diff --git a/libpldm/platform.h b/libpldm/platform.h
index 696857d..cab1804 100644
--- a/libpldm/platform.h
+++ b/libpldm/platform.h
@@ -57,6 +57,16 @@
 	PLDM_EFFECTER_DATA_SIZE_SINT32
 };
 
+enum pldm_range_field_format {
+	PLDM_RANGE_FIELD_FORMAT_UINT8,
+	PLDM_RANGE_FIELD_FORMAT_SINT8,
+	PLDM_RANGE_FIELD_FORMAT_UINT16,
+	PLDM_RANGE_FIELD_FORMAT_SINT16,
+	PLDM_RANGE_FIELD_FORMAT_UINT32,
+	PLDM_RANGE_FIELD_FORMAT_SINT32,
+	PLDM_RANGE_FIELD_FORMAT_REAL32
+};
+
 enum set_request { PLDM_NO_CHANGE = 0x00, PLDM_REQUEST_SET = 0x01 };
 
 enum effecter_state { PLDM_INVALID_VALUE = 0xFF };
@@ -119,6 +129,7 @@
 /** @brief PLDM PDR types
  */
 enum pldm_pdr_types {
+	PLDM_NUMERIC_EFFECTER_PDR = 9,
 	PLDM_STATE_EFFECTER_PDR = 11,
 	PLDM_PDR_ENTITY_ASSOCIATION = 15,
 	PLDM_PDR_FRU_RECORD_SET = 20,
@@ -275,6 +286,79 @@
 	uint8_t possible_states[1];
 } __attribute__((packed));
 
+/** @union union_effecter_data_size
+ *
+ *  The bit width and format of reading and threshold values that the effecter
+ *  returns.
+ *  Refer to: DSP0248_1.2.0: 28.11 Table 87
+ */
+typedef union {
+	uint8_t value_u8;
+	int8_t value_s8;
+	uint16_t value_u16;
+	int16_t value_s16;
+	uint32_t value_u32;
+	int32_t value_s32;
+} union_effecter_data_size;
+
+/** @union union_range_field_format
+ *
+ *  Indicates the format used for the nominalValue, normalMax, and normalMin
+ *  fields.
+ *  Refer to: DSP0248_1.2.0: 28.11 Table 87
+ */
+typedef union {
+	uint8_t value_u8;
+	int8_t value_s8;
+	uint16_t value_u16;
+	int16_t value_s16;
+	uint32_t value_u32;
+	int32_t value_s32;
+	real32_t value_f32;
+} union_range_field_format;
+
+/** @struct pldm_numeric_effecter_value_pdr
+ *
+ *  Structure representing PLDM numeric effecter value PDR
+ */
+struct pldm_numeric_effecter_value_pdr {
+	struct pldm_pdr_hdr hdr;
+	uint16_t terminus_handle;
+	uint16_t effecter_id;
+	uint16_t entity_type;
+	uint16_t entity_instance;
+	uint16_t container_id;
+	uint16_t effecter_semantic_id;
+	uint8_t effecter_init;
+	bool8_t effecter_auxiliary_names;
+	uint8_t base_unit;
+	int8_t unit_modifier;
+	uint8_t rate_unit;
+	uint8_t base_oem_unit_handle;
+	uint8_t aux_unit;
+	int8_t aux_unit_modifier;
+	uint8_t aux_rate_unit;
+	uint8_t aux_oem_unit_handle;
+	bool8_t is_linear;
+	uint8_t effecter_data_size;
+	real32_t resolution;
+	real32_t offset;
+	uint16_t accuracy;
+	uint8_t plus_tolerance;
+	uint8_t minus_tolerance;
+	real32_t state_transition_interval;
+	real32_t transition_interval;
+	union_effecter_data_size max_set_table;
+	union_effecter_data_size min_set_table;
+	uint8_t range_field_format;
+	bitfield8_t range_field_support;
+	union_range_field_format nominal_value;
+	union_range_field_format normal_max;
+	union_range_field_format normal_min;
+	union_range_field_format rated_max;
+	union_range_field_format rated_min;
+} __attribute__((packed));
+
 /** @struct state_effecter_possible_states
  *
  *  Structure representing state enums for state effecter
diff --git a/libpldm/pldm_types.h b/libpldm/pldm_types.h
index 093d016..ee823a5 100644
--- a/libpldm/pldm_types.h
+++ b/libpldm/pldm_types.h
@@ -68,4 +68,6 @@
 	} __attribute__((packed)) bits;
 } bitfield32_t;
 
+typedef float real32_t;
+
 #endif /* PLDM_TYPES_H */
