diff --git a/services/tunnelbroker/src/Database/DatabaseManager.cpp b/services/tunnelbroker/src/Database/DatabaseManager.cpp
index 5e326d3b7..33375e205 100644
--- a/services/tunnelbroker/src/Database/DatabaseManager.cpp
+++ b/services/tunnelbroker/src/Database/DatabaseManager.cpp
@@ -1,210 +1,238 @@
 #include "DatabaseManager.h"
 
 namespace comm {
 namespace network {
 namespace database {
 
 DatabaseManager &DatabaseManager::getInstance() {
   static DatabaseManager instance;
   return instance;
 }
 
 bool DatabaseManager::isTableAvailable(const std::string &tableName) {
   Aws::DynamoDB::Model::DescribeTableRequest request;
   request.SetTableName(tableName);
 
   // Check table availability by invoking DescribeTable
   const Aws::DynamoDB::Model::DescribeTableOutcome &result =
       getDynamoDBClient()->DescribeTable(request);
   return result.IsSuccess();
 }
 
 void DatabaseManager::innerPutItem(
     std::shared_ptr<Item> item,
     const Aws::DynamoDB::Model::PutItemRequest &request) {
   const Aws::DynamoDB::Model::PutItemOutcome outcome =
       getDynamoDBClient()->PutItem(request);
   if (!outcome.IsSuccess()) {
     throw std::runtime_error(outcome.GetError().GetMessage());
   }
 }
 
 template <typename T>
 std::shared_ptr<T>
 DatabaseManager::innerFindItem(Aws::DynamoDB::Model::GetItemRequest &request) {
   std::shared_ptr<T> item = createItemByType<T>();
   request.SetTableName(item->getTableName());
   const Aws::DynamoDB::Model::GetItemOutcome &outcome =
       getDynamoDBClient()->GetItem(request);
   if (!outcome.IsSuccess()) {
     throw std::runtime_error(outcome.GetError().GetMessage());
   }
   const AttributeValues &outcomeItem = outcome.GetResult().GetItem();
   if (!outcomeItem.size()) {
     return nullptr;
   }
   item->assignItemFromDatabase(outcomeItem);
   return std::move(item);
 }
 
 void DatabaseManager::innerRemoveItem(
     const Item &item,
     const std::string &key) {
   Aws::DynamoDB::Model::DeleteItemRequest request;
   request.SetTableName(item.getTableName());
   request.AddKey(
       item.getPrimaryKey(), Aws::DynamoDB::Model::AttributeValue(key));
 
   const Aws::DynamoDB::Model::DeleteItemOutcome &outcome =
       getDynamoDBClient()->DeleteItem(request);
   if (!outcome.IsSuccess()) {
     throw std::runtime_error(outcome.GetError().GetMessage());
   }
 }
 
 void DatabaseManager::putSessionItem(const DeviceSessionItem &item) {
   Aws::DynamoDB::Model::PutItemRequest request;
   request.SetTableName(item.getTableName());
   request.AddItem(
       DeviceSessionItem::FIELD_SESSION_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getSessionID()));
   request.AddItem(
       DeviceSessionItem::FIELD_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getDeviceID()));
   request.AddItem(
       DeviceSessionItem::FIELD_PUBKEY,
       Aws::DynamoDB::Model::AttributeValue(item.getPubKey()));
   request.AddItem(
       DeviceSessionItem::FIELD_NOTIFY_TOKEN,
       Aws::DynamoDB::Model::AttributeValue(item.getNotifyToken()));
   request.AddItem(
       DeviceSessionItem::FIELD_DEVICE_TYPE,
       Aws::DynamoDB::Model::AttributeValue(item.getDeviceType()));
   request.AddItem(
       DeviceSessionItem::FIELD_APP_VERSION,
       Aws::DynamoDB::Model::AttributeValue(item.getAppVersion()));
   request.AddItem(
       DeviceSessionItem::FIELD_DEVICE_OS,
       Aws::DynamoDB::Model::AttributeValue(item.getDeviceOs()));
   request.AddItem(
       DeviceSessionItem::FIELD_CHECKPOINT_TIME,
       Aws::DynamoDB::Model::AttributeValue(
           std::to_string(item.getCheckpointTime())));
   request.AddItem(
       DeviceSessionItem::FIELD_EXPIRE,
       Aws::DynamoDB::Model::AttributeValue(std::to_string(
           static_cast<size_t>(std::time(0)) + SESSION_RECORD_TTL)));
   this->innerPutItem(std::make_shared<DeviceSessionItem>(item), request);
 }
 
 std::shared_ptr<DeviceSessionItem>
 DatabaseManager::findSessionItem(const std::string &sessionID) {
   Aws::DynamoDB::Model::GetItemRequest request;
   request.AddKey(
       DeviceSessionItem::FIELD_SESSION_ID,
       Aws::DynamoDB::Model::AttributeValue(sessionID));
   return std::move(this->innerFindItem<DeviceSessionItem>(request));
 }
 
 void DatabaseManager::removeSessionItem(const std::string &sessionID) {
   this->innerRemoveItem(*(createItemByType<DeviceSessionItem>()), sessionID);
 }
 
 void DatabaseManager::putSessionSignItem(const SessionSignItem &item) {
   Aws::DynamoDB::Model::PutItemRequest request;
   request.SetTableName(item.getTableName());
   request.AddItem(
       SessionSignItem::FIELD_SESSION_VERIFICATION,
       Aws::DynamoDB::Model::AttributeValue(item.getSign()));
   request.AddItem(
       SessionSignItem::FIELD_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getDeviceID()));
   request.AddItem(
       SessionSignItem::FIELD_EXPIRE,
       Aws::DynamoDB::Model::AttributeValue(std::to_string(
           static_cast<size_t>(std::time(0)) + SESSION_SIGN_RECORD_TTL)));
   this->innerPutItem(std::make_shared<SessionSignItem>(item), request);
 }
 
 std::shared_ptr<SessionSignItem>
 DatabaseManager::findSessionSignItem(const std::string &deviceID) {
   Aws::DynamoDB::Model::GetItemRequest request;
   request.AddKey(
       SessionSignItem::FIELD_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(deviceID));
   return std::move(this->innerFindItem<SessionSignItem>(request));
 }
 
 void DatabaseManager::removeSessionSignItem(const std::string &deviceID) {
   this->innerRemoveItem(*(createItemByType<SessionSignItem>()), deviceID);
 }
 
 void DatabaseManager::putPublicKeyItem(const PublicKeyItem &item) {
   Aws::DynamoDB::Model::PutItemRequest request;
   request.SetTableName(item.getTableName());
   request.AddItem(
       PublicKeyItem::FIELD_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getDeviceID()));
   request.AddItem(
       PublicKeyItem::FIELD_PUBLIC_KEY,
       Aws::DynamoDB::Model::AttributeValue(item.getPublicKey()));
   this->innerPutItem(std::make_shared<PublicKeyItem>(item), request);
 }
 
 std::shared_ptr<PublicKeyItem>
 DatabaseManager::findPublicKeyItem(const std::string &deviceID) {
   Aws::DynamoDB::Model::GetItemRequest request;
   request.AddKey(
       PublicKeyItem::FIELD_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(deviceID));
   return std::move(this->innerFindItem<PublicKeyItem>(request));
 }
 
 void DatabaseManager::removePublicKeyItem(const std::string &deviceID) {
   this->innerRemoveItem(*(createItemByType<PublicKeyItem>()), deviceID);
 }
 
 void DatabaseManager::putMessageItem(const MessageItem &item) {
   Aws::DynamoDB::Model::PutItemRequest request;
   request.SetTableName(item.getTableName());
   request.AddItem(
       MessageItem::FIELD_MESSAGE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getMessageID()));
   request.AddItem(
       MessageItem::FIELD_FROM_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getFromDeviceID()));
   request.AddItem(
       MessageItem::FIELD_TO_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getToDeviceID()));
   request.AddItem(
       MessageItem::FIELD_PAYLOAD,
       Aws::DynamoDB::Model::AttributeValue(item.getPayload()));
   request.AddItem(
       MessageItem::FIELD_BLOB_HASHES,
       Aws::DynamoDB::Model::AttributeValue(item.getBlobHashes()));
   request.AddItem(
       MessageItem::FIELD_EXPIRE,
       Aws::DynamoDB::Model::AttributeValue(std::to_string(item.getExpire())));
   request.AddItem(
       MessageItem::FIELD_CREATED_AT,
       Aws::DynamoDB::Model::AttributeValue(
           std::to_string(tools::getCurrentTimestamp())));
   this->innerPutItem(std::make_shared<MessageItem>(item), request);
 }
 
 std::shared_ptr<MessageItem>
 DatabaseManager::findMessageItem(const std::string &messageID) {
   Aws::DynamoDB::Model::GetItemRequest request;
   request.AddKey(
       MessageItem::FIELD_MESSAGE_ID,
       Aws::DynamoDB::Model::AttributeValue(messageID));
   return std::move(this->innerFindItem<MessageItem>(request));
 }
 
