diff --git a/CHANGELOG.md b/CHANGELOG.md
index 01818a5..608435e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -45,6 +45,8 @@
 
 - file: Add encode req & decode resp for DfClose command.
 
+- file: Add encode req & decode resp for DfHeartbeat command.
+
 ### Changed
 
 - dsp: firmware_update: Expand "params" in symbol names
diff --git a/include/libpldm/file.h b/include/libpldm/file.h
index 320fed8..425f017 100644
--- a/include/libpldm/file.h
+++ b/include/libpldm/file.h
@@ -12,10 +12,12 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#define PLDM_DF_OPEN_REQ_BYTES	 4
-#define PLDM_DF_OPEN_RESP_BYTES	 3
-#define PLDM_DF_CLOSE_REQ_BYTES	 4
-#define PLDM_DF_CLOSE_RESP_BYTES 1
+#define PLDM_DF_OPEN_REQ_BYTES	     4
+#define PLDM_DF_OPEN_RESP_BYTES	     3
+#define PLDM_DF_CLOSE_REQ_BYTES	     4
+#define PLDM_DF_CLOSE_RESP_BYTES     1
+#define PLDM_DF_HEARTBEAT_REQ_BYTES  6
+#define PLDM_DF_HEARTBEAT_RESP_BYTES 5
 
 /** @brief PLDM File Transfer Completion Code */
 enum pldm_file_cc {
@@ -79,6 +81,24 @@
 	uint8_t completion_code;
 };
 
+/** @struct pldm_file_df_heartbeat_req
+ *
+ *  Structure representing PLDM File DfHeartbeat request.
+ */
+struct pldm_file_df_heartbeat_req {
+	uint16_t file_descriptor;
+	uint32_t requester_max_interval;
+};
+
+/** @struct pldm_file_df_heartbeat_resp
+ *
+ *  Structure representing PLDM File DfHearbeat response.
+ */
+struct pldm_file_df_heartbeat_resp {
+	uint8_t completion_code;
+	uint32_t responder_max_interval;
+};
+
 /** @brief Create a PLDM request message for DFOpen
  *
  *  @param[in] instance_id - Message's instance id
@@ -143,6 +163,40 @@
 				   size_t payload_length,
 				   struct pldm_file_df_close_resp *resp);
 
+/** @brief Create a PLDM request message for DFHeartbeat
+ *
+ *  @param[in] instance_id - Message's instance id
+ *  @param[in] req - The pointer to the request message to be encoded
+ *  @param[in,out] msg - Message will be written to this
+ *  @param[in] payload_length - Length of the request message payload
+ *  @return 0 on success
+ *          -EINVAL if the input parameters' memory are not allocated,
+ *          or message type or instance in request header is invalid
+ *          -ENOMSG if the PLDM type in the request header is invalid
+ *          -EOVERFLOW if the input message length is invalid
+ *  @note  Caller is responsible for memory alloc and dealloc of param
+ *         'msg.payload'
+ */
+int encode_pldm_file_df_heartbeat_req(
+	uint8_t instance_id, const struct pldm_file_df_heartbeat_req *req,
+	struct pldm_msg *msg, size_t payload_length);
+
+/** @brief Decode DFHeartbeat response data
+ *
+ *  @param[in] msg - Response message
+ *  @param[in] payload_length - Length of response message payload
+ *  @param[out] resp - pointer to the decoded response message
+ *  @return 0 on success
+ *          -EINVAL if the input parameters' memory are not allocated
+ *          -EOVERFLOW if the input message buffer is too short for the output
+ *          response struct
+ *          -EBADMSG if the input message buffer is too large for the output
+ *          response struct
+*/
+int decode_pldm_file_df_heartbeat_resp(const struct pldm_msg *msg,
+				       size_t payload_length,
+				       struct pldm_file_df_heartbeat_resp *resp);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/dsp/file.c b/src/dsp/file.c
index 05dba3b..fb3d1de 100644
--- a/src/dsp/file.c
+++ b/src/dsp/file.c
@@ -126,3 +126,68 @@
 
 	return 0;
 }
