diff --git a/redfish-core/include/utils/json_utils.hpp b/redfish-core/include/utils/json_utils.hpp
index 60994fe..f621a45 100644
--- a/redfish-core/include/utils/json_utils.hpp
+++ b/redfish-core/include/utils/json_utils.hpp
@@ -95,8 +95,7 @@
 };
 
 template <typename ToType, typename FromType>
-bool checkRange(const FromType& from [[maybe_unused]],
-                std::string_view key [[maybe_unused]])
+bool checkRange(const FromType& from, std::string_view key)
 {
     if constexpr (std::is_floating_point_v<ToType>)
     {
@@ -105,21 +104,19 @@
             BMCWEB_LOG_DEBUG("Value for key {} was NAN", key);
             return false;
         }
+        // Assume for the moment that all floats can represent the full range
+        // of any int/uint in a cast.  This is close enough to true for the
+        // precision of this json parser.
     }
-    if constexpr (std::numeric_limits<ToType>::max() <
-                  std::numeric_limits<FromType>::max())
+    else
     {
-        if (from > std::numeric_limits<ToType>::max())
+        if (std::cmp_greater(from, std::numeric_limits<ToType>::max()))
         {
             BMCWEB_LOG_DEBUG("Value for key {} was greater than max {}", key,
                              std::numeric_limits<FromType>::max());
             return false;
         }
-    }
-    if constexpr (std::numeric_limits<ToType>::lowest() >
-                  std::numeric_limits<FromType>::lowest())
-    {
-        if (from < std::numeric_limits<ToType>::lowest())
+        if (std::cmp_less(from, std::numeric_limits<ToType>::lowest()))
         {
             BMCWEB_LOG_DEBUG("Value for key {} was less than min {}", key,
                              std::numeric_limits<FromType>::lowest());
@@ -189,13 +186,26 @@
         int64_t* jsonPtr = jsonValue.get_ptr<int64_t*>();
         if (jsonPtr == nullptr)
         {
-            return UnpackErrorCode::invalidType;
+            // Value wasn't int, check uint
+            uint64_t* uJsonPtr = jsonValue.get_ptr<uint64_t*>();
+            if (uJsonPtr == nullptr)
+            {
+                return UnpackErrorCode::invalidType;
+            }
+            if (!checkRange<Type>(*uJsonPtr, key))
+            {
+                return UnpackErrorCode::outOfRange;
+            }
+            value = static_cast<Type>(*uJsonPtr);
         }
-        if (!checkRange<Type>(*jsonPtr, key))
+        else
         {
-            return UnpackErrorCode::outOfRange;
+            if (!checkRange<Type>(*jsonPtr, key))
+            {
+                return UnpackErrorCode::outOfRange;
+            }
+            value = static_cast<Type>(*jsonPtr);
         }
-        value = static_cast<Type>(*jsonPtr);
     }
 
     else if constexpr ((std::is_unsigned_v<Type>) &&
@@ -204,13 +214,25 @@
         uint64_t* jsonPtr = jsonValue.get_ptr<uint64_t*>();
         if (jsonPtr == nullptr)
         {
-            return UnpackErrorCode::invalidType;
+            int64_t* ijsonPtr = jsonValue.get_ptr<int64_t*>();
+            if (ijsonPtr == nullptr)
+            {
+                return UnpackErrorCode::invalidType;
+            }
+            if (!checkRange<Type>(*ijsonPtr, key))
+            {
+                return UnpackErrorCode::outOfRange;
+            }
+            value = static_cast<Type>(*ijsonPtr);
         }
-        if (!checkRange<Type>(*jsonPtr, key))
+        else
         {
-            return UnpackErrorCode::outOfRange;
+            if (!checkRange<Type>(*jsonPtr, key))
+            {
+                return UnpackErrorCode::outOfRange;
+            }
+            value = static_cast<Type>(*jsonPtr);
         }
-        value = static_cast<Type>(*jsonPtr);
     }
 
     else if constexpr (std::is_same_v<nlohmann::json, Type>)
diff --git a/redfish-core/src/filter_expr_executor.cpp b/redfish-core/src/filter_expr_executor.cpp
index 838fa64..e2513e1 100644
--- a/redfish-core/src/filter_expr_executor.cpp
+++ b/redfish-core/src/filter_expr_executor.cpp
@@ -152,6 +152,17 @@
     {
         return {*iValue};
     }
+    const uint64_t* uValue = entry.get_ptr<const uint64_t*>();
+    if (uValue != nullptr)
+    {
+        // For now all values are coerced to signed
+        if (*uValue > std::numeric_limits<int64_t>::max())
+        {
+            BMCWEB_LOG_WARNING("Parsed uint is outside limits");
+            return {};
+        }
+        return {static_cast<int64_t>(*uValue)};
+    }
     const std::string* strValue = entry.get_ptr<const std::string*>();
     if (strValue != nullptr)
     {