diff --git a/libpldmresponder/pdr_numeric_effecter.hpp b/libpldmresponder/pdr_numeric_effecter.hpp
new file mode 100644
index 0000000..63a4c26
--- /dev/null
+++ b/libpldmresponder/pdr_numeric_effecter.hpp
@@ -0,0 +1,185 @@
+#pragma once
+
+#include "libpldmresponder/pdr_utils.hpp"
+
+#include "libpldm/platform.h"
+
+namespace pldm
+{
+
+namespace responder
+{
+
+namespace pdr_numeric_effecter
+{
+
+using Json = nlohmann::json;
+
+static const Json empty{};
+
+/** @brief Parse PDR JSON file and generate numeric effecter PDR structure
+ *
+ *  @param[in] json - the JSON Object with the numeric effecter PDR
+ *  @param[out] handler - the Parser of PLDM command handler
+ *  @param[out] repo - pdr::RepoInterface
+ *
+ */
+template <class Handler>
+void generateNumericEffecterPDR(const Json& json, Handler& handler,
+                                pdr_utils::RepoInterface& repo)
+{
+    static const std::vector<Json> emptyList{};
+    auto entries = json.value("entries", emptyList);
+    for (const auto& e : entries)
+    {
+        std::vector<uint8_t> entry{};
+        entry.resize(sizeof(pldm_numeric_effecter_value_pdr));
+
+        pldm_numeric_effecter_value_pdr* pdr =
+            reinterpret_cast<pldm_numeric_effecter_value_pdr*>(entry.data());
+        pdr->hdr.record_handle = 0;
+        pdr->hdr.version = 1;
+        pdr->hdr.type = PLDM_NUMERIC_EFFECTER_PDR;
+        pdr->hdr.record_change_num = 0;
+        pdr->hdr.length =
+            sizeof(pldm_numeric_effecter_value_pdr) - sizeof(pldm_pdr_hdr);
+
+        pdr->terminus_handle = e.value("terminus_handle", 0);
+        pdr->effecter_id = handler.getNextEffecterId();
+        pdr->entity_type = e.value("entity_type", 0);
+        pdr->entity_instance = e.value("entity_instance", 0);
+        pdr->container_id = e.value("container_id", 0);
+        pdr->effecter_semantic_id = e.value("effecter_semantic_id", 0);
+        pdr->effecter_init = e.value("effecter_init", PLDM_NO_INIT);
+        pdr->effecter_auxiliary_names = e.value("effecter_init", false);
+        pdr->base_unit = e.value("base_unit", 0);
+        pdr->unit_modifier = e.value("unit_modifier", 0);
+        pdr->rate_unit = e.value("rate_unit", 0);
+        pdr->base_oem_unit_handle = e.value("base_oem_unit_handle", 0);
+        pdr->aux_unit = e.value("aux_unit", 0);
+        pdr->aux_unit_modifier = e.value("aux_unit_modifier", 0);
+        pdr->aux_oem_unit_handle = e.value("aux_oem_unit_handle", 0);
+        pdr->aux_rate_unit = e.value("aux_rate_unit", 0);
+        pdr->is_linear = e.value("is_linear", true);
+        pdr->effecter_data_size =
+            e.value("effecter_data_size", PLDM_EFFECTER_DATA_SIZE_UINT8);
+        pdr->resolution = e.value("effecter_resolution_init", 1.00);
+        pdr->offset = e.value("offset", 0.00);
+        pdr->accuracy = e.value("accuracy", 0);
+        pdr->plus_tolerance = e.value("plus_tolerance", 0);
+        pdr->minus_tolerance = e.value("minus_tolerance", 0);
+        pdr->state_transition_interval =
+            e.value("state_transition_interval", 0.00);
+        pdr->transition_interval = e.value("transition_interval", 0.00);
+        switch (pdr->effecter_data_size)
+        {
+            case PLDM_EFFECTER_DATA_SIZE_UINT8:
+                pdr->max_set_table.value_u8 = e.value("max_set_table", 0);
+                pdr->min_set_table.value_u8 = e.value("min_set_table", 0);
+                break;
+            case PLDM_EFFECTER_DATA_SIZE_SINT8:
+                pdr->max_set_table.value_s8 = e.value("max_set_table", 0);
+                pdr->min_set_table.value_s8 = e.value("min_set_table", 0);
+                break;
+            case PLDM_EFFECTER_DATA_SIZE_UINT16:
+                pdr->max_set_table.value_u16 = e.value("max_set_table", 0);
+                pdr->min_set_table.value_u16 = e.value("min_set_table", 0);
+                break;
+            case PLDM_EFFECTER_DATA_SIZE_SINT16:
+                pdr->max_set_table.value_s16 = e.value("max_set_table", 0);
+                pdr->min_set_table.value_s16 = e.value("min_set_table", 0);
+                break;
+            case PLDM_EFFECTER_DATA_SIZE_UINT32:
+                pdr->max_set_table.value_u32 = e.value("max_set_table", 0);
+                pdr->min_set_table.value_u32 = e.value("min_set_table", 0);
+                break;
+            case PLDM_EFFECTER_DATA_SIZE_SINT32:
+                pdr->max_set_table.value_s32 = e.value("max_set_table", 0);
+                pdr->min_set_table.value_s32 = e.value("min_set_table", 0);
+                break;
+            default:
+                break;
+        }
+
+        pdr->range_field_format =
+            e.value("range_field_format", PLDM_RANGE_FIELD_FORMAT_UINT8);
+        pdr->range_field_support.byte = e.value("range_field_support", 0);
+        switch (pdr->range_field_format)
+        {
+            case PLDM_RANGE_FIELD_FORMAT_UINT8:
+                pdr->nominal_value.value_u8 = e.value("nominal_value", 0);
+                pdr->normal_max.value_u8 = e.value("normal_max", 0);
+                pdr->normal_min.value_u8 = e.value("normal_min", 0);
+                pdr->rated_max.value_u8 = e.value("rated_max", 0);
+                pdr->rated_min.value_u8 = e.value("rated_min", 0);
+                break;
+            case PLDM_RANGE_FIELD_FORMAT_SINT8:
+                pdr->nominal_value.value_s8 = e.value("nominal_value", 0);
+                pdr->normal_max.value_s8 = e.value("normal_max", 0);
+                pdr->normal_min.value_s8 = e.value("normal_min", 0);
+                pdr->rated_max.value_s8 = e.value("rated_max", 0);
+                pdr->rated_min.value_s8 = e.value("rated_min", 0);
+                break;
+            case PLDM_RANGE_FIELD_FORMAT_UINT16:
+                pdr->nominal_value.value_u16 = e.value("nominal_value", 0);
+                pdr->normal_max.value_u16 = e.value("normal_max", 0);
+                pdr->normal_min.value_u16 = e.value("normal_min", 0);
+                pdr->rated_max.value_u16 = e.value("rated_max", 0);
+                pdr->rated_min.value_u16 = e.value("rated_min", 0);
+                break;
+            case PLDM_RANGE_FIELD_FORMAT_SINT16:
+                pdr->nominal_value.value_s16 = e.value("nominal_value", 0);
+                pdr->normal_max.value_s16 = e.value("normal_max", 0);
+                pdr->normal_min.value_s16 = e.value("normal_min", 0);
+                pdr->rated_max.value_s16 = e.value("rated_max", 0);
+                pdr->rated_min.value_s16 = e.value("rated_min", 0);
+                break;
+            case PLDM_RANGE_FIELD_FORMAT_UINT32:
+                pdr->nominal_value.value_u32 = e.value("nominal_value", 0);
+                pdr->normal_max.value_u32 = e.value("normal_max", 0);
+                pdr->normal_min.value_u32 = e.value("normal_min", 0);
+                pdr->rated_max.value_u32 = e.value("rated_max", 0);
+                pdr->rated_min.value_u32 = e.value("rated_min", 0);
+                break;
+            case PLDM_RANGE_FIELD_FORMAT_SINT32:
+                pdr->nominal_value.value_s32 = e.value("nominal_value", 0);
+                pdr->normal_max.value_s32 = e.value("normal_max", 0);
+                pdr->normal_min.value_s32 = e.value("normal_min", 0);
+                pdr->rated_max.value_s32 = e.value("rated_max", 0);
+                pdr->rated_min.value_s32 = e.value("rated_min", 0);
+                break;
+            case PLDM_RANGE_FIELD_FORMAT_REAL32:
+                pdr->nominal_value.value_f32 = e.value("nominal_value", 0);
+                pdr->normal_max.value_f32 = e.value("normal_max", 0);
+                pdr->normal_min.value_f32 = e.value("normal_min", 0);
+                pdr->rated_max.value_f32 = e.value("rated_max", 0);
+                pdr->rated_min.value_f32 = e.value("rated_min", 0);
+                break;
+            default:
+                break;
+        }
+
+        auto dbusEntry = e.value("dbus", empty);
+        auto objectPath = dbusEntry.value("path", "");
+        auto interface = dbusEntry.value("interface", "");
+        auto propertyName = dbusEntry.value("property_name", "");
+        auto propertyType = dbusEntry.value("property_type", "");
+        pldm::utils::DBusMapping dbusMapping{objectPath, interface,
+                                             propertyName, propertyType};
+        DbusMappings dbusMappings{};
+        DbusValMaps dbusValMaps{};
+        dbusMappings.emplace_back(std::move(dbusMapping));
+        handler.addDbusObjMaps(
+            pdr->effecter_id,
+            std::make_tuple(std::move(dbusMappings), std::move(dbusValMaps)));
+
+        pdr_utils::PdrEntry pdrEntry{};
+        pdrEntry.data = entry.data();
+        pdrEntry.size = sizeof(pldm_numeric_effecter_value_pdr);
+        repo.addRecord(pdrEntry);
+    }
+}
+
+} // namespace pdr_numeric_effecter
+} // namespace responder
+} // namespace pldm
diff --git a/libpldmresponder/platform.cpp b/libpldmresponder/platform.cpp
index eb08a8c..8d0cda0 100644
--- a/libpldmresponder/platform.cpp
+++ b/libpldmresponder/platform.cpp
@@ -1,6 +1,7 @@
 
 #include "platform.hpp"
 
