diff --git a/libguh-core/awsconnector.cpp b/libguh-core/awsconnector.cpp
index a87ae7c5..4142c0bc 100644
--- a/libguh-core/awsconnector.cpp
+++ b/libguh-core/awsconnector.cpp
@@ -176,7 +176,7 @@ void AWSConnector::onPairingsRetrieved(const QVariantList &pairings)
 {
     QStringList topics;
     foreach (const QVariant &pairing, pairings) {
-        topics << QString("eu-west-1:%1/%2/#").arg(pairing.toMap().value("cognitoIdIdentityId").toString()).arg(m_clientId);
+        topics << QString("%1/%2/#").arg(m_clientId).arg(pairing.toString());
     }
     subscribe(topics);
 
@@ -195,16 +195,15 @@ bool AWSConnector::isConnected() const
     return m_connectingFuture.isFinished() && m_networkConnection && m_client && m_client->IsConnected();
 }
 
-void AWSConnector::pairDevice(const QString &idToken, const QString &authToken, const QString &cognitoUserId)
+void AWSConnector::pairDevice(const QString &idToken, const QString &userId)
 {
     QVariantMap map;
     map.insert("idToken", idToken);
-    map.insert("authToken", authToken);
-    map.insert("cognitoUserId", cognitoUserId);
+    map.insert("userId", userId);
     map.insert("id", ++m_transactionId);
     map.insert("timestamp", QDateTime::currentMSecsSinceEpoch());
     publish(QString("%1/pair").arg(m_clientId), map);
-    m_pairingRequests.insert(m_transactionId, cognitoUserId);
+    m_pairingRequests.insert(m_transactionId, userId);
 }
 
 void AWSConnector::sendWebRtcHandshakeMessage(const QString &sessionId, const QVariantMap &map)
@@ -222,7 +221,7 @@ quint16 AWSConnector::publish(const QString &topic, const QVariantMap &message)
     QJsonDocument jsonDoc = QJsonDocument::fromVariant(message);
 
     uint16_t packetId = 0;
-    ResponseCode res = m_client->PublishAsync(Utf8String::Create(fullTopic.toStdString()), false, false, mqtt::QoS::QOS1, jsonDoc.toJson().toStdString(), &publishCallback, packetId);
+    ResponseCode res = m_client->PublishAsync(Utf8String::Create(fullTopic.toStdString()), false, false, mqtt::QoS::QOS1, jsonDoc.toJson(QJsonDocument::Compact).toStdString(), &publishCallback, packetId);
     qCDebug(dcAWSTraffic()) << "publish call queued with status:" << QString::fromStdString(ResponseHelper::ToString(res)) << packetId << "for topic" << topic << jsonDoc.toJson();
     s_requestMap.insert(packetId, this);
     return packetId;
@@ -342,6 +341,8 @@ ResponseCode AWSConnector::onSubscriptionReceivedCallback(util::String topic_nam
         return ResponseCode::JSON_PARSING_ERROR;
     }
 
