diff --git a/libpldm/base.c b/libpldm/base.c
index c85aead..7354fb1 100644
--- a/libpldm/base.c
+++ b/libpldm/base.c
@@ -161,3 +161,100 @@
 
 	return PLDM_SUCCESS;
 }
+
+int encode_get_version_req(uint8_t instance_id, uint32_t transfer_handle,
+			   uint8_t transfer_opflag, uint8_t type,
+			   struct pldm_msg *msg)
+{
+	struct pldm_header_info header = {0};
+	int rc = PLDM_SUCCESS;
+
+	if (NULL == msg) {
+		return PLDM_ERROR_INVALID_DATA;
+	}
+
+	header.msg_type = PLDM_REQUEST;
+	header.instance = instance_id;
+	header.pldm_type = PLDM_BASE;
+	header.command = PLDM_GET_PLDM_VERSION;
+
+	if ((rc = pack_pldm_header(&header, &(msg->hdr))) > PLDM_SUCCESS) {
+		return rc;
+	}
+
+	uint8_t *dst = msg->body.payload;
+	transfer_handle = htole32(transfer_handle);
+	memcpy(dst, &transfer_handle, sizeof(transfer_handle));
+	dst += sizeof(transfer_handle);
+
+	memcpy(dst, &transfer_opflag, sizeof(transfer_opflag));
+	dst += sizeof(transfer_opflag);
+
+	memcpy(dst, &type, sizeof(type));
+
+	return PLDM_SUCCESS;
+}
+
+int encode_get_version_resp(uint8_t instance_id, uint8_t completion_code,
+			    uint32_t next_transfer_handle,
+			    uint8_t transfer_flag,
+			    const struct pldm_version *version_data,
+			    size_t version_size, struct pldm_msg *msg)
+{
+	struct pldm_header_info header = {0};
+	int rc = PLDM_SUCCESS;
+
+	msg->body.payload[0] = completion_code;
+	if (msg->body.payload[0] == PLDM_SUCCESS) {
+
+		header.msg_type = PLDM_RESPONSE;
+		header.instance = instance_id;
+		header.pldm_type = PLDM_BASE;
+		header.command = PLDM_GET_PLDM_VERSION;
+
+		if ((rc = pack_pldm_header(&header, &(msg->hdr))) >
+		    PLDM_SUCCESS) {
+			return rc;
+		}
+		uint8_t *dst = msg->body.payload + sizeof(msg->body.payload[0]);
+
+		next_transfer_handle = htole32(next_transfer_handle);
+
+		memcpy(dst, &next_transfer_handle,
+		       sizeof(next_transfer_handle));
+		dst += sizeof(next_transfer_handle);
+		memcpy(dst, &transfer_flag, sizeof(transfer_flag));
+
+		dst += sizeof(transfer_flag);
+		memcpy(dst, version_data, version_size);
+	}
+	return PLDM_SUCCESS;
+}
+
+int decode_get_version_req(const struct pldm_msg_payload *msg,
+			   uint32_t *transfer_handle, uint8_t *transfer_opflag,
+			   uint8_t *type)
+{
+	const uint8_t *start = msg->payload;
+	*transfer_handle = le32toh(*((uint32_t *)start));
+	*transfer_opflag = *(start + sizeof(*transfer_handle));
+	*type = *(start + sizeof(*transfer_handle) + sizeof(*transfer_opflag));
+
+	return PLDM_SUCCESS;
+}
+
+int decode_get_version_resp(const struct pldm_msg_payload *msg,
+			    uint32_t *next_transfer_handle,
+			    uint8_t *transfer_flag,
+			    struct pldm_version *version)
+{
+	const uint8_t *start = msg->payload + sizeof(uint8_t);
+	*next_transfer_handle = le32toh(*((uint32_t *)start));
+	*transfer_flag = *(start + sizeof(*next_transfer_handle));
+
+	*version =
+	    *((struct pldm_version *)(start + sizeof(*next_transfer_handle) +
+				      sizeof(*transfer_flag)));
+
+	return PLDM_SUCCESS;
+}
diff --git a/libpldm/base.h b/libpldm/base.h
index 65be648..b2050a5 100644
--- a/libpldm/base.h
+++ b/libpldm/base.h
@@ -18,6 +18,7 @@
 /** @brief PLDM Commands
  */
 enum pldm_supported_commands {
+	PLDM_GET_PLDM_VERSION = 0x3,
 	PLDM_GET_PLDM_TYPES = 0x4,
 	PLDM_GET_PLDM_COMMANDS = 0x5
 };
@@ -34,6 +35,18 @@
 	PLDM_ERROR_INVALID_PLDM_TYPE = 0x20
 };
 
