diff --git a/SilKit/IntegrationTests/CMakeLists.txt b/SilKit/IntegrationTests/CMakeLists.txt
index 0eb1b3a59..5e34ec3d4 100644
--- a/SilKit/IntegrationTests/CMakeLists.txt
+++ b/SilKit/IntegrationTests/CMakeLists.txt
@@ -118,6 +118,10 @@ add_silkit_test_to_executable(SilKitIntegrationTests
     SOURCES ITest_SimTask.cpp
 )
 
+add_silkit_test_to_executable(SilKitIntegrationTests
+    SOURCES ITest_Parameters.cpp
+)
+
 add_silkit_test_to_executable(SilKitFunctionalTests
     SOURCES FTest_WallClockCoupling.cpp
 )
diff --git a/SilKit/IntegrationTests/Hourglass/MockCapi.cpp b/SilKit/IntegrationTests/Hourglass/MockCapi.cpp
index ccedbf562..7de7df300 100644
--- a/SilKit/IntegrationTests/Hourglass/MockCapi.cpp
+++ b/SilKit/IntegrationTests/Hourglass/MockCapi.cpp
@@ -769,6 +769,21 @@ extern "C"
         return globalCapi->SilKit_Participant_GetLogger(outLogger, participant);
     }
 
+    SilKit_ReturnCode SilKitCALL SilKit_Participant_GetParticipantName(char* outParticipantName,
+                                                                       size_t* inOutParticipantNameSize,
+                                                                       SilKit_Participant* participant)
+    {
+        return globalCapi->SilKit_Participant_GetParticipantName(outParticipantName, inOutParticipantNameSize,
+                                                                  participant);
+    }
+
+    SilKit_ReturnCode SilKitCALL SilKit_Participant_GetRegistryUri(char* outRegistryUri,
+                                                                    size_t* inOutRegistryUriSize,
+                                                                    SilKit_Participant* participant)
+    {
+        return globalCapi->SilKit_Participant_GetRegistryUri(outRegistryUri, inOutRegistryUriSize, participant);
+    }
+
     // ParticipantConfiguration
 
     SilKit_ReturnCode SilKitCALL SilKit_ParticipantConfiguration_FromString(
diff --git a/SilKit/IntegrationTests/Hourglass/MockCapi.hpp b/SilKit/IntegrationTests/Hourglass/MockCapi.hpp
index 1b863ea8b..b6c8e4ff8 100644
--- a/SilKit/IntegrationTests/Hourglass/MockCapi.hpp
+++ b/SilKit/IntegrationTests/Hourglass/MockCapi.hpp
@@ -407,6 +407,12 @@ class MockCapi
     MOCK_METHOD(SilKit_ReturnCode, SilKit_Participant_GetLogger,
                 (SilKit_Logger * *outLogger, SilKit_Participant* participant));
 
+    MOCK_METHOD(SilKit_ReturnCode, SilKit_Participant_GetParticipantName,
+                (char* outParticipantName, size_t* inOutParticipantNameSize, SilKit_Participant* participant));
+
+    MOCK_METHOD(SilKit_ReturnCode, SilKit_Participant_GetRegistryUri,
+                (char* outRegistryUri, size_t* inOutRegistryUriSize, SilKit_Participant* participant));
+
     // ParticipantConfiguration
 
     MOCK_METHOD(SilKit_ReturnCode, SilKit_ParticipantConfiguration_FromString,
diff --git a/SilKit/IntegrationTests/ITest_Parameters.cpp b/SilKit/IntegrationTests/ITest_Parameters.cpp
new file mode 100644
index 000000000..195787370
--- /dev/null
+++ b/SilKit/IntegrationTests/ITest_Parameters.cpp
@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: 2026 Vector Informatik GmbH
+//
+// SPDX-License-Identifier: MIT
+
+#include <sstream>
+#include <string>
+
+#include "gtest/gtest.h"
+
+#include "silkit/SilKit.hpp"
+#include "silkit/vendor/CreateSilKitRegistry.hpp"
+
+namespace {
+
+class ITest_Parameters : public testing::Test
+{
+protected:
+    const std::string _registryUriAnyPort{"silkit://127.0.0.1:0"};
+};
+
+TEST_F(ITest_Parameters, participant_name_and_registry_uri_set_by_api)
+{
+    const std::string participantNameByApi{"P1"};
+
+    auto emptyParticipantConfig = SilKit::Config::ParticipantConfigurationFromString("");
+    auto registry = SilKit::Vendor::Vector::CreateSilKitRegistry(emptyParticipantConfig);
+    auto registryUriByApi = registry->StartListening(_registryUriAnyPort);
+
+    auto participant = SilKit::CreateParticipant(emptyParticipantConfig, participantNameByApi, registryUriByApi);
+
+    EXPECT_EQ(participant->GetParticipantName(), participantNameByApi);
+    EXPECT_EQ(participant->GetRegistryUri(), registryUriByApi);
+}
+
+TEST_F(ITest_Parameters, participant_name_and_registry_uri_set_by_configuration)
+{
+    const std::string participantNameByApi{"P2"};
+    const std::string registryUriByApi{"silkit://127.0.0.42:0"};
+    const std::string participantNameByConfig{"P1"};
+
+    auto emptyParticipantConfig = SilKit::Config::ParticipantConfigurationFromString("");
+    auto registry = SilKit::Vendor::Vector::CreateSilKitRegistry(emptyParticipantConfig);
+    auto registryUriByConfig = registry->StartListening(_registryUriAnyPort);
+
+    std::ostringstream ss;
+    ss << R"({ "ParticipantName": ")" << participantNameByConfig
+       << R"(", "Middleware": { "RegistryUri": ")" << registryUriByConfig << R"(" }})";
+
+    auto participantConfig = SilKit::Config::ParticipantConfigurationFromString(ss.str());
+    auto participant = SilKit::CreateParticipant(participantConfig, participantNameByApi, registryUriByApi);
+
+    EXPECT_EQ(participant->GetParticipantName(), participantNameByConfig);
+    EXPECT_EQ(participant->GetRegistryUri(), registryUriByConfig);
+}
+
+} // namespace
diff --git a/SilKit/include/silkit/capi/Participant.h b/SilKit/include/silkit/capi/Participant.h
index 31283c542..36dc39bb6 100644
--- a/SilKit/include/silkit/capi/Participant.h
+++ b/SilKit/include/silkit/capi/Participant.h
@@ -63,6 +63,37 @@ SilKitAPI SilKit_ReturnCode SilKitCALL SilKit_Participant_GetLogger(SilKit_Logge
 typedef SilKit_ReturnCode(SilKitFPTR* SilKit_Participant_GetLogger_t)(SilKit_Logger** outLogger,
                                                                       SilKit_Participant* participant);
 
+
+/*! \brief Retrieve the participant name from a participant.
+ *
+ * \param outParticipantName A buffer to copy the null-terminated participant name to.
+ *                           Passing a nullptr is valid and indicates a size-check via inOutParticipantNameSize.
+ * \param inOutParticipantNameSize The required/provided size of the value including null-termination.
+ * \param participant The participant to query.
+ */
+SilKitAPI SilKit_ReturnCode SilKitCALL SilKit_Participant_GetParticipantName(char* outParticipantName,
+                                                                              size_t* inOutParticipantNameSize,
+                                                                              SilKit_Participant* participant);
+
+typedef SilKit_ReturnCode(SilKitFPTR* SilKit_Participant_GetParticipantName_t)(char* outParticipantName,
+                                                                                size_t* inOutParticipantNameSize,
+                                                                                SilKit_Participant* participant);
+
+/*! \brief Retrieve the registry URI from a participant.
+ *
+ * \param outRegistryUri A buffer to copy the null-terminated registry URI to.
+ *                       Passing a nullptr is valid and indicates a size-check via inOutRegistryUriSize.
+ * \param inOutRegistryUriSize The required/provided size of the value including null-termination.
+ * \param participant The participant to query.
+ */
+SilKitAPI SilKit_ReturnCode SilKitCALL SilKit_Participant_GetRegistryUri(char* outRegistryUri,
+                                                                          size_t* inOutRegistryUriSize,
+                                                                          SilKit_Participant* participant);
+
+typedef SilKit_ReturnCode(SilKitFPTR* SilKit_Participant_GetRegistryUri_t)(char* outRegistryUri,
+                                                                            size_t* inOutRegistryUriSize,
+                                                                            SilKit_Participant* participant);
+
 SILKIT_END_DECLS
 
 #pragma pack(pop)
diff --git a/SilKit/include/silkit/detail/impl/participant/ParameterProvider.hpp b/SilKit/include/silkit/detail/impl/participant/ParameterProvider.hpp
new file mode 100644
index 000000000..2ed91d7f2
--- /dev/null
+++ b/SilKit/include/silkit/detail/impl/participant/ParameterProvider.hpp
@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: 2024 Vector Informatik GmbH
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "silkit/participant/exception.hpp"
+#include "silkit/detail/impl/ThrowOnError.hpp"
+
+namespace SilKit {
+DETAIL_SILKIT_DETAIL_VN_NAMESPACE_BEGIN
+namespace Impl {
+
+using StringQueryFunction = SilKit_ReturnCode(SilKitCALL*)(char*, size_t*, SilKit_Participant*);
+inline auto QueryString(SilKit_Participant* participant, StringQueryFunction stringQueryFunction) -> std::string;
+
+inline auto GetParticipantName(SilKit_Participant* participant) -> std::string;
+inline auto GetRegistryUri(SilKit_Participant* participant) -> std::string;
+
+// ================================================================================
+//  Inline Implementations
+// ================================================================================
+
+auto QueryString(SilKit_Participant* participant, StringQueryFunction stringQueryFunction) -> std::string
+{
+    std::vector<char> buffer;
+    size_t size = 0;
+
+    {
+        // Initially only get the size of the string to be queried
+        const auto returnCode = stringQueryFunction(nullptr, &size, participant);
+        ThrowOnError(returnCode);
+    }
+
+    while (size > buffer.size())
+    {
+        // Retry until the returned required size fits our buffer:
+        // the value may change between the initial size query and the copy call.
+        buffer.resize(size);
+        const auto returnCode = stringQueryFunction(buffer.data(), &size, participant);
+        ThrowOnError(returnCode);
+    }
+
+    return std::string{buffer.data()};
+}
+
+auto GetParticipantName(SilKit_Participant* participant) -> std::string
+{
+    return QueryString(participant, &SilKit_Participant_GetParticipantName);
+}
+
+auto GetRegistryUri(SilKit_Participant* participant) -> std::string
+{
+    return QueryString(participant, &SilKit_Participant_GetRegistryUri);
+}
+
+} // namespace Impl
+DETAIL_SILKIT_DETAIL_VN_NAMESPACE_CLOSE
+} // namespace SilKit
diff --git a/SilKit/include/silkit/detail/impl/participant/Participant.hpp b/SilKit/include/silkit/detail/impl/participant/Participant.hpp
index a3ebada3c..3022b1cc8 100644
--- a/SilKit/include/silkit/detail/impl/participant/Participant.hpp
+++ b/SilKit/include/silkit/detail/impl/participant/Participant.hpp
@@ -36,6 +36,8 @@
 
 #include "silkit/detail/impl/netsim/NetworkSimulator.hpp"
 
+#include "silkit/detail/impl/participant/ParameterProvider.hpp"
+
 namespace SilKit {
 DETAIL_SILKIT_DETAIL_VN_NAMESPACE_BEGIN
 namespace Impl {
@@ -83,6 +85,10 @@ class Participant : public SilKit::IParticipant
 
     inline auto GetLogger() -> SilKit::Services::Logging::ILogger* override;
 
+    inline auto GetParticipantName() const -> std::string override;
+
+    inline auto GetRegistryUri() const -> std::string override;
+
     inline auto ExperimentalCreateNetworkSimulator() -> SilKit::Experimental::NetworkSimulation::INetworkSimulator*;
 
     inline auto ExperimentalCreateSystemController()
@@ -224,6 +230,17 @@ auto Participant::GetLogger() -> SilKit::Services::Logging::ILogger*
     return _logger.get();
 }
 
+
+auto Participant::GetParticipantName() const -> std::string
+{
+    return Impl::GetParticipantName(_participant);
+}
+
+auto Participant::GetRegistryUri() const -> std::string
+{
+    return Impl::GetRegistryUri(_participant);
+}
+
 auto Participant::ExperimentalCreateSystemController()
     -> SilKit::Experimental::Services::Orchestration::ISystemController*
 {
diff --git a/SilKit/include/silkit/participant/IParticipant.hpp b/SilKit/include/silkit/participant/IParticipant.hpp
index c1e9516c7..9104e4bed 100644
--- a/SilKit/include/silkit/participant/IParticipant.hpp
+++ b/SilKit/include/silkit/participant/IParticipant.hpp
@@ -18,6 +18,7 @@
 #include "silkit/services/rpc/RpcSpec.hpp"
 #include "silkit/services/rpc/RpcDatatypes.hpp"
 
+
 namespace SilKit {
 
 /*! \brief Communication interface to be used by SIL Kit participants
@@ -82,6 +83,12 @@ class IParticipant
 
     //! \brief Return the ILogger at this SIL Kit participant.
     virtual auto GetLogger() -> Services::Logging::ILogger* = 0;
+
+    //! \brief Return the participant name of this SIL Kit participant.
+    virtual auto GetParticipantName() const -> std::string = 0;
+
+    //! \brief Return the URI of the registry this SIL Kit participant connects to.
+    virtual auto GetRegistryUri() const -> std::string = 0;
 };
 
 } // namespace SilKit
diff --git a/SilKit/source/capi/CMakeLists.txt b/SilKit/source/capi/CMakeLists.txt
index 59e74758d..055d45a96 100644
--- a/SilKit/source/capi/CMakeLists.txt
+++ b/SilKit/source/capi/CMakeLists.txt
@@ -41,3 +41,5 @@ add_silkit_test_to_executable(SilKitUnitTests SOURCES Test_CapiLin.cpp LIBS S_Si
 add_silkit_test_to_executable(SilKitUnitTests SOURCES Test_CapiSymbols.cpp LIBS S_SilKitImpl)
 add_silkit_test_to_executable(SilKitUnitTests SOURCES Test_CapiNetSim.cpp LIBS S_SilKitImpl I_SilKit)
 add_silkit_test_to_executable(SilKitUnitTests SOURCES Test_CapiExceptions.cpp LIBS S_SilKitImpl)
+add_silkit_test_to_executable(SilKitUnitTests SOURCES Test_CapiGetParameter.cpp LIBS S_SilKitImpl)
+
diff --git a/SilKit/source/capi/CapiParticipant.cpp b/SilKit/source/capi/CapiParticipant.cpp
index 326e61117..322f95491 100644
--- a/SilKit/source/capi/CapiParticipant.cpp
+++ b/SilKit/source/capi/CapiParticipant.cpp
@@ -15,11 +15,36 @@
 #include "CapiImpl.hpp"
 #include "TypeConversion.hpp"
 
+#include <algorithm>
 #include <memory>
 #include <map>
 #include <mutex>
 #include <fstream>
+#include <string_view>
 
+namespace
+{
+auto CopyStringToOutBuffer(std::string_view value, char* outStringBuffer, size_t* inOutStringBufferSize)
+    -> SilKit_ReturnCode
+{
+    // Passing outStringBuffer == nullptr performs a size-check only.
+    const auto requiredSize = value.size() + 1; // include '\0'
+
+    if (outStringBuffer != nullptr)
+    {
+        const auto bufferSize = *inOutStringBufferSize;
+        if (bufferSize > 0)
+        {
+            const auto sizeToCopy = std::min(value.size(), bufferSize - 1);
+            value.copy(outStringBuffer, sizeToCopy);
+            outStringBuffer[sizeToCopy] = '\0';
+        }
+    }
+
+    *inOutStringBufferSize = requiredSize;
+    return SilKit_ReturnCode_SUCCESS;
+}
+} // namespace
 
 SilKit_ReturnCode SilKitCALL SilKit_Participant_Create(SilKit_Participant** outParticipant,
                                                        SilKit_ParticipantConfiguration* participantConfiguration,
@@ -86,6 +111,32 @@ try
 }
 CAPI_CATCH_EXCEPTIONS
 
+SilKit_ReturnCode SilKitCALL SilKit_Participant_GetParticipantName(char* outParticipantName,
+                                                                   size_t* inOutParticipantNameSize,
+                                                                   SilKit_Participant* participant)
+try
+{
+    ASSERT_VALID_OUT_PARAMETER(inOutParticipantNameSize);
+    ASSERT_VALID_POINTER_PARAMETER(participant);
+
+    auto cppParticipant = reinterpret_cast<SilKit::IParticipant*>(participant);
+    return CopyStringToOutBuffer(cppParticipant->GetParticipantName(), outParticipantName, inOutParticipantNameSize);
+}
+CAPI_CATCH_EXCEPTIONS
+
+SilKit_ReturnCode SilKitCALL SilKit_Participant_GetRegistryUri(char* outRegistryUri,
+                                                               size_t* inOutRegistryUriSize,
+                                                               SilKit_Participant* participant)
+try
+{
+    ASSERT_VALID_OUT_PARAMETER(inOutRegistryUriSize);
+    ASSERT_VALID_POINTER_PARAMETER(participant);
+
+    auto cppParticipant = reinterpret_cast<SilKit::IParticipant*>(participant);
+    return CopyStringToOutBuffer(cppParticipant->GetRegistryUri(), outRegistryUri, inOutRegistryUriSize);
+}
+CAPI_CATCH_EXCEPTIONS
+
 
 SilKit_ReturnCode SilKitCALL SilKit_ParticipantConfiguration_FromString(
     SilKit_ParticipantConfiguration** outParticipantConfiguration, const char* participantConfigurationString)
diff --git a/SilKit/source/capi/Test_CapiGetParameter.cpp b/SilKit/source/capi/Test_CapiGetParameter.cpp
new file mode 100644
index 000000000..d4dae3a44
--- /dev/null
+++ b/SilKit/source/capi/Test_CapiGetParameter.cpp
@@ -0,0 +1,106 @@
+// SPDX-FileCopyrightText: 2024 Vector Informatik GmbH
+//
+// SPDX-License-Identifier: MIT
+
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+#include "silkit/capi/SilKit.h"
+
+#include "MockParticipant.hpp"
+
+namespace {
+
+using SilKit::Core::Tests::DummyParticipant;
+
+class MockParticipant : public SilKit::Core::Tests::DummyParticipant{};
+
+class Test_CapiGetParameter : public testing::Test
+{
+public:
+    MockParticipant mockParticipant;
+    Test_CapiGetParameter() {}
+};
+
+TEST_F(Test_CapiGetParameter, getparticipantname_bad_params)
+{
+    SilKit_ReturnCode returnCode;
+    auto cMockParticipant = (SilKit_Participant*)&mockParticipant;
+    char* parameterValue{nullptr};
+    size_t parameterSize;
+
+    returnCode = SilKit_Participant_GetParticipantName(nullptr, &parameterSize, cMockParticipant);
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_SUCCESS);
+
+    returnCode = SilKit_Participant_GetParticipantName(parameterValue, nullptr, cMockParticipant);
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_BADPARAMETER);
+
+    returnCode = SilKit_Participant_GetParticipantName(parameterValue, &parameterSize, nullptr);
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_BADPARAMETER);
+}
+
+TEST_F(Test_CapiGetParameter, getregistryuri_bad_params)
+{
+    SilKit_ReturnCode returnCode;
+    auto cMockParticipant = (SilKit_Participant*)&mockParticipant;
+    char* parameterValue{nullptr};
+    size_t parameterSize;
+
+    returnCode = SilKit_Participant_GetRegistryUri(nullptr, &parameterSize, cMockParticipant);
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_SUCCESS);
+
+    returnCode = SilKit_Participant_GetRegistryUri(parameterValue, nullptr, cMockParticipant);
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_BADPARAMETER);
+
+    returnCode = SilKit_Participant_GetRegistryUri(parameterValue, &parameterSize, nullptr);
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_BADPARAMETER);
+}
+
+TEST_F(Test_CapiGetParameter, getparticipantname_returns_required_size_and_null_terminated_value)
+{
+    auto cMockParticipant = (SilKit_Participant*)&mockParticipant;
+    const std::string value{"MockParticipant"};
+
+    size_t parameterSize{0};
+    auto returnCode = SilKit_Participant_GetParticipantName(nullptr, &parameterSize, cMockParticipant);
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_SUCCESS);
+    EXPECT_EQ(parameterSize, value.size() + 1);
+
+    char buffer[32]{};
+    auto bufferSize = sizeof(buffer);
+    returnCode = SilKit_Participant_GetParticipantName(buffer, &bufferSize, cMockParticipant);
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_SUCCESS);
+    EXPECT_EQ(bufferSize, value.size() + 1);
+    EXPECT_STREQ(buffer, value.c_str());
+}
+
+TEST_F(Test_CapiGetParameter, getregistryuri_returns_required_size_and_null_terminated_value)
+{
+    auto cMockParticipant = (SilKit_Participant*)&mockParticipant;
+    const std::string value{"silkit://mock.participant.silkit:0"};
+
+    size_t parameterSize{0};
+    auto returnCode = SilKit_Participant_GetRegistryUri(nullptr, &parameterSize, cMockParticipant);
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_SUCCESS);
+    EXPECT_EQ(parameterSize, value.size() + 1);
+
+    char buffer[64]{};
+    auto bufferSize = sizeof(buffer);
+    returnCode = SilKit_Participant_GetRegistryUri(buffer, &bufferSize, cMockParticipant);
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_SUCCESS);
+    EXPECT_EQ(bufferSize, value.size() + 1);
+    EXPECT_STREQ(buffer, value.c_str());
+}
+
+TEST_F(Test_CapiGetParameter, getparticipantname_truncates_and_still_null_terminates)
+{
+    auto cMockParticipant = (SilKit_Participant*)&mockParticipant;
+
+    char buffer[5]{};
+    size_t bufferSize = sizeof(buffer);
+    const auto returnCode = SilKit_Participant_GetParticipantName(buffer, &bufferSize, cMockParticipant);
+
+    EXPECT_EQ(returnCode, SilKit_ReturnCode_SUCCESS);
+    EXPECT_EQ(buffer[sizeof(buffer) - 1], '\0');
+}
+
+} // namespace
diff --git a/SilKit/source/core/internal/IParticipantInternal.hpp b/SilKit/source/core/internal/IParticipantInternal.hpp
index 3da426d3d..352b41707 100644
--- a/SilKit/source/core/internal/IParticipantInternal.hpp
+++ b/SilKit/source/core/internal/IParticipantInternal.hpp
@@ -51,15 +51,15 @@ class IParticipantInternal : public IParticipant
 public:
     // ----------------------------------------
     // Public methods
-    virtual auto GetParticipantName() const -> const std::string& = 0;
+    virtual auto GetParticipantName() const -> std::string = 0;
 
     /*! \brief Returns the URI of the registry this participant is connecting to.
      *
-     * The URI must be specified in the configuration (which has priority) or the CreateParticipant call.
      *
      * @return the URI of the registry
+     * The URI must be specified in the configuration (which has priority) or the CreateParticipant call.
      */
-    virtual auto GetRegistryUri() const -> const std::string& = 0;
+    virtual auto GetRegistryUri() const -> std::string = 0;
 
     /*! \brief Connect to the registry and join the simulation.
     *
diff --git a/SilKit/source/core/mock/participant/MockParticipant.hpp b/SilKit/source/core/mock/participant/MockParticipant.hpp
index 611a852e0..bd9d5b802 100644
--- a/SilKit/source/core/mock/participant/MockParticipant.hpp
+++ b/SilKit/source/core/mock/participant/MockParticipant.hpp
@@ -349,6 +349,15 @@ class DummyParticipant : public IParticipantInternal
         return &logger;
     }
 
+    auto GetParticipantName() const -> std::string override
+    {
+        return _name;
+    }
+    auto GetRegistryUri() const -> std::string override
+    {
+        return _registryUri;
+    }
+
     void RegisterSimulator(Core::ISimulator*, std::string,
                            Experimental::NetworkSimulation::SimulatedNetworkType) override
     {
@@ -621,15 +630,6 @@ class DummyParticipant : public IParticipantInternal
         callback();
     }
 
-    auto GetParticipantName() const -> const std::string& override
-    {
-        return _name;
-    }
-    auto GetRegistryUri() const -> const std::string& override
-    {
-        return _registryUri;
-    }
-
     virtual auto GetTimeProvider() -> Services::Orchestration::ITimeProvider*
     {
         return &mockTimeProvider;
diff --git a/SilKit/source/core/participant/Participant.hpp b/SilKit/source/core/participant/Participant.hpp
index 8f864b597..75118627a 100644
--- a/SilKit/source/core/participant/Participant.hpp
+++ b/SilKit/source/core/participant/Participant.hpp
@@ -149,6 +149,7 @@ class Participant final : public IParticipantInternal
     auto GetMetricsManager() -> IMetricsManager* override;
 
     auto GetLogger() -> Services::Logging::ILogger* override;
+    
     auto CreateLifecycleService(Services::Orchestration::LifecycleConfiguration startConfiguration)
         -> Services::Orchestration::ILifecycleService* override;
     auto GetLifecycleService() -> Services::Orchestration::ILifecycleService* override;
@@ -157,11 +158,11 @@ class Participant final : public IParticipantInternal
 
     auto CreateNetworkSimulator() -> Experimental::NetworkSimulation::INetworkSimulator* override;
 
-    auto GetParticipantName() const -> const std::string& override
+    auto GetParticipantName() const -> std::string override
     {
         return _participantConfig.participantName;
     }
-    auto GetRegistryUri() const -> const std::string& override
+    auto GetRegistryUri() const -> std::string override
     {
         return _participantConfig.middleware.registryUri;
     }
diff --git a/SilKit/source/core/participant/Participant_impl.hpp b/SilKit/source/core/participant/Participant_impl.hpp
index 0010dcc57..facfb4c09 100644
--- a/SilKit/source/core/participant/Participant_impl.hpp
+++ b/SilKit/source/core/participant/Participant_impl.hpp
@@ -1046,6 +1046,7 @@ auto Participant<SilKitConnectionT>::GetLoggerInternal() -> Services::Logging::I
     return _logger.get();
 }
 
+
 template <class SilKitConnectionT>
 void Participant<SilKitConnectionT>::SendMsg(const IServiceEndpoint* from, const Can::WireCanFrameEvent& msg)
 {
diff --git a/Utilities/SilKitSystemController/SystemController.cpp b/Utilities/SilKitSystemController/SystemController.cpp
index 8320dc958..147c68336 100644
--- a/Utilities/SilKitSystemController/SystemController.cpp
+++ b/Utilities/SilKitSystemController/SystemController.cpp
@@ -351,7 +351,7 @@ int main(int argc, char** argv)
         return -1;
     }
 
-    const auto participantName{commandlineParser.Get<CliParser::Option>("name").Value()};
+    const auto participantNameFromCli{commandlineParser.Get<CliParser::Option>("name").Value()};
     const auto nonInteractiveMode = (commandlineParser.Get<CliParser::Flag>("non-interactive").Value());
 
     const bool hasLogOption{commandlineParser.Get<CliParser::Option>("log").HasValue()};
@@ -365,7 +365,7 @@ int main(int argc, char** argv)
 
     const auto configurationFilename{commandlineParser.Get<CliParser::Option>("configuration").Value()};
     const auto requiredParticipantNames{commandlineParser.Get<CliParser::PositionalList>("participantNames").Values()};
-    const auto connectUri{commandlineParser.Get<CliParser::Option>("connect-uri").Value()};
+    const auto connectUriFromCli{commandlineParser.Get<CliParser::Option>("connect-uri").Value()};
 
     const auto logLevel{commandlineParser.Get<CliParser::Option>("log").Value()};
     if (!IsValidLogLevel(logLevel))
@@ -413,9 +413,11 @@ int main(int argc, char** argv)
 
     try
     {
-        std::cout << "Creating participant '" << participantName << "' with registry " << connectUri << std::endl;
+        auto participant = SilKit::CreateParticipant(configuration, participantNameFromCli, connectUriFromCli);
 
-        auto participant = SilKit::CreateParticipant(configuration, participantName, connectUri);
+        // The name and URI might have changed due to the configuration, so we retrieve them from the participant after creation
+        const auto participantName{participant->GetParticipantName()};
+        const auto connectUri{participant->GetRegistryUri()};
 
         auto* logger{participant->GetLogger()};
         {