diff --git a/monitor/json_parser.cpp b/monitor/json_parser.cpp
index b2b0c06..82fc621 100644
--- a/monitor/json_parser.cpp
+++ b/monitor/json_parser.cpp
@@ -20,6 +20,7 @@
 #include "nonzero_speed_trust.hpp"
 #include "power_interface.hpp"
 #include "power_off_rule.hpp"
+#include "tach_sensor.hpp"
 #include "types.hpp"
 
 #include <fmt/format.h>
@@ -57,6 +58,8 @@
     {"nonzerospeed", tClass::getNonZeroSpeed}};
 const std::map<std::string, condHandler> conditions = {
     {"propertiesmatch", condition::getPropertiesMatch}};
+const std::map<std::string, size_t> methods = {
+    {"timebased", MethodMode::timebased}, {"count", MethodMode::count}};
 
 const std::vector<CreateGroupFunction> getTrustGrps(const json& obj)
 {
@@ -155,10 +158,16 @@
         {
             offset = sensor["offset"].get<int64_t>();
         }
+        // Threshold is optional and defaults to 1
+        auto threshold = 1;
+        if (sensor.contains("threshold"))
+        {
+            threshold = sensor["threshold"].get<size_t>();
+        }
 
-        sensorDefs.emplace_back(std::tuple(sensor["name"].get<std::string>(),
-                                           sensor["has_target"].get<bool>(),
-                                           targetIntf, factor, offset));
+        sensorDefs.emplace_back(std::tuple(
+            sensor["name"].get<std::string>(), sensor["has_target"].get<bool>(),
+            targetIntf, factor, offset, threshold));
     }
 
     return sensorDefs;
@@ -170,16 +179,14 @@
 
     for (const auto& fan : obj["fans"])
     {
-        if (!fan.contains("inventory") ||
-            !fan.contains("allowed_out_of_range_time") ||
-            !fan.contains("deviation") || !fan.contains("sensors"))
+        if (!fan.contains("inventory") || !fan.contains("deviation") ||
+            !fan.contains("sensors"))
         {
             // Log error on missing required parameters
             log<level::ERR>(
                 "Missing required fan monitor definition parameters",
                 entry("REQUIRED_PARAMETERS=%s",
-                      "{inventory, allowed_out_of_range_time, deviation, "
-                      "sensors}"));
+                      "{inventory, deviation, sensors}"));
             throw std::runtime_error(
                 "Missing required fan monitor definition parameters");
         }
@@ -193,6 +200,45 @@
             funcDelay = fan["functional_delay"].get<size_t>();
         }
 
+        // Method is optional and defaults to time based functional
+        // determination
+        size_t method = MethodMode::timebased;
+        if (fan.contains("method"))
+        {
+            auto methodConf = fan["method"].get<std::string>();
+            auto methodFunc = methods.find(methodConf);
+            if (methodFunc != methods.end())
+            {
+                method = methodFunc->second;
+            }
+            else
+            {
+                // Log error on unsupported method parameter
+                log<level::ERR>("Invalid fan method");
+                throw std::runtime_error("Invalid fan method");
+            }
+        }
+
+        // Timeout defaults to 0
+        size_t timeout = 0;
+        if (method == MethodMode::timebased)
+        {
+            if (!fan.contains("allowed_out_of_range_time"))
+            {
+                // Log error on missing required parameter
+                log<level::ERR>(
+                    "Missing required fan monitor definition parameters",
+                    entry("REQUIRED_PARAMETER=%s",
+                          "{allowed_out_of_range_time}"));
+                throw std::runtime_error(
+                    "Missing required fan monitor definition parameters");
+            }
+            else
+            {
+                timeout = fan["allowed_out_of_range_time"].get<size_t>();
+            }
+        }
+
         // Monitor start delay is optional and defaults to 0
         size_t monitorDelay = 0;
         if (fan.contains("monitor_start_delay"))
@@ -261,9 +307,9 @@
                     entry("JSON_DUMP=%s", fan["condition"].dump().c_str()));
             }
         }
+
         fanDefs.emplace_back(std::tuple(
-            fan["inventory"].get<std::string>(), funcDelay,
-            fan["allowed_out_of_range_time"].get<size_t>(),
+            fan["inventory"].get<std::string>(), method, funcDelay, timeout,
             fan["deviation"].get<size_t>(), nonfuncSensorsCount, monitorDelay,
             nonfuncRotorErrorDelay, fanMissingErrorDelay, sensorDefs, cond));
     }