+#include "pdr_numeric_effecter.hpp"
 #include "pdr_state_effecter.hpp"
 #include "utils.hpp"
 
@@ -73,6 +74,11 @@
          [this](const auto& json, RepoInterface& repo) {
              pdr_state_effecter::generateStateEffecterPDR<Handler>(json, *this,
                                                                    repo);
+         }},
+        {PLDM_NUMERIC_EFFECTER_PDR,
+         [this](const auto& json, RepoInterface& repo) {
+             pdr_numeric_effecter::generateNumericEffecterPDR<Handler>(
+                 json, *this, repo);
          }}};
 
     Type pdrType{};
diff --git a/test/libpldmresponder_pdr_state_effecter_test.cpp b/test/libpldmresponder_pdr_effecter_test.cpp
similarity index 75%
rename from test/libpldmresponder_pdr_state_effecter_test.cpp
rename to test/libpldmresponder_pdr_effecter_test.cpp
index e17fe89..72ca0c6 100644
--- a/test/libpldmresponder_pdr_state_effecter_test.cpp
+++ b/test/libpldmresponder_pdr_effecter_test.cpp
@@ -10,7 +10,7 @@
 using namespace pldm::responder::pdr;
 using namespace pldm::responder::pdr_utils;
 
-TEST(GeneratePDR, testGoodJson)
+TEST(GeneratePDRByStateEffecter, testGoodJson)
 {
     auto inPDRRepo = pldm_pdr_init();
     auto outPDRRepo = pldm_pdr_init();
@@ -103,6 +103,46 @@
     pldm_pdr_destroy(outPDRRepo);
 }
 
