diff --git a/fw-update/manager.hpp b/fw-update/manager.hpp
index 14ac450..db5cb64 100644
--- a/fw-update/manager.hpp
+++ b/fw-update/manager.hpp
@@ -98,6 +98,16 @@
         return updateManager.handleRequest(eid, command, request, reqMsgLen);
     }
 
+    /** @brief Get Active EIDs.
+     *
+     *  @param[in] addr - MCTP address of terminus
+     *  @param[in] terminiNames - MCTP terminus name
+     */
+    std::optional<mctp_eid_t> getActiveEidByName(const std::string&)
+    {
+        return std::nullopt;
+    }
+
   private:
     /** Descriptor information of all the discovered MCTP endpoints */
     DescriptorMap descriptorMap;
diff --git a/host-bmc/dbus_to_terminus_effecters.cpp b/host-bmc/dbus_to_terminus_effecters.cpp
index 5c2e0ee..0c27f95 100644
--- a/host-bmc/dbus_to_terminus_effecters.cpp
+++ b/host-bmc/dbus_to_terminus_effecters.cpp
@@ -67,6 +67,7 @@
     {
         EffecterInfo effecterInfo;
         effecterInfo.mctpEid = entry.value("mctp_eid", 0xFF);
+        effecterInfo.terminusName = entry.value("terminus_name", "");
         auto jsonEffecterInfo = entry.value("effecter_info", empty);
         auto effecterId =
             jsonEffecterInfo.value("effecterID", PLDM_INVALID_EFFECTER_ID);
@@ -469,7 +470,17 @@
     size_t effecterInfoIndex, uint16_t effecterId, uint8_t dataSize,
     double rawValue)
 {
+    std::string terminusName = hostEffecterInfo[effecterInfoIndex].terminusName;
     uint8_t& mctpEid = hostEffecterInfo[effecterInfoIndex].mctpEid;
+    if (!terminusName.empty())
+    {
+        auto tmpEid = platformManager->getActiveEidByName(terminusName);
+        if (tmpEid)
+        {
+            mctpEid = tmpEid.value();
+        }
+    }
+
     auto instanceId = instanceIdDb->next(mctpEid);
     int rc = PLDM_ERROR;
     std::vector<uint8_t> requestMsg;
@@ -597,7 +608,17 @@
     size_t effecterInfoIndex, std::vector<set_effecter_state_field>& stateField,
     uint16_t effecterId)
 {
+    std::string terminusName = hostEffecterInfo[effecterInfoIndex].terminusName;
     uint8_t& mctpEid = hostEffecterInfo[effecterInfoIndex].mctpEid;
+    if (!terminusName.empty())
+    {
+        auto tmpEid = platformManager->getActiveEidByName(terminusName);
+        if (tmpEid)
+        {
+            mctpEid = tmpEid.value();
+        }
+    }
+
     uint8_t& compEffCnt = hostEffecterInfo[effecterInfoIndex].compEffecterCnt;
     auto instanceId = instanceIdDb->next(mctpEid);
 
diff --git a/host-bmc/dbus_to_terminus_effecters.hpp b/host-bmc/dbus_to_terminus_effecters.hpp
index 038f869..962865c 100644
--- a/host-bmc/dbus_to_terminus_effecters.hpp
+++ b/host-bmc/dbus_to_terminus_effecters.hpp
@@ -3,6 +3,7 @@
 #include "common/instance_id.hpp"
 #include "common/types.hpp"
 #include "common/utils.hpp"
+#include "platform-mc/manager.hpp"
 #include "requester/handler.hpp"
 
 #include <phosphor-logging/lg2.hpp>
@@ -62,6 +63,7 @@
 struct EffecterInfo
 {
     uint8_t mctpEid;             //!< Host mctp eid
+    std::string terminusName;    //!< Terminus name
     uint8_t effecterPdrType;     //!< Effecter PDR type state/numeric
     uint16_t containerId;        //!< Container Id for host effecter
     uint16_t entityType;         //!< Entity type for the host effecter
@@ -102,9 +104,11 @@
         pldm::InstanceIdDb* instanceIdDb, int fd, const pldm_pdr* repo,
         pldm::utils::DBusHandler* const dbusHandler,
         const std::string& jsonPath,
-        pldm::requester::Handler<pldm::requester::Request>* handler) :
+        pldm::requester::Handler<pldm::requester::Request>* handler,
+        platform_mc::Manager* platformManager) :
         instanceIdDb(instanceIdDb), sockFd(fd), pdrRepo(repo),
