diff --git a/docs/mkdocs/docs/api/macros/json_use_objects_for_enum_keyed_maps.md b/docs/mkdocs/docs/api/macros/json_use_objects_for_enum_keyed_maps.md
index d8218b8ec..a84d83129 100644
--- a/docs/mkdocs/docs/api/macros/json_use_objects_for_enum_keyed_maps.md
+++ b/docs/mkdocs/docs/api/macros/json_use_objects_for_enum_keyed_maps.md
@@ -35,6 +35,11 @@ The default value is `0` (disabled — existing behavior is preserved).
     {"completed": "bb", "stopped": "aa"}
     ```
 
+!!! note "Maps with non-unique keys"
+
+    Maps that allow duplicate keys, such as `std::multimap<E, T>` or `std::unordered_multimap<E, T>`, are not affected
+    by the macro and are still stored as arrays of `[key, value]` pairs, as an object cannot hold duplicate keys.
+
 !!! note "Reading"
 
     Reading is not affected by the macro: a map with enum keys can always be read from both an array of pairs and an
diff --git a/include/nlohmann/detail/meta/type_traits.hpp b/include/nlohmann/detail/meta/type_traits.hpp
index b27d6b5b1..c97947d16 100644
--- a/include/nlohmann/detail/meta/type_traits.hpp
+++ b/include/nlohmann/detail/meta/type_traits.hpp
@@ -400,6 +400,12 @@ template<typename BasicJsonType, typename CompatibleObjectType>
 struct is_compatible_object_type
     : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
 
+template<typename T>
+using insert_result_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()));
+
+template<typename T>
+using insert_result_second_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()).second);
+
 // a map-like type (std::map, std::unordered_map, ...) whose keys are enums; see
 // JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
 template<typename T, typename = void>
@@ -410,8 +416,12 @@ struct is_enum_keyed_map <
     T, enable_if_t < is_detected<mapped_type_t, T>::value&&
     is_detected<key_type_t, T>::value >>
 {
+    // maps with non-unique keys (std::multimap, std::unordered_multimap, ...)
+    // are excluded, because an object cannot hold duplicate keys; they are
+    // detected by insert() returning an iterator instead of a pair<iterator, bool>
     // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    static constexpr bool value = std::is_enum<typename T::key_type>::value;
+    static constexpr bool value = std::is_enum<typename T::key_type>::value &&
+                                  !(is_detected<insert_result_t, T>::value && !is_detected<insert_result_second_t, T>::value);
 };
 
 template<typename BasicJsonType, typename ConstructibleObjectType,
diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp
index 183707735..8c6da9df9 100644
--- a/single_include/nlohmann/json.hpp
+++ b/single_include/nlohmann/json.hpp
@@ -4421,6 +4421,12 @@ template<typename BasicJsonType, typename CompatibleObjectType>
 struct is_compatible_object_type
     : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
 
+template<typename T>
+using insert_result_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()));
+
+template<typename T>
+using insert_result_second_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()).second);
+
 // a map-like type (std::map, std::unordered_map, ...) whose keys are enums; see
 // JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
 template<typename T, typename = void>
@@ -4431,8 +4437,12 @@ struct is_enum_keyed_map <
     T, enable_if_t < is_detected<mapped_type_t, T>::value&&
     is_detected<key_type_t, T>::value >>
 {
+    // maps with non-unique keys (std::multimap, std::unordered_multimap, ...)
+    // are excluded, because an object cannot hold duplicate keys; they are
+    // detected by insert() returning an iterator instead of a pair<iterator, bool>
     // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    static constexpr bool value = std::is_enum<typename T::key_type>::value;
+    static constexpr bool value = std::is_enum<typename T::key_type>::value &&
+                                  !(is_detected<insert_result_t, T>::value && !is_detected<insert_result_second_t, T>::value);
 };
 
 template<typename BasicJsonType, typename ConstructibleObjectType,
diff --git a/tests/src/unit-enum_keyed_maps.cpp b/tests/src/unit-enum_keyed_maps.cpp
index b8b7d9728..33228a2a7 100644
--- a/tests/src/unit-enum_keyed_maps.cpp
+++ b/tests/src/unit-enum_keyed_maps.cpp
@@ -198,6 +198,14 @@ TEST_CASE("JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS")
         CHECK(json(int_keys) == json::parse("[[1,2]]"));
     }
 
+    SECTION("maps with non-unique keys are still stored as arrays of pairs")
+    {
+        const std::multimap<TaskState, int> mm = {{TS_STOPPED, 1}, {TS_STOPPED, 2}};
+        const std::unordered_multimap<TaskState, int, enum_hash> umm = {{TS_RUNNING, 3}, {TS_RUNNING, 3}};
+        CHECK(json(mm) == json::parse(R"([["stopped",1],["stopped",2]])"));
+        CHECK(json(umm) == json::parse(R"([["running",3],["running",3]])"));
+    }
+
     SECTION("keys that do not serialize to strings")
     {
         const std::map<TaskState, int> null_key = {{TS_INVALID, 1}};