+TEST(GeneratePDRByNumericEffecter, testGoodJson)
+{
+    auto inPDRRepo = pldm_pdr_init();
+    auto outPDRRepo = pldm_pdr_init();
+    Repo outRepo(outPDRRepo);
+    Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr);
+    Repo inRepo(inPDRRepo);
+    getRepoByType(inRepo, outRepo, PLDM_NUMERIC_EFFECTER_PDR);
+
+    // 1 entries
+    ASSERT_EQ(outRepo.getRecordCount(), 1);
+
+    // Check first PDR
+    pdr_utils::PdrEntry e;
+    auto record = pdr::getRecordByHandle(outRepo, 3, e);
+    ASSERT_NE(record, nullptr);
+
+    pldm_numeric_effecter_value_pdr* pdr =
+        reinterpret_cast<pldm_numeric_effecter_value_pdr*>(e.data);
+    EXPECT_EQ(pdr->hdr.record_handle, 3);
+    EXPECT_EQ(pdr->hdr.version, 1);
+    EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR);
+    EXPECT_EQ(pdr->hdr.record_change_num, 0);
+    EXPECT_EQ(pdr->hdr.length,
+              sizeof(pldm_numeric_effecter_value_pdr) - sizeof(pldm_pdr_hdr));
+
+    EXPECT_EQ(pdr->effecter_id, 3);
+    EXPECT_EQ(pdr->effecter_data_size, 4);
+
+    const auto& [dbusMappings, dbusValMaps] =
+        handler.getDbusObjMaps(pdr->effecter_id);
+    EXPECT_EQ(dbusMappings[0].objectPath, "/foo/bar");
+    EXPECT_EQ(dbusMappings[0].interface, "xyz.openbmc_project.Foo.Bar");
+    EXPECT_EQ(dbusMappings[0].propertyName, "propertyName");
+    EXPECT_EQ(dbusMappings[0].propertyType, "uint64_t");
+
+    pldm_pdr_destroy(inPDRRepo);
+    pldm_pdr_destroy(outPDRRepo);
+}
+
 TEST(GeneratePDR, testNoJson)
 {
     auto pdrRepo = pldm_pdr_init();
diff --git a/test/meson.build b/test/meson.build
index b9d5b74..4bbdbc5 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -28,7 +28,7 @@
   'libpldmresponder_bios_config_test',
   'libpldmresponder_bios_integer_attribute_test',
   'libpldmresponder_bios_enum_attribute_test',
-  'libpldmresponder_pdr_state_effecter_test',
+  'libpldmresponder_pdr_effecter_test',
   'libpldmresponder_bios_table_test',
   'libpldmresponder_platform_test',
   'pldmd_instanceid_test',