diff --git a/src/profiling/Holder.cpp b/src/profiling/Holder.cpp
index 750be7e..41c2993 100644
--- a/src/profiling/Holder.cpp
+++ b/src/profiling/Holder.cpp
@@ -46,6 +46,19 @@
     return m_CaptureData;
 }
 
+bool CaptureData::IsCounterIdInCaptureData(uint16_t counterId)
+{
+    for (auto m_CounterId : m_CounterIds) {
+        if (m_CounterId == counterId)
+        {
+            return true;
+        }
+    }
+
+    // Return false by default unless counterId is found
+    return false;
+}
+
 void Holder::SetCaptureData(uint32_t capturePeriod, const std::vector<uint16_t>& counterIds)
 {
     std::lock_guard<std::mutex> lockGuard(m_CaptureThreadMutex);
diff --git a/src/profiling/Holder.hpp b/src/profiling/Holder.hpp
index 3143105..9785b98 100644
--- a/src/profiling/Holder.hpp
+++ b/src/profiling/Holder.hpp
@@ -33,6 +33,7 @@
     void SetCounterIds(const std::vector<uint16_t>& counterIds);
     uint32_t GetCapturePeriod() const;
     const std::vector<uint16_t>& GetCounterIds() const;
+    bool IsCounterIdInCaptureData(uint16_t counterId);
 
 private:
     uint32_t m_CapturePeriod;
diff --git a/src/profiling/ProfilingService.cpp b/src/profiling/ProfilingService.cpp
index 5cee477..3540fc4 100644
--- a/src/profiling/ProfilingService.cpp
+++ b/src/profiling/ProfilingService.cpp
@@ -224,6 +224,16 @@
     return m_CounterIdMap;
 }
 
+CaptureData ProfilingService::GetCaptureData()
+{
+    return m_Holder.GetCaptureData();
+}
+
+void ProfilingService::SetCaptureData(uint32_t capturePeriod, const std::vector<uint16_t>& counterIds)
+{
+    m_Holder.SetCaptureData(capturePeriod, counterIds);
+}
+
 void ProfilingService::SetCounterValue(uint16_t counterUid, uint32_t value)
 {
     CheckCounterUid(counterUid);
diff --git a/src/profiling/ProfilingService.hpp b/src/profiling/ProfilingService.hpp
index 4438952..17099b1 100644
--- a/src/profiling/ProfilingService.hpp
+++ b/src/profiling/ProfilingService.hpp
@@ -84,6 +84,9 @@
     // Getters for the profiling service state
     bool IsProfilingEnabled();
 
+    CaptureData GetCaptureData();
+    void SetCaptureData(uint32_t capturePeriod, const std::vector<uint16_t>& counterIds);
+
     // Setters for the profiling service state
     void SetCounterValue(uint16_t counterUid, uint32_t value) override;
     uint32_t AddCounterValue(uint16_t counterUid, uint32_t value) override;
diff --git a/src/profiling/backends/BackendProfiling.cpp b/src/profiling/backends/BackendProfiling.cpp
index a49122a..884fb3f 100644
--- a/src/profiling/backends/BackendProfiling.cpp
+++ b/src/profiling/backends/BackendProfiling.cpp
@@ -15,7 +15,7 @@
 std::unique_ptr<IRegisterBackendCounters>
     BackendProfiling::GetCounterRegistrationInterface(uint16_t currentMaxGlobalCounterID)
 {
-    return std::make_unique<RegisterBackendCounters>(RegisterBackendCounters(currentMaxGlobalCounterID, m_backendId));
+    return std::make_unique<RegisterBackendCounters>(RegisterBackendCounters(currentMaxGlobalCounterID, m_BackendId));
 }
 
 std::unique_ptr<ISendTimelinePacket> BackendProfiling::GetSendTimelinePacket()
@@ -29,14 +29,43 @@
     return m_ProfilingService;
 }
 