-        dbusHandler(dbusHandler), handler(handler)
+        dbusHandler(dbusHandler), handler(handler),
+        platformManager(platformManager)
     {
         try
         {
@@ -245,6 +249,9 @@
     const pldm::utils::DBusHandler* dbusHandler; //!< D-bus Handler
     /** @brief PLDM request handler */
     pldm::requester::Handler<pldm::requester::Request>* handler;
+
+    /** @brief MC Platform manager*/
+    platform_mc::Manager* platformManager = nullptr;
 };
 
 } // namespace host_effecters
diff --git a/host-bmc/test/dbus_to_terminus_effecter_test.cpp b/host-bmc/test/dbus_to_terminus_effecter_test.cpp
index f8ff8d6..6b02074 100644
--- a/host-bmc/test/dbus_to_terminus_effecter_test.cpp
+++ b/host-bmc/test/dbus_to_terminus_effecter_test.cpp
@@ -15,7 +15,8 @@
     MockHostEffecterParser(int fd, const pldm_pdr* repo,
                            DBusHandler* const dbusHandler,
                            const std::string& jsonPath) :
-        HostEffecterParser(nullptr, fd, repo, dbusHandler, jsonPath, nullptr)
+        HostEffecterParser(nullptr, fd, repo, dbusHandler, jsonPath, nullptr,
+                           nullptr)
     {}
 
     MOCK_METHOD(int, setHostStateEffecter,
diff --git a/platform-mc/manager.hpp b/platform-mc/manager.hpp
index 039d6f9..45a311a 100644
--- a/platform-mc/manager.hpp
+++ b/platform-mc/manager.hpp
@@ -255,6 +255,17 @@
      */
     exec::task<int> oemPollForPlatformEvent(pldm_tid_t tid);
 
+    /** @brief Get Active EIDs.
+     *
+     *  @param[in] addr - MCTP address of terminus
+     *  @param[in] terminiNames - MCTP terminus name
+     */
+    std::optional<mctp_eid_t> getActiveEidByName(
+        const std::string& terminusName)
+    {
+        return terminusManager.getActiveEidByName(terminusName);
+    }
+
   private:
     /** @brief List of discovered termini */
     TerminiMapper termini{};
diff --git a/platform-mc/terminus_manager.cpp b/platform-mc/terminus_manager.cpp
index 1086292..c64c0c3 100644
--- a/platform-mc/terminus_manager.cpp
+++ b/platform-mc/terminus_manager.cpp
@@ -734,5 +734,44 @@
     co_return completionCode;
 }
 
+std::optional<mctp_eid_t> TerminusManager::getActiveEidByName(
+    const std::string& terminusName)
+{
+    if (!termini.size() || terminusName.empty())
+    {
+        return std::nullopt;
+    }
+
+    for (auto& [tid, terminus] : termini)
+    {
+        if (!terminus)
+        {
+            continue;
+        }
+
+        auto tmp = terminus->getTerminusName();
+        if (!tmp || std::empty(*tmp) || *tmp != terminusName)
+        {
+            continue;
+        }
+
+        try
+        {
+            auto mctpInfo = toMctpInfo(tid);
+            if (!mctpInfo || !mctpInfoAvailTable[*mctpInfo])
+            {
+                return std::nullopt;
+            }
+
+            return std::get<0>(*mctpInfo);
+        }
+        catch (const std::exception& e)
+        {
+            return std::nullopt;
+        }
+    }
+
+    return std::nullopt;
+}
 } // namespace platform_mc
 } // namespace pldm
diff --git a/platform-mc/terminus_manager.hpp b/platform-mc/terminus_manager.hpp
index 0eb2869..f8611f7 100644
--- a/platform-mc/terminus_manager.hpp
+++ b/platform-mc/terminus_manager.hpp
@@ -170,6 +170,16 @@
      */
     std::string constructEndpointObjPath(const MctpInfo& mctpInfo);
 
