diff --git a/frame_serialize/ImageMessage.h b/frame_serialize/ImageMessage.h
index b2a0fbde2..1fc05421f 100644
--- a/frame_serialize/ImageMessage.h
+++ b/frame_serialize/ImageMessage.h
@@ -31,8 +31,12 @@ struct DataMessage {
     uint64_t bunch_id;
     uint32_t jf_info;
     uint64_t timestamp;
+    uint32_t timestamp_base;
+
     uint32_t storage_cell;
+
     uint32_t exptime;
+    uint32_t exptime_base;
 
     std::string series_unique_id;
     uint64_t series_id;
diff --git a/frame_serialize/JFJochFrameDeserializer.cpp b/frame_serialize/JFJochFrameDeserializer.cpp
index 48ac1968a..e31e02fa8 100644
--- a/frame_serialize/JFJochFrameDeserializer.cpp
+++ b/frame_serialize/JFJochFrameDeserializer.cpp
@@ -93,6 +93,22 @@ inline uint64_t GetCBORMapLen(CborValue &value) {
     return array_len;
 }
 
+
+inline std::pair<uint64_t, uint64_t> GetRational(CborValue &value) {
+    std::pair<uint64_t, uint64_t> ret;
+    if (GetCBORArrayLen(value) != 2)
+        throw JFJochException(JFJochExceptionCategory::CBORError,
+                              "Rational number expects array of 2 elements");
+    CborValue array_value;
+
+    cborErr(cbor_value_enter_container(&value, &array_value));
+    ret.first = GetCBORUInt(array_value);
+    ret.second = GetCBORUInt(array_value);
+    cborErr(cbor_value_leave_container(&value, &array_value));
+
+    return ret;
+}
+
 inline void GetCBORFloatArray(CborValue &value, std::vector<float> &v) {
     if (GetCBORTag(value) != TagFloatLE)
         throw JFJochException(JFJochExceptionCategory::CBORError, "Incorrect array type tag");
@@ -350,12 +366,8 @@ void JFJochFrameDeserializer::ProcessImageMessageUserDataElement(CborValue &valu
             data_message.jf_info = GetCBORUInt(map_value) & UINT32_MAX;
         else if (key == "storage_cell")
             data_message.storage_cell = GetCBORUInt(map_value) & UINT32_MAX;
-        else if (key == "exptime")
-            data_message.exptime = GetCBORUInt(map_value) & UINT32_MAX;
         else if (key == "bunch_id")
             data_message.bunch_id = GetCBORUInt(map_value);
-        else if (key == "timestamp")
-            data_message.timestamp = GetCBORUInt(map_value);
         else
             cbor_value_advance(&map_value);
     }
@@ -376,7 +388,15 @@ bool JFJochFrameDeserializer::ProcessImageMessageElement(CborValue &value) {
             data_message.series_unique_id = GetCBORString(value);
         else if (key == "series_id")
             data_message.series_id = GetCBORUInt(value);
-        else if (key == "user_data")
+        else if (key == "real_time") {
+            auto r = GetRational(value);
+            data_message.exptime = r.first;
+            data_message.exptime_base = r.second;
+        } else if (key == "start_time") {
+            auto r = GetRational(value);
+            data_message.timestamp = r.first;
+            data_message.timestamp_base = r.second;
+        } else if (key == "user_data")
             ProcessImageMessageUserDataElement(value);
         else
             cbor_value_advance(&value);
diff --git a/frame_serialize/JFJochFrameSerializer.cpp b/frame_serialize/JFJochFrameSerializer.cpp
index 3b3c89c9e..f98831375 100644
--- a/frame_serialize/JFJochFrameSerializer.cpp
+++ b/frame_serialize/JFJochFrameSerializer.cpp
@@ -156,6 +156,15 @@ inline void CBOR_ENC(CborEncoder &encoder, const char* key, const std::vector<fl
     cborErr(cbor_encoder_close_container(&encoder, &arrayEncoder));
 }
 
+inline void CBOR_ENC_RATIONAL(CborEncoder &encoder, const char* key, uint64_t numerator, uint64_t denominator) {
+    CborEncoder arrayEncoder;
+    cborErr(cbor_encode_text_stringz(&encoder, key));
+    cborErr(cbor_encoder_create_array(&encoder, &arrayEncoder, 2));
+    cborErr(cbor_encode_uint(&arrayEncoder, numerator));
+    cborErr(cbor_encode_uint(&arrayEncoder, denominator));
+    cborErr(cbor_encoder_close_container(&encoder, &arrayEncoder));
+}
+
 inline void CBOR_ENC_RAD_INT_RESULT(CborEncoder &encoder, const char* key,
                                     const std::map<std::string, std::vector<float>> &rad_int_result) {
     CborEncoder mapEncoder;
@@ -404,24 +413,28 @@ void JFJochFrameSerializer::SerializeImage(const DataMessage& message) {
     cbor_encoder_init(&encoder, buffer, max_buffer_size, 0);
 
     cborErr(cbor_encode_tag(&encoder, CborSignatureTag ));
-    cborErr(cbor_encoder_create_map(&encoder, &mapEncoder, 6));
+    cborErr(cbor_encoder_create_map(&encoder, &mapEncoder, 9));
 
     CBOR_ENC(mapEncoder, "type", "image");
     CBOR_ENC(mapEncoder, "series_unique_id", message.series_unique_id);
     CBOR_ENC(mapEncoder, "series_id", message.series_id);
     CBOR_ENC(mapEncoder, "image_id", message.number);
+    CBOR_ENC_RATIONAL(mapEncoder, "real_time", message.exptime,
+                      message.exptime_base);
+    CBOR_ENC_RATIONAL(mapEncoder, "start_time", message.timestamp,
+                      message.timestamp_base);
+    CBOR_ENC_RATIONAL(mapEncoder, "end_time", message.timestamp + message.exptime,
+                      message.timestamp_base);
 
     cborErr(cbor_encode_text_stringz(&mapEncoder, "user_data"));
-    cborErr(cbor_encoder_create_map(&mapEncoder, &userDataMapEncoder, 8));
+    cborErr(cbor_encoder_create_map(&mapEncoder, &userDataMapEncoder, 6));
 
     CBOR_ENC(userDataMapEncoder, "spots", message.spots);
     CBOR_ENC(userDataMapEncoder, "rad_int_profile", message.rad_int_profile);
     CBOR_ENC(userDataMapEncoder, "indexing_result", message.indexing_result);
     CBOR_ENC(userDataMapEncoder, "bunch_id", message.bunch_id);
     CBOR_ENC(userDataMapEncoder, "jf_info", (uint64_t) message.jf_info);
-    CBOR_ENC(userDataMapEncoder, "timestamp", message.timestamp);
     CBOR_ENC(userDataMapEncoder, "storage_cell", (uint64_t) message.storage_cell);
-    CBOR_ENC(userDataMapEncoder, "exptime", (uint64_t) message.exptime);
     cborErr(cbor_encoder_close_container(&mapEncoder, &userDataMapEncoder));
 
     CBOR_ENC(mapEncoder, "data", message.image);
diff --git a/receiver/JFJochReceiver.cpp b/receiver/JFJochReceiver.cpp
index 078fbb9d9..9dded6983 100644
--- a/receiver/JFJochReceiver.cpp
+++ b/receiver/JFJochReceiver.cpp
@@ -347,6 +347,8 @@ int64_t JFJochReceiver::FrameTransformationThread() {
         try {
             DataMessage message{};
             message.number = image_number;
+            message.timestamp_base = 10*1000*1000;
+            message.exptime_base = 10*1000*1000;
 
             bool send_preview = false;
             bool send_bkg_estimate = false;
@@ -394,6 +396,8 @@ int64_t JFJochReceiver::FrameTransformationThread() {
                                     message.bunch_id = acquisition_device[d]->GetBunchID(frame_number, m);
                                     message.jf_info = acquisition_device[d]->GetJFInfo(frame_number, m);
                                     message.timestamp = acquisition_device[d]->GetTimestamp(frame_number, m);
+                                    message.exptime = acquisition_device[d]->GetExptime(frame_number, m);
+                                    message.storage_cell = (message.jf_info >> 8) & 0xF;
                                 }
                                 send_image = true;
                             } else