-CounterStatus BackendProfiling::GetCounterStatus(uint16_t)
+CounterStatus BackendProfiling::GetCounterStatus(uint16_t backendCounterId)
 {
-    return CounterStatus();
+    uint16_t globalCounterId = m_ProfilingService.GetCounterMappings().GetGlobalId(backendCounterId, m_BackendId);
+    CaptureData captureData = m_ProfilingService.GetCaptureData();
+
+    CounterStatus counterStatus(backendCounterId, globalCounterId, false, 0);
+
+    if (captureData.IsCounterIdInCaptureData(globalCounterId))
+    {
+        counterStatus.m_Enabled = true;
+        counterStatus.m_SamplingRateInMicroseconds = captureData.GetCapturePeriod();
+    }
+
+    return counterStatus;
 }
 
 std::vector<CounterStatus> BackendProfiling::GetActiveCounters()
 {
-    return std::vector<CounterStatus>();
+    CaptureData captureData = m_ProfilingService.GetCaptureData();
+
+    const std::vector<uint16_t>& globalCounterIds = captureData.GetCounterIds();
+    std::vector<CounterStatus> activeCounterIds;
+
+    for (auto globalCounterId : globalCounterIds) {
+        // Get pair of local counterId and backendId using globalCounterId
+        const std::pair<uint16_t, armnn::BackendId>& backendCounterIdPair =
+                ProfilingService::Instance().GetCounterMappings().GetBackendId(globalCounterId);
+        if (backendCounterIdPair.second == m_BackendId)
+        {
+            activeCounterIds.emplace_back(backendCounterIdPair.first,
+                                          globalCounterId,
+                                          true,
+                                          captureData.GetCapturePeriod());
+        }
+    }
+
+    return activeCounterIds;
 }
 
 bool BackendProfiling::IsProfilingEnabled() const
diff --git a/src/profiling/backends/BackendProfiling.hpp b/src/profiling/backends/BackendProfiling.hpp
index 2bc365a..e0e0f58 100644
--- a/src/profiling/backends/BackendProfiling.hpp
+++ b/src/profiling/backends/BackendProfiling.hpp
@@ -3,7 +3,9 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include <ProfilingService.hpp>
+#pragma once
+
+#include "ProfilingService.hpp"
 #include <armnn/backends/profiling/IBackendProfiling.hpp>
 
 namespace armnn
@@ -15,17 +17,18 @@
 class BackendProfiling : public IBackendProfiling
 {
 public:
-    BackendProfiling(const IRuntime::CreationOptions& options, ProfilingService& profilingService, const BackendId& id)
-        : m_options(options)
-        , m_ProfilingService(profilingService)
-        , m_backendId(id)
-    {}
+    BackendProfiling(const IRuntime::CreationOptions& options,
+                     ProfilingService& profilingService,
+                     const BackendId& backendId)
+            : m_Options(options),
+              m_ProfilingService(profilingService),
+              m_BackendId(backendId) {}
 
     ~BackendProfiling()
     {}
 
     std::unique_ptr<IRegisterBackendCounters>
-        GetCounterRegistrationInterface(uint16_t currentMaxGlobalCounterID) override;
+            GetCounterRegistrationInterface(uint16_t currentMaxGlobalCounterID) override;
 
     std::unique_ptr<ISendTimelinePacket> GetSendTimelinePacket() override;
 
@@ -41,9 +44,9 @@
     bool IsProfilingEnabled() const override;
 
 private:
-    IRuntime::CreationOptions m_options;
+    IRuntime::CreationOptions m_Options;
     ProfilingService& m_ProfilingService;
-    BackendId m_backendId;
+    BackendId m_BackendId;
 };
 }    // namespace profiling
 }    // namespace armnn
\ No newline at end of file
diff --git a/src/profiling/test/ProfilingTests.cpp b/src/profiling/test/ProfilingTests.cpp
index d06201d..b15ddf7 100644
--- a/src/profiling/test/ProfilingTests.cpp
+++ b/src/profiling/test/ProfilingTests.cpp
@@ -5,6 +5,7 @@
 
 #include "ProfilingTests.hpp"
 
+#include <backends/BackendProfiling.hpp>
 #include <CommandHandler.hpp>
 #include <CommandHandlerKey.hpp>
 #include <CommandHandlerRegistry.hpp>
@@ -20,6 +21,7 @@
 #include <PeriodicCounterSelectionCommandHandler.hpp>
 #include <ProfilingStateMachine.hpp>
 #include <ProfilingUtils.hpp>
+#include <RegisterBackendCounters.hpp>
 #include <RequestCounterDirectoryCommandHandler.hpp>
 #include <Runtime.hpp>
 #include <SocketProfilingConnection.hpp>
