diff --git a/services/tunnelbroker/src/Tools/ConfigManager.cpp b/services/tunnelbroker/src/Tools/ConfigManager.cpp
index fa99894c7..5c5502de2 100644
--- a/services/tunnelbroker/src/Tools/ConfigManager.cpp
+++ b/services/tunnelbroker/src/Tools/ConfigManager.cpp
@@ -1,125 +1,150 @@
 #include "ConfigManager.h"
 #include "Constants.h"
 #include "GlobalTools.h"
 
 #include <fstream>
 
 namespace comm {
 namespace network {
 namespace config {
 
 const std::string ConfigManager::OPTION_TUNNELBROKER_ID =
     "tunnelbroker.instance-id";
 const std::string ConfigManager::OPTION_DEFAULT_KEYSERVER_ID =
     "keyserver.default_keyserver_id";
 const std::string ConfigManager::OPTION_AMQP_URI = "amqp.uri";
 const std::string ConfigManager::OPTION_AMQP_FANOUT_EXCHANGE =
     "amqp.fanout_exchange_name";
 const std::string ConfigManager::OPTION_DYNAMODB_SESSIONS_TABLE =
     "dynamodb.sessions_table_name";
 const std::string ConfigManager::OPTION_DYNAMODB_SESSIONS_VERIFICATION_TABLE =
     "dynamodb.sessions_verification_table_name";
 const std::string ConfigManager::OPTION_DYNAMODB_SESSIONS_PUBLIC_KEY_TABLE =
     "dynamodb.sessions_public_key_table_name";
 const std::string ConfigManager::OPTION_DYNAMODB_MESSAGES_TABLE =
     "dynamodb.messages_table_name";
+const std::string ConfigManager::OPTION_NOTIFS_APNS_P12_CERT_PATH =
+    "notifications.apns_cert_path";
+const std::string ConfigManager::OPTION_NOTIFS_APNS_P12_CERT_PASSWORD =
+    "notifications.apns_cert_password";
+const std::string ConfigManager::OPTION_NOTIFS_APNS_TOPIC =
+    "notifications.apns_topic";
+const std::string ConfigManager::OPTION_NOTIFS_FCM_SERVER_KEY =
+    "notifications.fcm_server_key";
 
 ConfigManager &ConfigManager::getInstance() {
   static ConfigManager instance;
   return instance;
 }
 
 void ConfigManager::load() {
   char const *configFileDirectoryFromEnvironment =
       std::getenv(CONFIG_FILE_DIRECTORY_ENV_VARIABLE.c_str());
   std::string configFilePath = DEFAULT_CONFIG_FILE_DIRECTORY;
 
   if (configFileDirectoryFromEnvironment != nullptr) {
     configFilePath = std::string{configFileDirectoryFromEnvironment};
   }
   if (comm::network::tools::isSandbox()) {
     loadConfigFile(configFilePath + "/" + SANDBOX_CONFIG_FILE_NAME);
   } else {
     loadConfigFile(configFilePath + "/" + CONFIG_FILE_NAME);
   }
 }
 
 void ConfigManager::loadConfigFile(const std::string configFilePath) {
   try {
     std::ifstream fileStream;
     fileStream.open(configFilePath.c_str(), std::ifstream::in);
     if (!fileStream.is_open()) {
       throw std::runtime_error("Error: can not open file " + configFilePath);
     }
 
     boost::program_options::options_description description{
         "Tunnelbroker options"};
     description.add_options()(
         this->OPTION_TUNNELBROKER_ID.c_str(),
         boost::program_options::value<std::string>()->required(),
         "Tunnelbroker unique identification");
     description.add_options()(
         this->OPTION_DEFAULT_KEYSERVER_ID.c_str(),
         boost::program_options::value<std::string>()->required(),
         "Default and only allowed keyserver deviceID");
     description.add_options()(
         this->OPTION_AMQP_URI.c_str(),
         boost::program_options::value<std::string>()->required(),
         "AMQP URI connection string");
     description.add_options()(
         this->OPTION_AMQP_FANOUT_EXCHANGE.c_str(),
         boost::program_options::value<std::string>()->default_value(
             AMQP_FANOUT_EXCHANGE_NAME),
         "AMQP Fanout exchange name");
     description.add_options()(
         this->OPTION_DYNAMODB_SESSIONS_TABLE.c_str(),
         boost::program_options::value<std::string>()->default_value(
             DEVICE_SESSIONS_TABLE_NAME),
         "DynamoDB table name for sessions");
     description.add_options()(
         this->OPTION_DYNAMODB_SESSIONS_VERIFICATION_TABLE.c_str(),
         boost::program_options::value<std::string>()->default_value(
             DEVICE_SESSIONS_VERIFICATION_MESSAGES_TABLE_NAME),
         "DynamoDB table name for sessions verification messages");
     description.add_options()(
         this->OPTION_DYNAMODB_SESSIONS_PUBLIC_KEY_TABLE.c_str(),
         boost::program_options::value<std::string>()->default_value(
             DEVICE_PUBLIC_KEY_TABLE_NAME),
         "DynamoDB table name for public keys");
     description.add_options()(
         this->OPTION_DYNAMODB_MESSAGES_TABLE.c_str(),
         boost::program_options::value<std::string>()->default_value(
             MESSAGES_TABLE_NAME),
         "DynamoDB table name for messages");
 
+    description.add_options()(
+        this->OPTION_NOTIFS_APNS_P12_CERT_PATH.c_str(),
+        boost::program_options::value<std::string>()->required(),
+        "P12 certificate path for iOS notifications");
+    description.add_options()(
+        this->OPTION_NOTIFS_APNS_P12_CERT_PASSWORD.c_str(),
+        boost::program_options::value<std::string>()->required(),
+        "P12 certificate password for iOS notifications");
+    description.add_options()(
+        this->OPTION_NOTIFS_APNS_TOPIC.c_str(),
+        boost::program_options::value<std::string>()->required(),
+        "APNs messages topic for iOS notifications");
+    description.add_options()(
+        this->OPTION_NOTIFS_FCM_SERVER_KEY.c_str(),
+        boost::program_options::value<std::string>()->required(),
+        "Firebase Cloud Messaging server key for Android notifications");
+
     boost::program_options::parsed_options parsedDescription =
         boost::program_options::parse_config_file(
             fileStream, description, true);
     boost::program_options::store(parsedDescription, this->variablesMap);
     boost::program_options::notify(this->variablesMap);
     fileStream.close();
   } catch (const std::exception &e) {
     throw std::runtime_error(
         "Got an exception at ConfigManager: " + std::string(e.what()));
   }
 }
 
 std::string ConfigManager::getParameter(std::string param) {
   if (!this->variablesMap.count(param) &&
       !this->variablesMap[param].defaulted()) {
     throw std::runtime_error(
         "ConfigManager Error: config parameter " + param + " is not set.");
   }
   const std::string parameterValue =
       this->variablesMap[param].as<std::string>();
   if (parameterValue.empty()) {
     throw std::runtime_error(
         "ConfigManager Error: config parameter " + param +
         " can not be empty.");
   }
   return parameterValue;
 }
 
 } // namespace config
 } // namespace network
 } // namespace comm