+    qCDebug(dcAWSTraffic()) << "Subscription received: Topic:" << QString::fromStdString(topic_name) << "payload:" << QString::fromStdString(payload);
+
     AWSConnector *connector = dynamic_cast<SubscriptionContext*>(p_app_handler_data.get())->c;
     QString topic = QString::fromStdString(topic_name);
     if (topic.startsWith("create/device/")) {
@@ -363,21 +364,25 @@ ResponseCode AWSConnector::onSubscriptionReceivedCallback(util::String topic_nam
     } else if (topic == QString("%1/pair/response").arg(connector->m_clientId)) {
         int statusCode = jsonDoc.toVariant().toMap().value("status").toInt();
         int id = jsonDoc.toVariant().toMap().value("id").toInt();
-        QString cognitoUserId = connector->m_pairingRequests.take(id);
-        if (!cognitoUserId.isEmpty()) {
-            qCDebug(dcAWS()) << "Pairing response for id:" << cognitoUserId << statusCode;
-            emit connector->devicePaired(cognitoUserId, statusCode);
-            connector->subscribe({QString("eu-west-1:%1/listeningPeer/#").arg(cognitoUserId)});
+        QString message = jsonDoc.toVariant().toMap().value("result").toMap().value("message").toString();
+        QString userId = connector->m_pairingRequests.take(id);
+        if (statusCode != 200) {
+            qCWarning(dcAWS()) << "Pairing failed:" << statusCode << message;
+            emit connector->devicePaired(userId, statusCode, message);
+        } else if (!userId.isEmpty()) {
+            qCDebug(dcAWS()) << "Pairing response for id:" << userId << statusCode;
+            emit connector->devicePaired(userId, statusCode, message);
+            connector->subscribe({QString("eu-west-1:%1/listeningPeer/#").arg(userId)});
         } else {
             qCWarning(dcAWS()) << "Received a pairing response for a transaction we didn't start";
         }
     } else if (topic == QString("%1/device/users/response").arg(connector->m_clientId)) {
-        qCDebug(dcAWS) << "have device pairings:" << jsonDoc.toVariant().toMap().value("pairings").toList();
-        if (jsonDoc.toVariant().toMap().value("pairings").toList().isEmpty()) {
+        if (jsonDoc.toVariant().toMap().value("users").toList().isEmpty()) {
             qCDebug(dcAWS()) << "No devices paired yet...";
             return ResponseCode::SUCCESS;
         }
-        connector->staticMetaObject.invokeMethod(connector, "inPairingsReceived", Qt::QueuedConnection, Q_ARG(QVariantList, jsonDoc.toVariant().toMap().value("pairings").toList()));
+        qCDebug(dcAWS) << jsonDoc.toVariant().toMap().value("users").toList().count() << "devices paired in cloud.";
+        connector->staticMetaObject.invokeMethod(connector, "onPairingsRetrieved", Qt::QueuedConnection, Q_ARG(QVariantList, jsonDoc.toVariant().toMap().value("users").toList()));
     } else if (topic == QString("%1/device/name/response").arg(connector->m_clientId)) {
         qCDebug(dcAWS) << "Set device name in cloud with status:" << jsonDoc.toVariant().toMap().value("status").toInt();
     } else if (topic.startsWith("eu-west-1:") && !topic.contains("reply")) {
diff --git a/libguh-core/awsconnector.h b/libguh-core/awsconnector.h
index 461444a3..966cb6ec 100644
--- a/libguh-core/awsconnector.h
+++ b/libguh-core/awsconnector.h
@@ -43,14 +43,14 @@ public:
     void disconnectAWS();
     bool isConnected() const;
 
-    void pairDevice(const QString &idToken, const QString &authToken, const QString &cognitoUserId);
+    void pairDevice(const QString &idToken, const QString &userId);
 
     void sendWebRtcHandshakeMessage(const QString &sessionId, const QVariantMap &map);
 
 signals:
     void connected();
     void disconnected();
-    void devicePaired(const QString &cognritoUserId, int errorCode);
+    void devicePaired(const QString &cognritoUserId, int errorCode, const QString &message);
     void webRtcHandshakeMessageReceived(const QString &transactionId, const QVariantMap &data);
 
 private slots:
@@ -101,7 +101,7 @@ private:
     QFuture<void> m_connectingFuture;
     bool m_isCleanSession = true;
 
-    int m_transactionId = 0;
+    quint8 m_transactionId = 0;
     QString m_createDeviceId;
     int m_createDeviceSubscriptionId = 0;
     QHash<quint16, QString> m_pairingRequests;
diff --git a/libguh-core/cloudmanager.cpp b/libguh-core/cloudmanager.cpp
index a7b04941..631853d9 100644
--- a/libguh-core/cloudmanager.cpp
+++ b/libguh-core/cloudmanager.cpp
@@ -111,9 +111,9 @@ void CloudManager::setEnabled(bool enabled)
     }
 }
 
-void CloudManager::pairDevice(const QString &idToken, const QString &authToken, const QString &cognitoId)
+void CloudManager::pairDevice(const QString &idToken, const QString &userId)
 {
-    m_awsConnector->pairDevice(idToken, authToken, cognitoId);
+    m_awsConnector->pairDevice(idToken, userId);
 }
 
 void CloudManager::connect2aws()
@@ -137,9 +137,9 @@ void CloudManager::onlineStateChanged()
     }
 }
 
-void CloudManager::onPairingFinished(const QString &cognitoUserId, int errorCode)
+void CloudManager::onPairingFinished(const QString &cognitoUserId, int errorCode, const QString &message)
 {
-    emit pairingReply(cognitoUserId, errorCode);
+    emit pairingReply(cognitoUserId, errorCode, message);
 }
 
 void CloudManager::onAWSWebRtcHandshakeMessageReceived(const QString &transactionId, const QVariantMap &data)
