diff --git a/libnymea-core/nymeacore.cpp b/libnymea-core/nymeacore.cpp
index 91835696..b3d67e64 100644
--- a/libnymea-core/nymeacore.cpp
+++ b/libnymea-core/nymeacore.cpp
@@ -617,7 +617,7 @@ void NymeaCore::gotEvent(const Event &event)
                 //       something like a EventParamDescriptor
 
                 ruleActionParam.setValue(eventValue);
-                qCDebug(dcRuleEngine) << "take over event param value" << ruleActionParam.value();
+                qCDebug(dcRuleEngine) << "Using param value from event:" << ruleActionParam.value();
             }
             newParams.append(ruleActionParam);
         }
diff --git a/libnymea-core/ruleengine.cpp b/libnymea-core/ruleengine.cpp
index 47b8b9a8..d2fdb0a6 100644
--- a/libnymea-core/ruleengine.cpp
+++ b/libnymea-core/ruleengine.cpp
@@ -595,8 +595,9 @@ RuleEngine::RuleError RuleEngine::addRule(const Rule &rule, bool fromEdit)
 
                         // check if the param type of the event and the action match
                         QVariant::Type eventParamType = getEventParamType(ruleActionParam.eventTypeId(), ruleActionParam.eventParamTypeId());
+                        QVariant v(eventParamType);
                         QVariant::Type actionParamType = getActionParamType(action.actionTypeId(), ruleActionParam.paramTypeId());
-                        if (eventParamType != actionParamType) {
+                        if (eventParamType != actionParamType && !v.canConvert(actionParamType)) {
                             qCWarning(dcRuleEngine) << "Cannot create rule. RuleActionParam" << ruleActionParam.paramTypeId().toString() << " and given event param " << ruleActionParam.eventParamTypeId().toString() << "have not the same type:";
                             qCWarning(dcRuleEngine) << "        -> actionParamType:" << actionParamType;
                             qCWarning(dcRuleEngine) << "        ->  eventParamType:" << eventParamType;
diff --git a/tests/auto/rules/testrules.cpp b/tests/auto/rules/testrules.cpp
index c67feaa2..a0a52d4b 100644
--- a/tests/auto/rules/testrules.cpp
+++ b/tests/auto/rules/testrules.cpp
@@ -104,6 +104,9 @@ private slots:
     void testRuleActionParams_data();
     void testRuleActionParams();
 
+    void testRuleActionPAramsFromEventParameter_data();
+    void testRuleActionPAramsFromEventParameter();
+
     void testInterfaceBasedRule();
 
     void testHousekeeping_data();
@@ -2175,6 +2178,66 @@ void TestRules::testRuleActionParams()
     verifyRuleError(response, error);
 }
 
+void TestRules::testRuleActionPAramsFromEventParameter_data() {
+    QTest::addColumn<QVariantMap>("event");
+    QTest::addColumn<QVariantMap>("action");
+    QTest::addColumn<RuleEngine::RuleError>("error");
+
+    QVariantMap intEvent;
+    intEvent.insert("eventTypeId", mockIntStateId);
+    intEvent.insert("deviceId", m_mockDeviceId);
+
+    QVariantMap intAction;
+    intAction.insert("actionTypeId", mockActionIdWithParams);
+    intAction.insert("deviceId", m_mockDeviceId);
+    QVariantList ruleActionParams;
+    QVariantMap intParam;
+    intParam.insert("paramTypeId", mockActionParam1ParamTypeId);
+    intParam.insert("eventTypeId", mockIntStateId);
+    intParam.insert("eventParamTypeId", mockIntStateId);
+    ruleActionParams.append(intParam);
+    QVariantMap boolParam;
+    boolParam.insert("paramTypeId", mockActionParam2ParamTypeId);
+    boolParam.insert("value", true);
+    ruleActionParams.append(boolParam);
+    intAction.insert("ruleActionParams", ruleActionParams);
+
+    QVariantMap boolAction;
+    boolAction.insert("actionTypeId", mockActionIdWithParams);
+    boolAction.insert("deviceId", m_mockDeviceId);
+    ruleActionParams.clear();
+    intParam.clear();
+    intParam.insert("paramTypeId", mockActionParam1ParamTypeId);
+    intParam.insert("value", 5);
+    ruleActionParams.append(intParam);
+    boolParam.clear();
+    boolParam.insert("paramTypeId", mockActionParam2ParamTypeId);
+    boolParam.insert("eventTypeId", mockIntStateId);
+    boolParam.insert("eventParamTypeId", mockIntStateId);
+    ruleActionParams.append(boolParam);
+    boolAction.insert("ruleActionParams", ruleActionParams);
+
+    QTest::newRow("int -> int") << intEvent << intAction << RuleEngine::RuleErrorNoError;
+    QTest::newRow("int -> bool") << intEvent << boolAction << RuleEngine::RuleErrorNoError;
+}
+
+void TestRules::testRuleActionPAramsFromEventParameter()
+{
+    QFETCH(QVariantMap, event);
+    QFETCH(QVariantMap, action);
+    QFETCH(RuleEngine::RuleError, error);
+
+    QVariantMap addRuleParams;
+    addRuleParams.insert("name", "TestRule");
+    addRuleParams.insert("enabled", true);
+
+    addRuleParams.insert("eventDescriptors", QVariantList() << event);
+    addRuleParams.insert("actions", QVariantList() << action);
+
+    QVariant response = injectAndWait("Rules.AddRule", addRuleParams);
+    verifyRuleError(response, error);
+}
+
 void TestRules::testInterfaceBasedRule()
 {
     QVariantMap powerAction;