diff --git a/libhive/devicemanager.cpp b/libhive/devicemanager.cpp
index 6c3ee125..c78ba9f1 100644
--- a/libhive/devicemanager.cpp
+++ b/libhive/devicemanager.cpp
@@ -25,12 +25,27 @@ QList<DeviceClass> DeviceManager::supportedDevices()
     return m_supportedDevices;
 }
 
-void DeviceManager::createDevice(const DeviceClass &deviceClass, const QVariantMap &params)
+DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const QUuid &deviceClassId, const QVariantMap &params)
 {
-    Device *device = new Device(deviceClass.id(), this);
+    DeviceClass deviceClass = findDeviceClass(deviceClassId);
+    if (deviceClass.id().isNull()) {
+        qWarning() << "cannot find a device class with id" << deviceClassId;
+        return DeviceErrorDeviceClassNotFound;
+    }
+    foreach (const QVariant &param, deviceClass.params()) {
+        if (!params.contains(param.toMap().value("name").toString())) {
+            qWarning() << "Missing parameter when creating device:" << param.toMap().value("name").toString();
+            return DeviceErrorMissingParameter;
+        }
+    }
+
+    // TODO: check if params match with template from DeviceClass
+
+    Device *device = new Device(deviceClassId, this);
     device->setName(deviceClass.name());
     device->setParams(params);
     m_configuredDevices.append(device);
+    return DeviceErrorNoError;
 }
 
 QList<Device *> DeviceManager::configuredDevices() const
@@ -49,6 +64,16 @@ QList<Device *> DeviceManager::findConfiguredDevices(const DeviceClass &deviceCl
     return ret;
 }
 
+DeviceClass DeviceManager::findDeviceClass(const QUuid &deviceClassId)
+{
+    foreach (const DeviceClass &deviceClass, m_supportedDevices) {
+        if (deviceClass.id() == deviceClassId) {
+            return deviceClass;
+        }
+    }
+    return DeviceClass(QUuid());
+}
+
 Radio433 *DeviceManager::radio433() const
 {
     return m_radio433;
diff --git a/libhive/devicemanager.h b/libhive/devicemanager.h
index 3ec0dc02..b205d878 100644
--- a/libhive/devicemanager.h
+++ b/libhive/devicemanager.h
@@ -14,15 +14,22 @@ class DeviceManager : public QObject
 {
     Q_OBJECT
 public:
+    enum DeviceError {
+        DeviceErrorNoError,
+        DeviceErrorDeviceNotFound,
+        DeviceErrorDeviceClassNotFound,
+        DeviceErrorMissingParameter
+    };
+
     explicit DeviceManager(QObject *parent = 0);
 
     QList<DeviceClass> supportedDevices();
 
-    void createDevice(const DeviceClass &deviceClass, const QVariantMap &params);
-
     QList<Device*> configuredDevices() const;
+    DeviceError addConfiguredDevice(const QUuid &deviceClassId, const QVariantMap &params);
 
     QList<Device*> findConfiguredDevices(const DeviceClass &deviceClass);
+    DeviceClass findDeviceClass(const QUuid &deviceClassId);
 
     Radio433 *radio433() const;
 
diff --git a/server/jsonrpcserver.cpp b/server/jsonrpcserver.cpp
index 5e3e7f3c..e0fc1d10 100644
--- a/server/jsonrpcserver.cpp
+++ b/server/jsonrpcserver.cpp
@@ -59,6 +59,23 @@ void JsonRPCServer::processData(int clientId, const QByteArray &jsonData)
             }
             params.insert("deviceClasses", supportedDeviceList);
             sendResponse(clientId, commandId, params);
+        } else if (method == "AddConfiguredDevice") {
+            QUuid deviceClass = params.value("deviceClass").toUuid();
+            QVariantMap deviceParams = params.value("deviceParams").toMap();
+            DeviceManager::DeviceError status = HiveCore::instance()->deviceManager()->addConfiguredDevice(deviceClass, deviceParams);
+            switch(status) {
+            case DeviceManager::DeviceErrorNoError:
+                sendResponse(clientId, commandId);
+                break;
+            case DeviceManager::DeviceErrorDeviceClassNotFound:
+                sendErrorResponse(clientId, commandId, "Error creating device. Device class not found.");
+                break;
+            case DeviceManager::DeviceErrorMissingParameter:
+                sendErrorResponse(clientId, commandId, "Error creating device. Missing parameter.");
+                break;
+            }
+        } else {
+            sendErrorResponse(clientId, commandId, "No such method");
         }
     } else {
         qDebug() << "got unknown namespace" << targetNamspace;
@@ -88,10 +105,22 @@ void JsonRPCServer::sendResponse(int clientId, int commandId, const QVariantMap
 {
     QVariantMap rsp;
     rsp.insert("id", commandId);
+    rsp.insert("status", "success");
     rsp.insert("params", params);
 
     QJsonDocument jsonDoc = QJsonDocument::fromVariant(rsp);
     m_tcpServer->sendResponse(clientId, jsonDoc.toJson());
 }
 
+void JsonRPCServer::sendErrorResponse(int clientId, int commandId, const QString &error)
+{
+    QVariantMap rsp;
+    rsp.insert("id", commandId);
+    rsp.insert("status", "error");
+    rsp.insert("error", error);
+
+    QJsonDocument jsonDoc = QJsonDocument::fromVariant(rsp);
+    m_tcpServer->sendResponse(clientId, jsonDoc.toJson());
+}
+
 
diff --git a/server/jsonrpcserver.h b/server/jsonrpcserver.h
index 0a01d626..1707732b 100644
--- a/server/jsonrpcserver.h
+++ b/server/jsonrpcserver.h
@@ -24,7 +24,8 @@ private slots:
 private:
     QVariantMap packDeviceClass(const DeviceClass &deviceClass);
 
-    void sendResponse(int clientId, int commandId, const QVariantMap &params);
+    void sendResponse(int clientId, int commandId, const QVariantMap &params = QVariantMap());
+    void sendErrorResponse(int clientId, int commandId, const QString &error);
 
 private:
     TcpServer *m_tcpServer;