diff --git a/libguh-core/cloudmanager.h b/libguh-core/cloudmanager.h
index a369e186..2a32a12f 100644
--- a/libguh-core/cloudmanager.h
+++ b/libguh-core/cloudmanager.h
@@ -46,17 +46,17 @@ public:
     bool enabled() const;
     void setEnabled(bool enabled);
 
-    void pairDevice(const QString &idToken, const QString &authToken, const QString &cognitoId);
+    void pairDevice(const QString &idToken, const QString &userId);
 
 signals:
-    void pairingReply(QString cognitoUserId, int status);
+    void pairingReply(QString cognitoUserId, int status, const QString &message);
 
 private:
     void connect2aws();
 
 private slots:
     void onlineStateChanged();
-    void onPairingFinished(const QString &cognitoUserId, int errorCode);
+    void onPairingFinished(const QString &cognitoUserId, int errorCode, const QString &message);
     void onAWSWebRtcHandshakeMessageReceived(const QString &transactionId, const QVariantMap &data);
     void onJanusWebRtcHandshakeMessageReceived(const QString &transactionId, const QVariantMap &data);
 
diff --git a/libguh-core/jsonrpc/jsonrpcserver.cpp b/libguh-core/jsonrpc/jsonrpcserver.cpp
index 010e1f19..6fa23de3 100644
--- a/libguh-core/jsonrpc/jsonrpcserver.cpp
+++ b/libguh-core/jsonrpc/jsonrpcserver.cpp
@@ -143,10 +143,10 @@ JsonRPCServer::JsonRPCServer(const QSslConfiguration &sslConfiguration, QObject
     params.clear(); returns.clear();
     setDescription("SetupRemoteAccess", "Setup the remote connection by providing AWS token information");
     params.insert("idToken", JsonTypes::basicTypeToString(JsonTypes::String));
-    params.insert("authToken", JsonTypes::basicTypeToString(JsonTypes::String));
-    params.insert("cognitoId", JsonTypes::basicTypeToString(JsonTypes::String));
+    params.insert("userId", JsonTypes::basicTypeToString(JsonTypes::String));
     setParams("SetupRemoteAccess", params);
     returns.insert("status", JsonTypes::basicTypeToString(JsonTypes::Int));
+    returns.insert("message", JsonTypes::basicTypeToString(JsonTypes::String));
     setReturns("SetupRemoteAccess", returns);
 
     QMetaObject::invokeMethod(this, "setup", Qt::QueuedConnection);
@@ -263,14 +263,14 @@ JsonReply *JsonRPCServer::RemoveToken(const QVariantMap &params)
 
 JsonReply *JsonRPCServer::SetupRemoteAccess(const QVariantMap &params)
 {
+    qWarning() << "SetupRemoteAccess called";
     QString idToken = params.value("idToken").toString();
-    QString authToken = params.value("authToken").toString();
-    QString cognitoUserId = params.value("cognitoId").toString();
-    GuhCore::instance()->cloudManager()->pairDevice(idToken, authToken, cognitoUserId);
+    QString userId = params.value("userId").toString();
+    GuhCore::instance()->cloudManager()->pairDevice(idToken, userId);
     JsonReply *reply = createAsyncReply("SetupRemoteAccess");
-    m_pairingRequests.insert(cognitoUserId, reply);
-    connect(reply, &JsonReply::finished, [this, cognitoUserId](){
-        m_pairingRequests.remove(cognitoUserId);
+    m_pairingRequests.insert(userId, reply);
+    connect(reply, &JsonReply::finished, [this, userId](){
+        m_pairingRequests.remove(userId);
     });
     return reply;
 }
@@ -375,6 +375,7 @@ void JsonRPCServer::setup()
 void JsonRPCServer::processData(const QUuid &clientId, const QByteArray &data)
 {
     qCDebug(dcJsonRpcTraffic()) << "Incoming data:" << data;
+    qWarning() << "***F*f+DSF*DA*a+FD*SF*f+ASDF*S";
 
     TransportInterface *interface = qobject_cast<TransportInterface *>(sender());
     QJsonParseError error;
@@ -447,7 +448,7 @@ void JsonRPCServer::processData(const QUuid &clientId, const QByteArray &data)
     handler->setProperty("token", message.value("token").toByteArray());
     handler->setProperty("transportInterface", reinterpret_cast<qint64>(interface));
 
-    qCDebug(dcJsonRpc()) << "Got method" << method.toLatin1().data();
+    qCDebug(dcJsonRpc()) << "Invoking method" << targetNamespace << method.toLatin1().data();
 
     JsonReply *reply;
     QMetaObject::invokeMethod(handler, method.toLatin1().data(), Q_RETURN_ARG(JsonReply*, reply), Q_ARG(QVariantMap, params));
@@ -505,15 +506,15 @@ void JsonRPCServer::asyncReplyFinished()
     reply->deleteLater();
 }
 
-void JsonRPCServer::pairingFinished(QString cognitoUserId, int status)
+void JsonRPCServer::pairingFinished(QString cognitoUserId, int status, const QString &message)
 {
-    qWarning() << "pairing finished" << cognitoUserId << status;
     JsonReply *reply = m_pairingRequests.take(cognitoUserId);
     if (!reply) {
         return;
     }
     QVariantMap returns;
     returns.insert("status", status);
+    returns.insert("message", message);
     reply->setData(returns);
     reply->finished();
 }
diff --git a/libguh-core/jsonrpc/jsonrpcserver.h b/libguh-core/jsonrpc/jsonrpcserver.h
index 5f289e9f..3bded0a5 100644
--- a/libguh-core/jsonrpc/jsonrpcserver.h
+++ b/libguh-core/jsonrpc/jsonrpcserver.h
@@ -81,7 +81,7 @@ private slots:
 
     void asyncReplyFinished();
 
-    void pairingFinished(QString cognitoUserId, int status);
+    void pairingFinished(QString cognitoUserId, int status, const QString &message);
 
 private:
     QMap<TransportInterface*, bool> m_interfaces;
diff --git a/libguh-core/tcpserver.cpp b/libguh-core/tcpserver.cpp
index 2d64f76f..806ae998 100644
--- a/libguh-core/tcpserver.cpp
+++ b/libguh-core/tcpserver.cpp
@@ -114,6 +114,7 @@ void TcpServer::onEncrypted()
 
 void TcpServer::onDataAvailable(QSslSocket * socket, const QByteArray &data)
 {
+    qCDebug(dcTcpServerTraffic()) << "Emitting data available";
     QUuid clientId = m_clientList.key(socket);
     emit dataAvailable(clientId, data);
 }
@@ -224,11 +225,13 @@ void SslServer::onSocketReadyRead()
     m_receiveBuffer.append(socket->readAll());
     int splitIndex = m_receiveBuffer.indexOf("}\n{");
     while (splitIndex > -1) {
+        qWarning() << "******" << "emitting dataAcailable" << splitIndex;
         emit dataAvailable(socket, m_receiveBuffer.left(splitIndex + 1));
         m_receiveBuffer = m_receiveBuffer.right(m_receiveBuffer.length() - splitIndex - 2);
         splitIndex = m_receiveBuffer.indexOf("}\n{");
     }
     if (m_receiveBuffer.endsWith("}\n")) {
+        qWarning() << "*********" << "emitting dataAvailable" << m_receiveBuffer;
         emit dataAvailable(socket, m_receiveBuffer);
         m_receiveBuffer.clear();
     }
diff --git a/tests/scripts/setupremoteaccess.sh b/tests/scripts/setupremoteaccess.sh
index 4a206946..a2a95b9e 100755
--- a/tests/scripts/setupremoteaccess.sh
+++ b/tests/scripts/setupremoteaccess.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
-if [ -z $4 ]; then
-  echo "usage: $0 host idToken authToken cognitoId"
+if [ "$3" == "" ]; then
+  echo "usage: $0 host userId idToken"
 else
-  (echo '{"id":1, "method": "JSONRPC.SetupRemoteAccess", "params": { "idToken": "'$2'", "authToken": "'$3'", "cognitoId": "'$4'"}}'; sleep 1) | nc $1 2222
+  (echo '{"id":1, "method":"JSONRPC.SetupRemoteAccess", "params":{"userId": "'$2'", "idToken":"'$3'"}}'; sleep 1) | nc $1 2222
 fi