@@ -40,7 +42,7 @@
 #include <limits>
 #include <map>
 #include <random>
-#include <RegisterBackendCounters.hpp>
+
 
 using namespace armnn::profiling;
 using PacketType = MockProfilingConnection::PacketType;
@@ -3259,4 +3261,141 @@
     profilingService.ResetExternalProfilingOptions(options, true);
 }
 
+BOOST_AUTO_TEST_CASE(CheckCounterStatusQuery)
+{
+    armnn::IRuntime::CreationOptions options;
+    options.m_ProfilingOptions.m_EnableProfiling = true;
+
+    // Reset the profiling service to the uninitialized state
+    ProfilingService& profilingService = ProfilingService::Instance();
+    profilingService.ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
+
+    const armnn::BackendId cpuRefId(armnn::Compute::CpuRef);
+    const armnn::BackendId cpuAccId(armnn::Compute::CpuAcc);
+
+    // Create BackendProfiling for each backend
+    BackendProfiling backendProfilingCpuRef(options, profilingService, cpuRefId);
+    BackendProfiling backendProfilingCpuAcc(options, profilingService, cpuAccId);
+
+    uint16_t initialNumGlobalCounterIds = armnn::profiling::INFERENCES_RUN;
+
+    // Create RegisterBackendCounters for CpuRef
+    RegisterBackendCounters registerBackendCountersCpuRef(initialNumGlobalCounterIds, cpuRefId);
+
+    // Create 'testCategory' in CounterDirectory (backend agnostic)
+    BOOST_CHECK(profilingService.GetCounterDirectory().GetCategories().empty());
+    registerBackendCountersCpuRef.RegisterCategory("testCategory");
+    auto categoryOnePtr = profilingService.GetCounterDirectory().GetCategory("testCategory");
+    BOOST_CHECK(categoryOnePtr);
+
+    // Counters:
+    // Global | Local | Backend
+    //    5   |   0   | CpuRef
+    //    6   |   1   | CpuRef
+    //    7   |   1   | CpuAcc
+
+    std::vector<uint16_t> cpuRefCounters = {0, 1};
+    std::vector<uint16_t> cpuAccCounters = {0};
+
+    // Register the backend counters for CpuRef and validate GetGlobalId and GetBackendId
+    uint16_t currentNumGlobalCounterIds = registerBackendCountersCpuRef.RegisterCounter(
+            0, "testCategory", 0, 0, 1.f, "CpuRefCounter0", "Zeroth CpuRef Counter");
+    BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 1);
+    uint16_t mappedGlobalId = profilingService.GetCounterMappings().GetGlobalId(0, cpuRefId);
+    BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
+    auto backendMapping = profilingService.GetCounterMappings().GetBackendId(currentNumGlobalCounterIds);
+    BOOST_CHECK(backendMapping.first == 0);
+    BOOST_CHECK(backendMapping.second == cpuRefId);
+
+    currentNumGlobalCounterIds = registerBackendCountersCpuRef.RegisterCounter(
+            1, "testCategory", 0, 0, 1.f, "CpuRefCounter1", "First CpuRef Counter");
+    BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 2);
+    mappedGlobalId = profilingService.GetCounterMappings().GetGlobalId(1, cpuRefId);
+    BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
+    backendMapping = profilingService.GetCounterMappings().GetBackendId(currentNumGlobalCounterIds);
+    BOOST_CHECK(backendMapping.first == 1);
+    BOOST_CHECK(backendMapping.second == cpuRefId);
+
+    // Create RegisterBackendCounters for CpuAcc
+    RegisterBackendCounters registerBackendCountersCpuAcc(currentNumGlobalCounterIds, cpuAccId);
+
+    // Register the backend counter for CpuAcc and validate GetGlobalId and GetBackendId
+    currentNumGlobalCounterIds = registerBackendCountersCpuAcc.RegisterCounter(
+            0, "testCategory", 0, 0, 1.f, "CpuAccCounter0", "Zeroth CpuAcc Counter");
+    BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 3);
+    mappedGlobalId = profilingService.GetCounterMappings().GetGlobalId(0, cpuAccId);
+    BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
+    backendMapping = profilingService.GetCounterMappings().GetBackendId(currentNumGlobalCounterIds);
+    BOOST_CHECK(backendMapping.first == 0);
+    BOOST_CHECK(backendMapping.second == cpuAccId);
+
+    // Create vectors for active counters
+    const std::vector<uint16_t> activeGlobalCounterIds = {5}; // CpuRef(0) activated
+    const std::vector<uint16_t> newActiveGlobalCounterIds = {6, 7}; // CpuRef(0) and CpuAcc(1) activated
+
+    const uint32_t capturePeriod = 200;
+    const uint32_t newCapturePeriod = 100;
+
+    // Set capture period and active counters in CaptureData
+    profilingService.SetCaptureData(capturePeriod, activeGlobalCounterIds);
+
+    // Get vector of active counters for CpuRef and CpuAcc backends
+    std::vector<CounterStatus> cpuRefCounterStatus = backendProfilingCpuRef.GetActiveCounters();
+    std::vector<CounterStatus> cpuAccCounterStatus = backendProfilingCpuAcc.GetActiveCounters();
+    BOOST_CHECK_EQUAL(cpuRefCounterStatus.size(), 1);
+    BOOST_CHECK_EQUAL(cpuAccCounterStatus.size(), 0);
+
+    // Check active CpuRef counter
+    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_GlobalCounterId, activeGlobalCounterIds[0]);
+    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_BackendCounterId, cpuRefCounters[0]);
+    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_SamplingRateInMicroseconds, capturePeriod);
+    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_Enabled, true);
+
+    // Check inactive CpuRef counter
+    CounterStatus inactiveCpuRefCounter = backendProfilingCpuRef.GetCounterStatus(cpuRefCounters[1]);
+    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_GlobalCounterId, 6);
+    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_BackendCounterId, cpuRefCounters[1]);
+    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_SamplingRateInMicroseconds, 0);
+    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_Enabled, false);
+
+    // Check inactive CpuAcc counter
+    CounterStatus inactiveCpuAccCounter = backendProfilingCpuAcc.GetCounterStatus(cpuAccCounters[0]);
+    BOOST_CHECK_EQUAL(inactiveCpuAccCounter.m_GlobalCounterId, 7);
+    BOOST_CHECK_EQUAL(inactiveCpuAccCounter.m_BackendCounterId, cpuAccCounters[0]);
+    BOOST_CHECK_EQUAL(inactiveCpuAccCounter.m_SamplingRateInMicroseconds, 0);
+    BOOST_CHECK_EQUAL(inactiveCpuAccCounter.m_Enabled, false);
+
+    // Set new capture period and new active counters in CaptureData
+    profilingService.SetCaptureData(newCapturePeriod, newActiveGlobalCounterIds);
+
+    // Get vector of active counters for CpuRef and CpuAcc backends
+    cpuRefCounterStatus = backendProfilingCpuRef.GetActiveCounters();
+    cpuAccCounterStatus = backendProfilingCpuAcc.GetActiveCounters();
+    BOOST_CHECK_EQUAL(cpuRefCounterStatus.size(), 1);
+    BOOST_CHECK_EQUAL(cpuAccCounterStatus.size(), 1);
+
+    // Check active CpuRef counter
+    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_GlobalCounterId, newActiveGlobalCounterIds[0]);
+    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_BackendCounterId, cpuRefCounters[1]);
+    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_SamplingRateInMicroseconds, newCapturePeriod);
+    BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_Enabled, true);
+
+    // Check active CpuAcc counter
+    BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_GlobalCounterId, newActiveGlobalCounterIds[1]);
+    BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_BackendCounterId, cpuAccCounters[0]);
+    BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_SamplingRateInMicroseconds, newCapturePeriod);
+    BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_Enabled, true);
+
+    // Check inactive CpuRef counter
+    inactiveCpuRefCounter = backendProfilingCpuRef.GetCounterStatus(cpuRefCounters[0]);
+    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_GlobalCounterId, 5);
+    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_BackendCounterId, cpuRefCounters[0]);
+    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_SamplingRateInMicroseconds, 0);
+    BOOST_CHECK_EQUAL(inactiveCpuRefCounter.m_Enabled, false);
+
+    // Reset the profiling service to stop any running thread
+    options.m_ProfilingOptions.m_EnableProfiling = false;
+    profilingService.ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
+}
+
 BOOST_AUTO_TEST_SUITE_END()