diff --git a/services/tunnelbroker/src/Tools/ConfigManager.h b/services/tunnelbroker/src/Tools/ConfigManager.h
index 8f0d5e6e3..f84fb2d88 100644
--- a/services/tunnelbroker/src/Tools/ConfigManager.h
+++ b/services/tunnelbroker/src/Tools/ConfigManager.h
@@ -1,33 +1,37 @@
 #pragma once
 
 #include <boost/program_options.hpp>
 
 #include <string>
 
 namespace comm {
 namespace network {
 namespace config {
 
 class ConfigManager {
 private:
   boost::program_options::variables_map variablesMap;
   void loadConfigFile(const std::string configFilePath);
 
 public:
   static const std::string OPTION_TUNNELBROKER_ID;
   static const std::string OPTION_DEFAULT_KEYSERVER_ID;
   static const std::string OPTION_AMQP_URI;
   static const std::string OPTION_AMQP_FANOUT_EXCHANGE;
   static const std::string OPTION_DYNAMODB_SESSIONS_TABLE;
   static const std::string OPTION_DYNAMODB_SESSIONS_VERIFICATION_TABLE;
   static const std::string OPTION_DYNAMODB_SESSIONS_PUBLIC_KEY_TABLE;
   static const std::string OPTION_DYNAMODB_MESSAGES_TABLE;
+  static const std::string OPTION_NOTIFS_APNS_P12_CERT_PATH;
+  static const std::string OPTION_NOTIFS_APNS_P12_CERT_PASSWORD;
+  static const std::string OPTION_NOTIFS_APNS_TOPIC;
+  static const std::string OPTION_NOTIFS_FCM_SERVER_KEY;
 
   static ConfigManager &getInstance();
   void load();
   std::string getParameter(std::string param);
 };
 
 } // namespace config
 } // namespace network
 } // namespace comm