+enum transfer_op_flag {
+	PLDM_GET_NEXTPART = 0,
+	PLDM_GET_FIRSTPART = 1,
+};
+
+enum transfer_resp_flag {
+	PLDM_START = 0x01,
+	PLDM_MIDDLE = 0x02,
+	PLDM_END = 0x04,
+	PLDM_START_AND_END = 0x05,
+};
+
 /** @enum MessageType
  *
  *  The different message types supported by the PLDM specification.
@@ -51,10 +64,13 @@
 
 /* Message payload lengths */
 #define PLDM_GET_COMMANDS_REQ_BYTES 5
+#define PLDM_GET_VERSION_REQ_BYTES 6
 
 /* Response lengths are inclusive of completion code */
 #define PLDM_GET_TYPES_RESP_BYTES 9
 #define PLDM_GET_COMMANDS_RESP_BYTES 33
+/* Response data has only one version and does not contain the checksum */
+#define PLDM_GET_VERSION_RESP_BYTES 10
 
 /** @struct pldm_msg_hdr
  *
@@ -197,6 +213,38 @@
 int decode_get_commands_resp(const struct pldm_msg_payload *msg,
 			     uint8_t *commands);
 
+/* GetPLDMVersion */
+
+/** @brief Create a PLDM request for GetPLDMVersion
+ *
+ *  @param[in] instance_id - Message's instance id
+ *  @param[in] transfer_handle - Handle to identify PLDM version data transfer.
+ *         This handle is ignored by the responder when the
+ *         transferop_flag is set to getFirstPart.
+ *  @param[in] transfer_opflag - flag to indicate whether it is start of
+ *         transfer
+ *  @param[in] type -  PLDM Type for which version is requested
+ *  @param[in,out] msg - Message will be written to this
+ *  @return pldm_completion_codes
+ *  @note  Caller is responsible for memory alloc and dealloc of param
+ *         'msg.body.payload'
+ */
+int encode_get_version_req(uint8_t instance_id, uint32_t transfer_handle,
+			   uint8_t transfer_opflag, uint8_t type,
+			   struct pldm_msg *msg);
+
+/** @brief Decode a GetPLDMVersion response message
+ *
+ *  @param[in] msg - Response message payload
+ *  @param[out] next_transfer_handle - the next handle for the next part of data
+ *  @param[out] transfer_flag - flag to indicate the part of data
+ *  @return pldm_completion_codes
+ */
+int decode_get_version_resp(const struct pldm_msg_payload *msg,
+			    uint32_t *next_transfer_handle,
+			    uint8_t *transfer_flag,
+			    struct pldm_version *version);
+
 /* Responder */
 
 /* GetPLDMTypes */
@@ -241,6 +289,40 @@
 int encode_get_commands_resp(uint8_t instance_id, uint8_t completion_code,
 			     const uint8_t *commands, struct pldm_msg *msg);
 
+/* GetPLDMVersion */
+
+/** @brief Create a PLDM response for GetPLDMVersion
+ *
+ *  @param[in] instance_id - Message's instance id
+ *  @param[in] completion_code - PLDM completion code
+ *  @param[in] next_transfer_handle - Handle to identify next portion of
+ *              data transfer
+ *  @param[in] transfer_flag - Represents the part of transfer
+ *  @param[in] version_data - the version data
+ *  @param[in] version_size - size of version data
+ *  @param[in,out] msg - Message will be written to this
+ *  @return pldm_completion_codes
+ *  @note  Caller is responsible for memory alloc and dealloc of param
+ *         'msg.body.payload'
+ */
+int encode_get_version_resp(uint8_t instance_id, uint8_t completion_code,
+			    uint32_t next_transfer_handle,
+			    uint8_t transfer_flag,
+			    const struct pldm_version *version_data,
+			    size_t version_size, struct pldm_msg *msg);
+
+/** @brief Decode a GetPLDMVersion request message
+ *
+ *  @param[in] msg - Request message payload
+ *  @param[out] transfer_handle - the handle of data
+ *  @param[out] transfer_opflag - Transfer Flag
+ *  @param[out] type - PLDM type for which version is requested
+ *  @return pldm_completion_codes
+ */
+int decode_get_version_req(const struct pldm_msg_payload *msg,
+			   uint32_t *transfer_handle, uint8_t *transfer_opflag,
+			   uint8_t *type);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/libpldmresponder/base.cpp b/libpldmresponder/base.cpp
index f3bb8f4..9489d47 100644
--- a/libpldmresponder/base.cpp
+++ b/libpldmresponder/base.cpp
@@ -3,6 +3,7 @@
 #include "base.hpp"
 
 #include <array>
+#include <cstring>
 #include <map>
 #include <stdexcept>
 #include <vector>
@@ -17,6 +18,10 @@
 static const std::map<Type, Cmd> capabilities{
     {PLDM_BASE, {PLDM_GET_PLDM_TYPES, PLDM_GET_PLDM_COMMANDS}}};
 
