diff --git a/include/rfl/parsing/Parser_map_like.hpp b/include/rfl/parsing/Parser_map_like.hpp
index 29c3ddcc..d4b3fe78 100644
--- a/include/rfl/parsing/Parser_map_like.hpp
+++ b/include/rfl/parsing/Parser_map_like.hpp
@@ -15,10 +15,14 @@
 namespace rfl {
 namespace parsing {
 
-template <class R, class W, class T, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::map<std::string, T>>
-struct Parser<R, W, std::map<std::string, T>, ProcessorsType>
-    : public MapParser<R, W, std::map<std::string, T>, ProcessorsType> {};
+template <class R, class W, class T, class ProcessorsType, class Compare,
+          class Allocator>
+  requires AreReaderAndWriter<R, W,
+                              std::map<std::string, T, Compare, Allocator>>
+struct Parser<R, W, std::map<std::string, T, Compare, Allocator>,
+              ProcessorsType>
+    : public MapParser<R, W, std::map<std::string, T, Compare, Allocator>,
+                       ProcessorsType> {};
 
 template <class R, class W, class T, class Hash, class KeyEqual,
           class Allocator, class ProcessorsType>
diff --git a/include/rfl/parsing/Parser_vector_like.hpp b/include/rfl/parsing/Parser_vector_like.hpp
index 81412156..8ce8322b 100644
--- a/include/rfl/parsing/Parser_vector_like.hpp
+++ b/include/rfl/parsing/Parser_vector_like.hpp
@@ -33,25 +33,33 @@ template <class R, class W, class T, class ProcessorsType>
 struct Parser<R, W, std::list<T>, ProcessorsType>
     : public VectorParser<R, W, std::list<T>, ProcessorsType> {};
 
-template <class R, class W, class K, class V, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::map<K, V>>
-struct Parser<R, W, std::map<K, V>, ProcessorsType>
-    : public VectorParser<R, W, std::map<K, V>, ProcessorsType> {};
+template <class R, class W, class K, class V, class Compare, class Allocator,
+          class ProcessorsType>
+  requires AreReaderAndWriter<R, W, std::map<K, V, Compare, Allocator>>
+struct Parser<R, W, std::map<K, V, Compare, Allocator>, ProcessorsType>
+    : public VectorParser<R, W, std::map<K, V, Compare, Allocator>,
+                          ProcessorsType> {};
 
-template <class R, class W, class K, class V, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::multimap<K, V>>
-struct Parser<R, W, std::multimap<K, V>, ProcessorsType>
-    : public VectorParser<R, W, std::multimap<K, V>, ProcessorsType> {};
+template <class R, class W, class K, class V, class Compare, class Allocator,
+          class ProcessorsType>
+  requires AreReaderAndWriter<R, W, std::multimap<K, V, Compare, Allocator>>
+struct Parser<R, W, std::multimap<K, V, Compare, Allocator>, ProcessorsType>
+    : public VectorParser<R, W, std::multimap<K, V, Compare, Allocator>,
+                          ProcessorsType> {};
 
-template <class R, class W, class T, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::multiset<T>>
-struct Parser<R, W, std::multiset<T>, ProcessorsType>
-    : public VectorParser<R, W, std::multiset<T>, ProcessorsType> {};
+template <class R, class W, class T, class Compare, class Allocator,
+          class ProcessorsType>
+  requires AreReaderAndWriter<R, W, std::multiset<T, Compare, Allocator>>
+struct Parser<R, W, std::multiset<T, Compare, Allocator>, ProcessorsType>
+    : public VectorParser<R, W, std::multiset<T, Compare, Allocator>,
+                          ProcessorsType> {};
 
-template <class R, class W, class T, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::set<T>>
-struct Parser<R, W, std::set<T>, ProcessorsType>
-    : public VectorParser<R, W, std::set<T>, ProcessorsType> {};
+template <class R, class W, class T, class Compare, class Allocator,
+          class ProcessorsType>
+  requires AreReaderAndWriter<R, W, std::set<T, Compare, Allocator>>
+struct Parser<R, W, std::set<T, Compare, Allocator>, ProcessorsType>
+    : public VectorParser<R, W, std::set<T, Compare, Allocator>,
+                          ProcessorsType> {};
 
 template <class R, class W, class K, class V, class Hash, class KeyEqual,
           class Allocator, class ProcessorsType>
diff --git a/include/rfl/parsing/is_map_like.hpp b/include/rfl/parsing/is_map_like.hpp
index 82f60021..1fb0cf65 100644
--- a/include/rfl/parsing/is_map_like.hpp
+++ b/include/rfl/parsing/is_map_like.hpp
@@ -14,11 +14,13 @@ class is_map_like;
 template <class T>
 class is_map_like : public std::false_type {};
 
-template <class K, class V>
-class is_map_like<std::map<K, V>> : public std::true_type {};
+template <class K, class V, class Compare, class Allocator>
+class is_map_like<std::map<K, V, Compare, Allocator>> : public std::true_type {
+};
 
-template <class K, class V>
-class is_map_like<std::multimap<K, V>> : public std::true_type {};
+template <class K, class V, class Compare, class Allocator>
+class is_map_like<std::multimap<K, V, Compare, Allocator>>
+    : public std::true_type {};
 
 template <class K, class V, class Hash, class KeyEqual, class Allocator>
 class is_map_like<std::unordered_map<K, V, Hash, KeyEqual, Allocator>>
diff --git a/include/rfl/parsing/is_map_like_not_multimap.hpp b/include/rfl/parsing/is_map_like_not_multimap.hpp
index 64811608..83475765 100644
--- a/include/rfl/parsing/is_map_like_not_multimap.hpp
+++ b/include/rfl/parsing/is_map_like_not_multimap.hpp
@@ -14,8 +14,9 @@ class is_map_like_not_multimap;
 template <class T>
 class is_map_like_not_multimap : public std::false_type {};
 
-template <class K, class V>
-class is_map_like_not_multimap<std::map<K, V>> : public std::true_type {};
+template <class K, class V, class Compare, class Allocator>
+class is_map_like_not_multimap<std::map<K, V, Compare, Allocator>>
+    : public std::true_type {};
 
 template <class K, class V, class Hash, class KeyEqual, class Allocator>
 class is_map_like_not_multimap<
diff --git a/tests/json/test_map_with_custom_less.cpp b/tests/json/test_map_with_custom_less.cpp
new file mode 100644
index 00000000..89405f49
--- /dev/null
+++ b/tests/json/test_map_with_custom_less.cpp
@@ -0,0 +1,30 @@
+#include <map>
+#include <memory>
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <string>
+
+#include "write_and_read.hpp"
+
+namespace test_map_with_custom_less {
+
+struct Person {
+  rfl::Rename<"firstName", std::string> first_name;
+  rfl::Rename<"lastName", std::string> last_name = "Simpson";
+  std::shared_ptr<std::map<size_t, Person, std::less<>>> children;
+};
+
+TEST(json, test_map_with_custom_less) {
+  auto children = std::make_shared<std::map<size_t, Person, std::less<>>>();
+  children->insert(std::make_pair(1, Person{.first_name = "Bart"}));
+  children->insert(std::make_pair(2, Person{.first_name = "Lisa"}));
+  children->insert(std::make_pair(2660778562, Person{.first_name = "Maggie"}));
+
+  const auto homer =
+      Person{.first_name = "Homer", .children = std::move(children)};
+
+  write_and_read(
+      homer,
+      R"({"firstName":"Homer","lastName":"Simpson","children":{"1":{"firstName":"Bart","lastName":"Simpson"},"2":{"firstName":"Lisa","lastName":"Simpson"},"2660778562":{"firstName":"Maggie","lastName":"Simpson"}}})");
+}
+}  // namespace test_map_with_custom_less