+    /** @brief Member functions to get the MCTP eid of active MCTP medium
+     *         interface of one terminus by terminus name
+     *
+     *  @param[in] terminusName - terminus name
+     *
+     *  @return option mctp_eid_t - the mctp eid or std::nullopt
+     */
+    std::optional<mctp_eid_t> getActiveEidByName(
+        const std::string& terminusName);
+
   private:
     /** @brief Find the terminus object pointer in termini list.
      *
diff --git a/platform-mc/test/terminus_manager_test.cpp b/platform-mc/test/terminus_manager_test.cpp
index 7fa8506..80d2699 100644
--- a/platform-mc/test/terminus_manager_test.cpp
+++ b/platform-mc/test/terminus_manager_test.cpp
@@ -6,6 +6,7 @@
 #include "common/instance_id.hpp"
 #include "common/types.hpp"
 #include "mock_terminus_manager.hpp"
+#include "platform-mc/platform_manager.hpp"
 #include "platform-mc/terminus_manager.hpp"
 #include "requester/handler.hpp"
 #include "requester/mctp_endpoint_discovery.hpp"
@@ -34,7 +35,8 @@
                    std::chrono::seconds(1), 2, std::chrono::milliseconds(100)),
         terminusManager(event, reqHandler, instanceIdDb, termini, nullptr,
                         pldm::BmcMctpEid),
-        mockTerminusManager(event, reqHandler, instanceIdDb, termini, nullptr)
+        mockTerminusManager(event, reqHandler, instanceIdDb, termini, nullptr),
+        platformManager(mockTerminusManager, termini, nullptr)
     {}
 
     PldmTransport* pldmTransport = nullptr;
@@ -44,6 +46,7 @@
     pldm::requester::Handler<pldm::requester::Request> reqHandler;
     pldm::platform_mc::TerminusManager terminusManager;
     pldm::platform_mc::MockTerminusManager mockTerminusManager;
+    pldm::platform_mc::PlatformManager platformManager;
     std::map<pldm_tid_t, std::shared_ptr<pldm::platform_mc::Terminus>> termini;
 };
 
@@ -542,3 +545,174 @@
     EXPECT_EQ(false, termini[1]->doesSupportCommand(
                          PLDM_FRU, PLDM_GET_FRU_RECORD_BY_OPTION));
 }
+
+TEST_F(TerminusManagerTest, getActiveEidByNameTest)
+{
+    // Add terminus
+    pldm::MctpInfo mctpInfo(10, "", "", 1);
+    auto mappedTid = mockTerminusManager.mapTid(mctpInfo);
+    auto tid = mappedTid.value();
+    termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
+        tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
+    auto terminus = termini[tid];
+
+    auto mappedTid1 = terminusManager.mapTid(mctpInfo);
+    EXPECT_EQ(mappedTid1, mappedTid);
+
+    auto mctpInfo1 = terminusManager.toMctpInfo(tid);
+    EXPECT_EQ(mctpInfo, mctpInfo1.value());
+
+    /* Set supported command by terminus */
+    auto size = PLDM_MAX_TYPES * (PLDM_MAX_CMDS_PER_TYPE / 8);
+    std::vector<uint8_t> pldmCmds(size);
+    uint8_t type = PLDM_PLATFORM;
+    uint8_t cmd = PLDM_GET_PDR;
+    auto idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (cmd / 8);
+    pldmCmds[idx] = pldmCmds[idx] | (1 << (cmd % 8));
+    cmd = PLDM_GET_PDR_REPOSITORY_INFO;
+    idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (cmd / 8);
+    pldmCmds[idx] = pldmCmds[idx] | (1 << (cmd % 8));
+    termini[tid]->setSupportedCommands(pldmCmds);
+
+    // queue getPDRRepositoryInfo response
+    const size_t getPDRRepositoryInfoLen =
+        PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES;
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + getPDRRepositoryInfoLen>
+        getPDRRepositoryInfoResp{
+            0x0, 0x02, 0x50, PLDM_SUCCESS,
+            0x0,                                     // repositoryState
+            0x0, 0x0,  0x0,  0x0,          0x0, 0x0, 0x0,
+            0x0, 0x0,  0x0,  0x0,          0x0, 0x0, // updateTime
+            0x0, 0x0,  0x0,  0x0,          0x0, 0x0, 0x0,
+            0x0, 0x0,  0x0,  0x0,          0x0, 0x0, // OEMUpdateTime
+            2,   0x0,  0x0,  0x0,                    // recordCount
+            0x0, 0x1,  0x0,  0x0,                    // repositorySize
+            59,  0x0,  0x0,  0x0,                    // largestRecordSize
+            0x0 // dataTransferHandleTimeout
+        };
+    auto rc = mockTerminusManager.enqueueResponse(
+        reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
+        sizeof(getPDRRepositoryInfoResp));
+    EXPECT_EQ(rc, PLDM_SUCCESS);
+
+    // queue getPDR responses
+    const size_t getPdrRespLen = 81;
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrRespLen> getPdrResp{
+        0x0, 0x02, 0x51, PLDM_SUCCESS, 0x1, 0x0, 0x0, 0x0, // nextRecordHandle
+        0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
+        0x5,                // transferFlag
+        69, 0x0,            // responseCount
+        // numeric Sensor PDR
+        0x0, 0x0, 0x0,
+        0x0,                     // record handle
+        0x1,                     // PDRHeaderVersion
+        PLDM_NUMERIC_SENSOR_PDR, // PDRType
+        0x0,
+        0x0,                     // recordChangeNumber
+        PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
+            PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH +
+            PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH,
+        0,                             // dataLength
+        0,
+        0,                             // PLDMTerminusHandle
+        0x1,
+        0x0,                           // sensorID=1
+        120,
+        0,                             // entityType=Power Supply(120)
+        1,
+        0,                             // entityInstanceNumber
+        0x1,
+        0x0,                           // containerID=1
+        PLDM_NO_INIT,                  // sensorInit
+        false,                         // sensorAuxiliaryNamesPDR
+        PLDM_SENSOR_UNIT_DEGRESS_C,    // baseUint(2)=degrees C
+        1,                             // unitModifier = 1
+        0,                             // rateUnit
+        0,                             // baseOEMUnitHandle
+        0,                             // auxUnit
+        0,                             // auxUnitModifier
+        0,                             // auxRateUnit
+        0,                             // rel
+        0,                             // auxOEMUnitHandle
+        true,                          // isLinear
+        PLDM_SENSOR_DATA_SIZE_UINT8,   // sensorDataSize
+        0, 0, 0xc0,
+        0x3f,                          // resolution=1.5
+        0, 0, 0x80,
+        0x3f,                          // offset=1.0
+        0,
+        0,                             // accuracy
+        0,                             // plusTolerance
+        0,                             // minusTolerance
+        2,                             // hysteresis
+        0,                             // supportedThresholds
+        0,                             // thresholdAndHysteresisVolatility
+        0, 0, 0x80,
+        0x3f,                          // stateTransistionInterval=1.0
+        0, 0, 0x80,
+        0x3f,                          // updateInverval=1.0
+        255,                           // maxReadable
+        0,                             // minReadable
+        PLDM_RANGE_FIELD_FORMAT_UINT8, // rangeFieldFormat
+        0,                             // rangeFieldsupport
+        0,                             // nominalValue
+        0,                             // normalMax
+        0,                             // normalMin
+        0,                             // warningHigh
+        0,                             // warningLow
+        0,                             // criticalHigh
+        0,                             // criticalLow
+        0,                             // fatalHigh
+        0                              // fatalLow
+    };
+    rc = mockTerminusManager.enqueueResponse(
+        reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
+    EXPECT_EQ(rc, PLDM_SUCCESS);
+
+    const size_t getPdrAuxNameRespLen = 39;
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrAuxNameRespLen>
+        getPdrAuxNameResp{
+            0x0, 0x02, 0x51, PLDM_SUCCESS, 0x0, 0x0, 0x0,
+            0x0,                // nextRecordHandle
+            0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
+            0x5,                // transferFlag
+            0x1b, 0x0,          // responseCount
+            // Common PDR Header
+            0x1, 0x0, 0x0,
+            0x0,                             // record handle
+            0x1,                             // PDRHeaderVersion
+            PLDM_ENTITY_AUXILIARY_NAMES_PDR, // PDRType
+            0x1,
+            0x0,                             // recordChangeNumber
+            0x11,
+            0,                               // dataLength
+            /* Entity Auxiliary Names PDR Data*/
+            3,
+            0x80, // entityType system software
+            0x1,
+            0x0,  // Entity instance number =1
+            0,
+            0,    // Overall system
+            0,    // shared Name Count one name only
+            01,   // nameStringCount
+            0x65, 0x6e, 0x00,
+            0x00, // Language Tag "en"
+            0x53, 0x00, 0x30, 0x00,
+            0x00  // Entity Name "S0"
+        };
+    rc = mockTerminusManager.enqueueResponse(
+        reinterpret_cast<pldm_msg*>(getPdrAuxNameResp.data()),
+        sizeof(getPdrAuxNameResp));
+    EXPECT_EQ(rc, PLDM_SUCCESS);
+
+    mockTerminusManager.updateMctpEndpointAvailability(mctpInfo, true);
+    terminusManager.updateMctpEndpointAvailability(mctpInfo, true);
+
+    stdexec::sync_wait(platformManager.initTerminus());
+    EXPECT_EQ(true, terminus->initialized);
+    EXPECT_EQ(2, terminus->pdrs.size());
+    EXPECT_EQ(1, termini.size());
+    EXPECT_EQ("S0", terminus->getTerminusName().value());
+    EXPECT_EQ(10, terminusManager.getActiveEidByName("S0").value());
+    EXPECT_EQ(false, terminusManager.getActiveEidByName("S1").has_value());
+}
diff --git a/pldmd/pldmd.cpp b/pldmd/pldmd.cpp
index ad86afe..202f794 100644
--- a/pldmd/pldmd.cpp
+++ b/pldmd/pldmd.cpp
@@ -220,11 +220,16 @@
         throw std::runtime_error("Failed to instantiate PDR repository");
     }
     DBusHandler dbusHandler;