+std::vector<std::shared_ptr<MessageItem>>
+DatabaseManager::findMessageItemsByReceiver(const std::string &toDeviceID) {
+  std::vector<std::shared_ptr<MessageItem>> result;
+
+  Aws::DynamoDB::Model::QueryRequest req;
+  req.SetTableName(MessageItem().getTableName());
+  req.SetKeyConditionExpression(
+      MessageItem::FIELD_TO_DEVICE_ID + " = :valueToMatch");
+
+  AttributeValues attributeValues;
+  attributeValues.emplace(":valueToMatch", toDeviceID);
+
+  req.SetExpressionAttributeValues(attributeValues);
+  req.SetIndexName(MessageItem::INDEX_TO_DEVICE_ID);
+
+  const Aws::DynamoDB::Model::QueryOutcome &outcome =
+      getDynamoDBClient()->Query(req);
+  if (!outcome.IsSuccess()) {
+    throw std::runtime_error(outcome.GetError().GetMessage());
+  }
+  const Aws::Vector<AttributeValues> &items = outcome.GetResult().GetItems();
+  for (auto &item : items) {
+    result.push_back(std::make_shared<MessageItem>(item));
+  }
+
+  return result;
+}
+
 void DatabaseManager::removeMessageItem(const std::string &messageID) {
   this->innerRemoveItem(*(createItemByType<MessageItem>()), messageID);
 }
 
 } // namespace database
 } // namespace network
 } // namespace comm