+static const std::map<Type, pldm_version> versions{
+    {PLDM_BASE, {0xF1, 0xF0, 0xF0, 0x00}},
+};
+
 void getPLDMTypes(const pldm_msg_payload* request, pldm_msg* response)
 {
     // DSP0240 has this as a bitfield8[N], where N = 0 to 7
@@ -66,5 +71,36 @@
     encode_get_commands_resp(0, PLDM_SUCCESS, cmds.data(), response);
 }
 
+void getPLDMVersion(const pldm_msg_payload* request, pldm_msg* response)
+{
+    uint32_t transferHandle;
+    Type type;
+    uint8_t transferFlag;
+
+    if (request->payload_length !=
+        (sizeof(transferHandle) + sizeof(type) + sizeof(transferFlag)))
+    {
+        encode_get_version_resp(0, PLDM_ERROR_INVALID_LENGTH, 0, 0, nullptr, 0,
+                                response);
+        return;
+    }
+
+    decode_get_version_req(request, &transferHandle, &transferFlag, &type);
+
+    pldm_version version{};
+    auto search = versions.find(type);
+
+    if (search == versions.end())
+    {
+        encode_get_version_resp(0, PLDM_ERROR_INVALID_PLDM_TYPE, 0, 0, nullptr,
+                                0, response);
+        return;
+    }
+
+    memcpy(&version, &(search->second), sizeof(version));
+    encode_get_version_resp(0, PLDM_SUCCESS, 0, PLDM_START_AND_END, &version,
+                            sizeof(pldm_version), response);
+}
+
 } // namespace responder
 } // namespace pldm
diff --git a/libpldmresponder/base.hpp b/libpldmresponder/base.hpp
index e4351d4..74bc4af 100644
--- a/libpldmresponder/base.hpp
+++ b/libpldmresponder/base.hpp
@@ -28,5 +28,12 @@
  */
 void getPLDMCommands(const pldm_msg_payload* request, pldm_msg* response);
 
+/** @brief Handler for getPLDMCommands
+ *
+ *  @param[in] request - Request message payload
+ *  @param[out] response - Response messsage written here
+ */
+void getPLDMVersion(const pldm_msg_payload* request, pldm_msg* response);
+
 } // namespace responder
 } // namespace pldm
diff --git a/test/libpldm_base_test.cpp b/test/libpldm_base_test.cpp
index 04d14c0..9a37ec6 100644
--- a/test/libpldm_base_test.cpp
+++ b/test/libpldm_base_test.cpp
@@ -300,3 +300,116 @@
     ASSERT_EQ(response.payload[2], outTypes[1]);
     ASSERT_EQ(response.payload[3], outTypes[2]);
 }