+
+LIBPLDM_ABI_TESTING
+int encode_pldm_file_df_heartbeat_req(
+	uint8_t instance_id, const struct pldm_file_df_heartbeat_req *req,
+	struct pldm_msg *msg, size_t payload_length)
+{
+	PLDM_MSGBUF_DEFINE_P(buf);
+	int rc;
+
+	if (!req || !msg) {
+		return -EINVAL;
+	}
+
+	struct pldm_header_info header = { 0 };
+	header.instance = instance_id;
+	header.msg_type = PLDM_REQUEST;
+	header.pldm_type = PLDM_FILE;
+	header.command = PLDM_FILE_CMD_DF_HEARTBEAT;
+
+	rc = pack_pldm_header_errno(&header, &(msg->hdr));
+	if (rc) {
+		return rc;
+	}
+
+	rc = pldm_msgbuf_init_errno(buf, PLDM_DF_HEARTBEAT_REQ_BYTES,
+				    msg->payload, payload_length);
+	if (rc) {
+		return rc;
+	}
+
+	pldm_msgbuf_insert(buf, req->file_descriptor);
+	pldm_msgbuf_insert(buf, req->requester_max_interval);
+
+	return pldm_msgbuf_complete(buf);
+}
+
+LIBPLDM_ABI_TESTING
+int decode_pldm_file_df_heartbeat_resp(const struct pldm_msg *msg,
+				       size_t payload_length,
+				       struct pldm_file_df_heartbeat_resp *resp)
+{
+	PLDM_MSGBUF_DEFINE_P(buf);
+	int rc;
+
+	if (!msg || !resp) {
+		return -EINVAL;
+	}
+
+	rc = pldm_msg_has_error(msg, payload_length);
+	if (rc) {
+		resp->completion_code = rc;
+		return 0;
+	}
+
+	rc = pldm_msgbuf_init_errno(buf, PLDM_DF_HEARTBEAT_RESP_BYTES,
+				    msg->payload, payload_length);
+	if (rc) {
+		return rc;
+	}
+
+	pldm_msgbuf_extract(buf, resp->completion_code);
+	pldm_msgbuf_extract(buf, resp->responder_max_interval);
+
+	return pldm_msgbuf_complete_consumed(buf);
+}
diff --git a/tests/dsp/file.cpp b/tests/dsp/file.cpp
index 50d6bca..93ba847 100644
--- a/tests/dsp/file.cpp
+++ b/tests/dsp/file.cpp
@@ -286,3 +286,158 @@
     EXPECT_EQ(rc, -EINVAL);
 }
 #endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(EncodeDfHeartbeatReq, GoodTest)
