diff --git a/command/open_session.hpp b/command/open_session.hpp
index f5111d2..717b99b 100644
--- a/command/open_session.hpp
+++ b/command/open_session.hpp
@@ -174,7 +174,7 @@
  *
  * @return Response data for the command
  */
-std::vector<uint8_t> openSession(std::vector<uint8_t>& inPayload,
+std::vector<uint8_t> openSession(const std::vector<uint8_t>& inPayload,
                                  const message::Handler& handler);
 
 } // namespace command