+
+TEST(GetPLDMVersion, testEncodeRequest)
+{
+    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestMsg{};
+    pldm_msg request{};
+    request.body.payload = requestMsg.data();
+    request.body.payload_length = requestMsg.size();
+    uint8_t pldmType = 0x03;
+    uint32_t transferHandle = 0x0;
+    uint8_t opFlag = 0x01;
+
+    auto rc =
+        encode_get_version_req(0, transferHandle, opFlag, pldmType, &request);
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(0, memcmp(request.body.payload, &transferHandle,
+                        sizeof(transferHandle)));
+    ASSERT_EQ(0, memcmp(request.body.payload + sizeof(transferHandle), &opFlag,
+                        sizeof(opFlag)));
+    ASSERT_EQ(0, memcmp(request.body.payload + sizeof(transferHandle) +
+                            sizeof(opFlag),
+                        &pldmType, sizeof(pldmType)));
+}
+
+TEST(GetPLDMVersion, testEncodeResponse)
+{
+    pldm_msg response{};
+    uint8_t completionCode = 0;
+    uint32_t transferHandle = 0;
+    uint8_t flag = PLDM_START_AND_END;
+    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
+    response.body.payload = responseMsg.data();
+    response.body.payload_length = responseMsg.size();
+    struct pldm_version version = {0xFF, 0xFF, 0xFF, 0xFF};
+
+    auto rc =
+        encode_get_version_resp(0, PLDM_SUCCESS, 0, PLDM_START_AND_END,
+                                &version, sizeof(pldm_version), &response);
+
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(completionCode, response.body.payload[0]);
+    ASSERT_EQ(0,
+              memcmp(response.body.payload + sizeof(response.body.payload[0]),
+                     &transferHandle, sizeof(transferHandle)));
+    ASSERT_EQ(0,
+              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
+                         sizeof(transferHandle),
+                     &flag, sizeof(flag)));
+    ASSERT_EQ(0,
+              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
+                         sizeof(transferHandle) + sizeof(flag),
+                     &version, sizeof(version)));
+}
+
+TEST(GetPLDMVersion, testDecodeRequest)
+{
+    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestMsg{};
+    pldm_msg_payload request{};
+    request.payload = requestMsg.data();
+    request.payload_length = requestMsg.size();
+    uint32_t transferHandle = 0x0;
+    uint32_t retTransferHandle = 0x0;
+    uint8_t flag = PLDM_GET_FIRSTPART;
+    uint8_t retFlag = PLDM_GET_FIRSTPART;
+    uint8_t pldmType = PLDM_BASE;
+    uint8_t retType = PLDM_BASE;
+
+    memcpy(request.payload, &transferHandle, sizeof(transferHandle));
+    memcpy(request.payload + sizeof(transferHandle), &flag, sizeof(flag));
+    memcpy(request.payload + sizeof(transferHandle) + sizeof(flag), &pldmType,
+           sizeof(pldmType));
+
+    auto rc = decode_get_version_req(&request, &retTransferHandle, &retFlag,
+                                     &retType);
+
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(transferHandle, retTransferHandle);
+    ASSERT_EQ(flag, retFlag);
+    ASSERT_EQ(pldmType, retType);
+}
+
+TEST(GetPLDMVersion, testDecodeResponse)
+{
+    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
+    pldm_msg_payload response{};
+    response.payload = responseMsg.data();
+    response.payload_length = responseMsg.size();
+    uint32_t transferHandle = 0x0;
+    uint32_t retTransferHandle = 0x0;
+    uint8_t flag = PLDM_START_AND_END;
+    uint8_t retFlag = PLDM_START_AND_END;
+    uint8_t completionCode = 0;
+    struct pldm_version version = {0xFF, 0xFF, 0xFF, 0xFF};
+    struct pldm_version versionOut;
+
+    memcpy(response.payload + sizeof(completionCode), &transferHandle,
+           sizeof(transferHandle));
+    memcpy(response.payload + sizeof(completionCode) + sizeof(transferHandle),
+           &flag, sizeof(flag));
+    memcpy(response.payload + sizeof(completionCode) + sizeof(transferHandle) +
+               sizeof(flag),
+           &version, sizeof(version));
+
+    auto rc = decode_get_version_resp(&response, &retTransferHandle, &retFlag,
+                                      &versionOut);
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(transferHandle, retTransferHandle);
+    ASSERT_EQ(flag, retFlag);
+
+    ASSERT_EQ(versionOut.major, version.major);
+    ASSERT_EQ(versionOut.minor, version.minor);
+    ASSERT_EQ(versionOut.update, version.update);
+    ASSERT_EQ(versionOut.alpha, version.alpha);
+}
diff --git a/test/libpldmresponder_base_test.cpp b/test/libpldmresponder_base_test.cpp
index 2bd6ebd..a34d80f 100644
--- a/test/libpldmresponder_base_test.cpp
+++ b/test/libpldmresponder_base_test.cpp
@@ -57,3 +57,41 @@
     getPLDMCommands(&request, &response);
     ASSERT_EQ(response.body.payload[0], PLDM_ERROR_INVALID_PLDM_TYPE);
 }
+
+TEST(GetPLDMVersion, testGoodRequest)
+{
+    pldm_msg response{};
+    std::array<uint8_t, PLDM_GET_VERSION_RESP_BYTES> responseMsg{};
+    response.body.payload = responseMsg.data();
+    response.body.payload_length = responseMsg.size();
+    pldm_msg request{};
+    std::array<uint8_t, PLDM_GET_VERSION_REQ_BYTES> requestPayload{};
+    request.body.payload = requestPayload.data();
+    request.body.payload_length = requestPayload.size();
+
+    uint8_t pldmType = PLDM_BASE;
+    uint32_t transferHandle = 0x0;
+    uint8_t flag = PLDM_GET_FIRSTPART;
+    uint8_t retFlag = PLDM_START_AND_END;
+    struct pldm_version version = {0xF1, 0xF0, 0xF0, 0x00};
+
+    auto rc =
+        encode_get_version_req(0, transferHandle, flag, pldmType, &request);
+
+    ASSERT_EQ(0, rc);
+
+    getPLDMVersion(&(request.body), &response);
+
+    ASSERT_EQ(response.body.payload[0], 0);
+    ASSERT_EQ(0,
+              memcmp(response.body.payload + sizeof(response.body.payload[0]),
+                     &transferHandle, sizeof(transferHandle)));
+    ASSERT_EQ(0,
+              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
+                         sizeof(transferHandle),
+                     &retFlag, sizeof(flag)));
+    ASSERT_EQ(0,
+              memcmp(response.body.payload + sizeof(response.body.payload[0]) +
+                         sizeof(transferHandle) + sizeof(flag),
+                     &version, sizeof(version)));
+}