diff --git a/services/tunnelbroker/src/Database/DatabaseManager.h b/services/tunnelbroker/src/Database/DatabaseManager.h
index a82156f83..13d5a6a13 100644
--- a/services/tunnelbroker/src/Database/DatabaseManager.h
+++ b/services/tunnelbroker/src/Database/DatabaseManager.h
@@ -1,59 +1,62 @@
 #pragma once
 
 #include "AwsTools.h"
 #include "Constants.h"
 #include "DatabaseEntitiesTools.h"
 #include "Tools.h"
 
 #include <aws/core/Aws.h>
 #include <aws/core/utils/Outcome.h>
 #include <aws/dynamodb/model/AttributeDefinition.h>
 #include <aws/dynamodb/model/DeleteItemRequest.h>
 #include <aws/dynamodb/model/DescribeTableRequest.h>
 #include <aws/dynamodb/model/DescribeTableResult.h>
 #include <aws/dynamodb/model/GetItemRequest.h>
 #include <aws/dynamodb/model/PutItemRequest.h>
+#include <aws/dynamodb/model/QueryRequest.h>
 
 #include <memory>
 #include <string>
 
 namespace comm {
 namespace network {
 namespace database {
 
 class DatabaseManager {
 
   void innerPutItem(
       std::shared_ptr<Item> item,
       const Aws::DynamoDB::Model::PutItemRequest &request);
   template <typename T>
   std::shared_ptr<T>
   innerFindItem(Aws::DynamoDB::Model::GetItemRequest &request);
   void innerRemoveItem(const Item &item, const std::string &key);
 
 public:
   static DatabaseManager &getInstance();
   bool isTableAvailable(const std::string &tableName);
 
   void putSessionItem(const DeviceSessionItem &item);
   std::shared_ptr<DeviceSessionItem>
   findSessionItem(const std::string &deviceID);
   void removeSessionItem(const std::string &sessionID);
 
   void putSessionSignItem(const SessionSignItem &item);
   std::shared_ptr<SessionSignItem>
   findSessionSignItem(const std::string &deviceID);
   void removeSessionSignItem(const std::string &deviceID);
 
   void putPublicKeyItem(const PublicKeyItem &item);
   std::shared_ptr<PublicKeyItem> findPublicKeyItem(const std::string &deviceID);
   void removePublicKeyItem(const std::string &deviceID);
 
   void putMessageItem(const MessageItem &item);
   std::shared_ptr<MessageItem> findMessageItem(const std::string &messageID);
+  std::vector<std::shared_ptr<MessageItem>>
+  findMessageItemsByReceiver(const std::string &toDeviceID);
   void removeMessageItem(const std::string &messageID);
 };
 
 } // namespace database
 } // namespace network
 } // namespace comm