+{
+    uint8_t instance_id = 0;
+    uint16_t file_descriptor = 0x0200;
+    uint32_t requester_max_interval = 0x88130000; // 5000 ms
+    std::array<uint8_t, PLDM_DF_HEARTBEAT_REQ_BYTES> requestMsg = {
+        0x00, 0x02, 0x00, 0x00, 0x13, 0x88};
+
+    const struct pldm_file_df_heartbeat_req req_data = {file_descriptor,
+                                                        requester_max_interval};
+
+    PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES);
+    auto rc = encode_pldm_file_df_heartbeat_req(
+        instance_id, &req_data, requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES);
+
+    ASSERT_EQ(rc, 0);
+    EXPECT_EQ(
+        0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg)));
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(EncodeDfHeartbeatReq, BadTestUnAllocatedPtrParams)
+{
+    uint8_t instance_id = 0;
+    uint16_t file_descriptor = 0x0200;
+    uint32_t requester_max_interval = 0x88130000; // 5000 ms
+    int rc;
+
+    const struct pldm_file_df_heartbeat_req req_data = {file_descriptor,
+                                                        requester_max_interval};
+
+    PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES);
+    rc = encode_pldm_file_df_heartbeat_req(instance_id, &req_data, nullptr,
+                                           PLDM_DF_HEARTBEAT_REQ_BYTES);
+    EXPECT_EQ(rc, -EINVAL);
+
+    rc = encode_pldm_file_df_heartbeat_req(instance_id, nullptr, requestPtr,
+                                           PLDM_DF_HEARTBEAT_REQ_BYTES);
+    EXPECT_EQ(rc, -EINVAL);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(EncodeDfHeartbeatReq, BadTestInvalidExpectedOutputMsgLength)
+{
+    uint8_t instance_id = 0;
+    uint16_t file_descriptor = 0x0200;
+    uint32_t requester_max_interval = 0x88130000; // 5000 ms
+    int rc;
+
+    const struct pldm_file_df_heartbeat_req req_data = {file_descriptor,
+                                                        requester_max_interval};
+
+    PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES);
+    rc = encode_pldm_file_df_heartbeat_req(instance_id, &req_data, requestPtr,
+                                           1);
+    EXPECT_EQ(rc, -EOVERFLOW);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(DecodeDfHeartbeatResp, GoodTest)
+{
+    uint8_t completion_code = PLDM_SUCCESS;
+    uint32_t responder_max_interval = 0xa00f0000; // 4000 ms
+
+    struct pldm_file_df_heartbeat_resp resp_data = {};
+
+    PLDM_MSGBUF_DEFINE_P(buf);
+    int rc;
+
+    static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES;
+
+    PLDM_MSG_DEFINE_P(responseMsg, payload_length);
+
+    rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
+    ASSERT_EQ(rc, 0);
+
+    pldm_msgbuf_insert_uint8(buf, completion_code);
+    pldm_msgbuf_insert_uint32(buf, responder_max_interval);
+
+    ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
+
+    rc = decode_pldm_file_df_heartbeat_resp(responseMsg, payload_length,
+                                            &resp_data);
+
+    ASSERT_EQ(rc, 0);
+    EXPECT_EQ(resp_data.completion_code, completion_code);
+    EXPECT_EQ(resp_data.responder_max_interval, responder_max_interval);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(DecodeDfHeartbeatResp, BadTestUnAllocatedPtrParams)
+{
+    uint8_t completion_code = PLDM_SUCCESS;
+    uint32_t responder_max_interval = 0xa00f0000; // 4000 ms
+
+    struct pldm_file_df_heartbeat_resp resp_data = {};
+
+    PLDM_MSGBUF_DEFINE_P(buf);
+    int rc;
+
+    static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES;
+
+    PLDM_MSG_DEFINE_P(responseMsg, payload_length);
+
+    rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
+    ASSERT_EQ(rc, 0);
+
+    pldm_msgbuf_insert_uint8(buf, completion_code);
+    pldm_msgbuf_insert_uint32(buf, responder_max_interval);
+
+    ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
+
+    rc =
+        decode_pldm_file_df_heartbeat_resp(nullptr, payload_length, &resp_data);
+    EXPECT_EQ(rc, -EINVAL);
+
+    rc = decode_pldm_file_df_heartbeat_resp(responseMsg, payload_length,
+                                            nullptr);
+    EXPECT_EQ(rc, -EINVAL);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(DecodeDfHeartbeatResp, BadTestInvalidExpectedInputMsgLength)
+{
+    uint8_t completion_code = PLDM_SUCCESS;
+    uint32_t responder_max_interval = 0xa00f0000; // 4000 ms
+
+    struct pldm_file_df_heartbeat_resp resp_data = {};
+
+    PLDM_MSGBUF_DEFINE_P(buf);
+    int rc;
+
+    static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES;
+
+    PLDM_MSG_DEFINE_P(responseMsg, payload_length);
+
+    rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
+    ASSERT_EQ(rc, 0);
+
+    pldm_msgbuf_insert_uint8(buf, completion_code);
+    pldm_msgbuf_insert_uint32(buf, responder_max_interval);
+
+    ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
+
+    rc = decode_pldm_file_df_heartbeat_resp(responseMsg, 0, &resp_data);
+    EXPECT_EQ(rc, -EOVERFLOW);
+}
+#endif