+
+    std::unique_ptr<platform_mc::Manager> platformManager =
+        std::make_unique<platform_mc::Manager>(event, reqHandler, instanceIdDb);
+
     std::unique_ptr<pldm::host_effecters::HostEffecterParser>
         hostEffecterParser =
             std::make_unique<pldm::host_effecters::HostEffecterParser>(
                 &instanceIdDb, pldmTransport.getEventSource(), pdrRepo.get(),
-                &dbusHandler, HOST_JSONS_DIR, &reqHandler);
+                &dbusHandler, HOST_JSONS_DIR, &reqHandler,
+                platformManager.get());
 #ifdef LIBPLDMRESPONDER
     using namespace pldm::state_sensor;
     dbus_api::Host dbusImplHost(bus, "/xyz/openbmc_project/pldm");
@@ -275,9 +280,6 @@
     // handled. To enable building FRU table, the FRU handler is passed to the
     // Platform handler.
 
-    std::unique_ptr<platform_mc::Manager> platformManager =
-        std::make_unique<platform_mc::Manager>(event, reqHandler, instanceIdDb);
-
     pldm::responder::platform::EventMap addOnEventHandlers{
         {PLDM_CPER_EVENT,
          {[&platformManager](const pldm_msg* request, size_t payloadLength,
diff --git a/requester/mctp_endpoint_discovery.hpp b/requester/mctp_endpoint_discovery.hpp
index 6bd3168..026e155 100644
--- a/requester/mctp_endpoint_discovery.hpp
+++ b/requester/mctp_endpoint_discovery.hpp
@@ -34,6 +34,14 @@
     virtual void handleRemovedMctpEndpoints(const MctpInfos& mctpInfos) = 0;
     virtual void updateMctpEndpointAvailability(const MctpInfo& mctpInfo,
                                                 Availability availability) = 0;
+    /** @brief Get Active EIDs.
+     *
+     *  @param[in] addr - MCTP address of terminus
+     *  @param[in] terminiNames - MCTP terminus name
+     */
+    virtual std::optional<mctp_eid_t> getActiveEidByName(
+        const std::string& terminusName) = 0;
+
     virtual ~MctpDiscoveryHandlerIntf() {}
 };
 
diff --git a/requester/test/mock_mctp_discovery_handler_intf.hpp b/requester/test/mock_mctp_discovery_handler_intf.hpp
index 02de8c5..eec085c 100644
--- a/requester/test/mock_mctp_discovery_handler_intf.hpp
+++ b/requester/test/mock_mctp_discovery_handler_intf.hpp
@@ -18,6 +18,8 @@
     MOCK_METHOD(void, updateMctpEndpointAvailability,
                 (const MctpInfo& mctpInfo, Availability availability),
                 (override));
+    MOCK_METHOD(std::optional<mctp_eid_t>, getActiveEidByName,
+                (const std::string& terminusName), (override));
 };
 
 } // namespace pldm