diff --git a/services/tunnelbroker/src/Database/MessageItem.cpp b/services/tunnelbroker/src/Database/MessageItem.cpp
index f42e8df09..92c063682 100644
--- a/services/tunnelbroker/src/Database/MessageItem.cpp
+++ b/services/tunnelbroker/src/Database/MessageItem.cpp
@@ -1,107 +1,108 @@
 #include "MessageItem.h"
 #include "ConfigManager.h"
 #include "Tools.h"
 
 #include <vector>
 
 namespace comm {
 namespace network {
 namespace database {
 
 const std::string MessageItem::FIELD_MESSAGE_ID = "MessageID";
 const std::string MessageItem::FIELD_FROM_DEVICE_ID = "FromDeviceID";
 const std::string MessageItem::FIELD_TO_DEVICE_ID = "ToDeviceID";
 const std::string MessageItem::FIELD_PAYLOAD = "Payload";
 const std::string MessageItem::FIELD_BLOB_HASHES = "BlobHashes";
 const std::string MessageItem::FIELD_EXPIRE = "Expire";
 const std::string MessageItem::FIELD_CREATED_AT = "CreatedAt";
+const std::string MessageItem::INDEX_TO_DEVICE_ID = "ToDeviceID-index";
 
 MessageItem::MessageItem(
     const std::string messageID,
     const std::string fromDeviceID,
     const std::string toDeviceID,
     const std::string payload,
     const std::string blobHashes,
     const uint64_t expire)
     : messageID(messageID),
       fromDeviceID(fromDeviceID),
       toDeviceID(toDeviceID),
       payload(payload),
       blobHashes(blobHashes),
       expire(expire) {
   this->validate();
 }
 
 MessageItem::MessageItem(const AttributeValues &itemFromDB) {
   this->assignItemFromDatabase(itemFromDB);
 }
 
 void MessageItem::validate() const {
   if (!tools::validateDeviceID(this->fromDeviceID)) {
     throw std::runtime_error("Error: FromDeviceID format is wrong.");
   }
   if (!tools::validateDeviceID(this->toDeviceID)) {
     throw std::runtime_error("Error: ToDeviceID format is wrong.");
   }
   tools::checkIfNotEmpty("messageID", this->messageID);
   tools::checkIfNotZero("expire", this->expire);
 }
 
 void MessageItem::assignItemFromDatabase(const AttributeValues &itemFromDB) {
   try {
     this->messageID = itemFromDB.at(MessageItem::FIELD_MESSAGE_ID).GetS();
     this->fromDeviceID =
         itemFromDB.at(MessageItem::FIELD_FROM_DEVICE_ID).GetS();
     this->toDeviceID = itemFromDB.at(MessageItem::FIELD_TO_DEVICE_ID).GetS();
     this->payload = itemFromDB.at(MessageItem::FIELD_PAYLOAD).GetS();
     this->blobHashes = itemFromDB.at(MessageItem::FIELD_BLOB_HASHES).GetS();
     this->expire = std::stoull(itemFromDB.at(MessageItem::FIELD_EXPIRE).GetS());
     this->createdAt =
         std::stoull(itemFromDB.at(MessageItem::FIELD_CREATED_AT).GetS());
   } catch (const std::exception &e) {
     throw std::runtime_error(
         "Got an exception at MessageItem: " + std::string(e.what()));
   }
   this->validate();
 }
 
 std::string MessageItem::getTableName() const {
   return config::ConfigManager::getInstance().getParameter(
       config::ConfigManager::OPTION_DYNAMODB_MESSAGES_TABLE);
 }
 
 std::string MessageItem::getPrimaryKey() const {
   return MessageItem::FIELD_MESSAGE_ID;
 }
 
 std::string MessageItem::getMessageID() const {
   return this->messageID;
 }
 
 std::string MessageItem::getFromDeviceID() const {
   return this->fromDeviceID;
 }
 
 std::string MessageItem::getToDeviceID() const {
   return this->toDeviceID;
 }
 
 std::string MessageItem::getPayload() const {
   return this->payload;
 }
 
 std::string MessageItem::getBlobHashes() const {
   return this->blobHashes;
 }
 
 uint64_t MessageItem::getExpire() const {
   return this->expire;
 }
 
 uint64_t MessageItem::getCreatedAt() const {
   return this->createdAt;
 }
 
 } // namespace database
 } // namespace network
 } // namespace comm
diff --git a/services/tunnelbroker/src/Database/MessageItem.h b/services/tunnelbroker/src/Database/MessageItem.h
index 7913a87e6..5a70c78f3 100644
--- a/services/tunnelbroker/src/Database/MessageItem.h
+++ b/services/tunnelbroker/src/Database/MessageItem.h
@@ -1,56 +1,57 @@
 #pragma once
 
 #include "Item.h"
 
 #include <string>
 
 namespace comm {
 namespace network {
 namespace database {
 
 class MessageItem : public Item {
   std::string messageID;
   std::string fromDeviceID;
   std::string toDeviceID;
   std::string payload;
   std::string blobHashes;
   uint64_t expire;
   uint64_t createdAt;
 
   void validate() const override;
 
 public:
   static const std::string FIELD_MESSAGE_ID;
   static const std::string FIELD_FROM_DEVICE_ID;
   static const std::string FIELD_TO_DEVICE_ID;
   static const std::string FIELD_PAYLOAD;
   static const std::string FIELD_BLOB_HASHES;
   static const std::string FIELD_EXPIRE;
   static const std::string FIELD_CREATED_AT;
+  static const std::string INDEX_TO_DEVICE_ID;
 
   std::string getPrimaryKey() const override;
   std::string getTableName() const override;
   std::string getMessageID() const;
   std::string getFromDeviceID() const;
   std::string getToDeviceID() const;
   std::string getPayload() const;
   std::string getBlobHashes() const;
   uint64_t getExpire() const;
   uint64_t getCreatedAt() const;
 
   MessageItem() {
   }
   MessageItem(
       const std::string messageID,
       const std::string fromDeviceID,
       const std::string toDeviceID,
       const std::string payload,
       const std::string blobHashes,
       const uint64_t expire);
   MessageItem(const AttributeValues &itemFromDB);
   void assignItemFromDatabase(const AttributeValues &itemFromDB) override;
 };
 
 } // namespace database
 } // namespace network
 } // namespace comm