diff --git a/docs/content/variants_and_tagged_unions.md b/docs/content/variants_and_tagged_unions.md
index 3b39522e7..d86100e1c 100644
--- a/docs/content/variants_and_tagged_unions.md
+++ b/docs/content/variants_and_tagged_unions.md
@@ -252,6 +252,26 @@ The resulting JSON looks like this:
 
 Because the tag is external, this is called *externally tagged*. It is the standard in Rust's [serde-json](https://serde.rs/enum-representations.html).
 
+## `std::monostate`
+
+`std::monostate` is serialized as `null`. A `std::variant` or `rfl::Variant` whose
+first alternative is `std::monostate` behaves like `std::optional`: as a field, it is
+omitted when it holds `std::monostate` and a missing field is read as `std::monostate`.
+
+```cpp
+struct Order {
+  std::variant<std::monostate, std::string, int> price;
+};
+
+rfl::json::write(Order{.price = std::monostate{}});  // {}
+rfl::json::write(Order{.price = 2});                 // {"price":2}
+```
+
+Both `{}` and `{"price":null}` are read as `std::monostate`.
+
+As with `std::optional`, passing `rfl::NoOptionals` writes the field as `null`
+(`{"price":null}`) and makes it required on read.
+
 
 ## The visitor pattern
 
diff --git a/include/rfl/parsing/ParserMonostate.hpp b/include/rfl/parsing/ParserMonostate.hpp
new file mode 100644
index 000000000..1c07de129
--- /dev/null
+++ b/include/rfl/parsing/ParserMonostate.hpp
@@ -0,0 +1,58 @@
+#ifndef RFL_PARSING_PARSER_MONOSTATE_HPP_
+#define RFL_PARSING_PARSER_MONOSTATE_HPP_
+
+#include <map>
+#include <string>
+#include <variant>
+
+#include "../Result.hpp"
+#include "Parent.hpp"
+#include "Parser_base.hpp"
+#include "is_monostate.hpp"
+#include "schema/Type.hpp"
+
+namespace rfl::parsing {
+
+template <class R, class W, class ProcessorsType>
+struct ParserMonostate {
+  using InputVarType = typename R::InputVarType;
+
+  using ParentType = Parent<W>;
+
+  /**
+   * @brief Reads a std::monostate from the input, which must be null.
+   * @param _r The reader to use.
+   * @param _var The input variable to read.
+   * @return A Result containing the std::monostate or an error.
+   */
+  static Result<std::monostate> read(const R& _r,
+                                     const InputVarType& _var) noexcept {
+    if (!_r.is_empty(_var)) {
+      return error("Expected null for std::monostate.");
+    }
+    return std::monostate{};
+  }
+
+  /**
+   * @brief Writes a std::monostate to the output as null.
+   * @tparam P The type of the parent.
+   * @param _w The writer to use.
+   * @param _parent The parent object.
+   */
+  template <class P>
+  static void write(const W& _w, const std::monostate&, const P& _parent) {
+    ParentType::add_null(_w, _parent);
+  }
+
+  /**
+   * @brief Generates the schema for std::monostate.
+   * @return The null schema type.
+   */
+  static schema::Type to_schema(std::map<std::string, schema::Type>*) {
+    return schema::Type{schema::Type::Null{}};
+  }
+};
+
+}  // namespace rfl::parsing
+
+#endif
diff --git a/include/rfl/parsing/Parser_default.hpp b/include/rfl/parsing/Parser_default.hpp
index 3a92a86cf..7d1986a8d 100644
--- a/include/rfl/parsing/Parser_default.hpp
+++ b/include/rfl/parsing/Parser_default.hpp
@@ -38,6 +38,7 @@
 #include "ParserEnum.hpp"
 #include "ParserExpected.hpp"
 #include "ParserFilepath.hpp"
+#include "ParserMonostate.hpp"
 #include "ParserOptional.hpp"
 #include "ParserPair.hpp"
 #include "ParserPositional.hpp"
@@ -152,6 +153,9 @@ struct Parser {
     } else if constexpr (is_filepath_v<T>) {
       return ParserFilepath<R, W, ProcessorsType>::read(_r, _var);
 
+    } else if constexpr (is_monostate_v<T>) {
+      return ParserMonostate<R, W, ProcessorsType>::read(_r, _var);
+
     } else if constexpr (is_skip_v<T>) {
       using U = std::remove_cvref_t<T>;
       return ParserSkip<R, W, typename U::Type, U::skip_serialization_,
@@ -339,6 +343,9 @@ struct Parser {
     } else if constexpr (is_filepath_v<T>) {
       ParserFilepath<R, W, ProcessorsType>::write(_w, _var, _parent);
 
+    } else if constexpr (is_monostate_v<T>) {
+      ParserMonostate<R, W, ProcessorsType>::write(_w, _var, _parent);
+
     } else if constexpr (is_skip_v<T>) {
       using U = std::remove_cvref_t<T>;
       ParserSkip<R, W, typename U::Type, U::skip_serialization_,
@@ -512,6 +519,9 @@ struct Parser {
     } else if constexpr (is_filepath_v<U>) {
       return ParserFilepath<R, W, ProcessorsType>::to_schema(_definitions);
 
+    } else if constexpr (is_monostate_v<U>) {
+      return ParserMonostate<R, W, ProcessorsType>::to_schema(_definitions);
+
     } else if constexpr (is_skip_v<U>) {
       return ParserSkip<R, W, typename U::Type, U::skip_serialization_,
                         U::skip_deserialization_,
diff --git a/include/rfl/parsing/is_empty.hpp b/include/rfl/parsing/is_empty.hpp
index 41d5b8511..67d875226 100644
--- a/include/rfl/parsing/is_empty.hpp
+++ b/include/rfl/parsing/is_empty.hpp
@@ -8,6 +8,7 @@
 #include "../internal/is_rename.hpp"
 #include "../internal/is_skip.hpp"
 #include "is_map_like.hpp"
+#include "is_monostate_variant.hpp"
 #include "is_vector_like.hpp"
 
 namespace rfl {
@@ -36,6 +37,8 @@ static bool is_empty(const T& _var) {
     }
   } else if constexpr (internal::is_rename_v<Type>) {
     return is_empty(_var.value());
+  } else if constexpr (is_monostate_variant_v<Type>) {
+    return _var.index() == 0;
   } else if constexpr (is_map_like_v<Type> || is_vector_like_v<Type>) {
     return _var.begin() == _var.end();
   } else {
diff --git a/include/rfl/parsing/is_monostate.hpp b/include/rfl/parsing/is_monostate.hpp
new file mode 100644
index 000000000..cb6ce7b72
--- /dev/null
+++ b/include/rfl/parsing/is_monostate.hpp
@@ -0,0 +1,20 @@
+#ifndef RFL_PARSING_IS_MONOSTATE_HPP_
+#define RFL_PARSING_IS_MONOSTATE_HPP_
+
+#include <type_traits>
+#include <variant>
+
+namespace rfl::parsing {
+
+template <class T>
+struct is_monostate : std::false_type {};
+
+template <>
+struct is_monostate<std::monostate> : std::true_type {};
+
+template <class T>
+constexpr bool is_monostate_v = is_monostate<std::remove_cvref_t<T>>::value;
+
+}  // namespace rfl::parsing
+
+#endif
diff --git a/include/rfl/parsing/is_monostate_variant.hpp b/include/rfl/parsing/is_monostate_variant.hpp
new file mode 100644
index 000000000..ffe397beb
--- /dev/null
+++ b/include/rfl/parsing/is_monostate_variant.hpp
@@ -0,0 +1,29 @@
+#ifndef RFL_PARSING_IS_MONOSTATE_VARIANT_HPP_
+#define RFL_PARSING_IS_MONOSTATE_VARIANT_HPP_
+
+#include <type_traits>
+#include <variant>
+
+#include "../Variant.hpp"
+#include "is_monostate.hpp"
+
+namespace rfl::parsing {
+
+template <class T>
+struct is_monostate_variant : std::false_type {};
+
+template <class T, class... Ts>
+struct is_monostate_variant<std::variant<T, Ts...>>
+    : std::bool_constant<is_monostate_v<T>> {};
+
+template <class T, class... Ts>
+struct is_monostate_variant<rfl::Variant<T, Ts...>>
+    : std::bool_constant<is_monostate_v<T>> {};
+
+template <class T>
+constexpr bool is_monostate_variant_v =
+    is_monostate_variant<std::remove_cvref_t<T>>::value;
+
+}  // namespace rfl::parsing
+
+#endif
diff --git a/include/rfl/parsing/is_required.hpp b/include/rfl/parsing/is_required.hpp
index 30fe10f6a..e59c7f932 100644
--- a/include/rfl/parsing/is_required.hpp
+++ b/include/rfl/parsing/is_required.hpp
@@ -15,6 +15,7 @@
 #include "../internal/is_rename.hpp"
 #include "../internal/is_short.hpp"
 #include "is_map_like.hpp"
+#include "is_monostate_variant.hpp"
 #include "is_vector_like.hpp"
 
 namespace rfl {
@@ -64,7 +65,7 @@ consteval bool is_required() {
   } else if constexpr (internal::is_short_v<Type>) {
     return is_required<typename Type::Type, _ignore_empty_containers>();
   } else {
-    return !(is_never_required_v<Type> ||
+    return !(is_never_required_v<Type> || is_monostate_variant_v<Type> ||
              (_ignore_empty_containers &&
               (is_vector_like_v<Type> || is_map_like_v<Type>)));
   }
diff --git a/include/rfl/parsing/schema/Type.hpp b/include/rfl/parsing/schema/Type.hpp
index c81679ce6..6159cc176 100644
--- a/include/rfl/parsing/schema/Type.hpp
+++ b/include/rfl/parsing/schema/Type.hpp
@@ -19,6 +19,8 @@ namespace rfl::parsing::schema {
 struct RFL_API Type {
   struct Boolean {};
 
+  struct Null {};
+
   struct Bytestring {};
 
   struct Vectorstring {};
@@ -115,9 +117,9 @@ struct RFL_API Type {
   };
 
   using VariantType =
-      rfl::Variant<Boolean, Bytestring, Vectorstring, Int32, Int64, UInt32,
-                   UInt64, Integer, Float, Double, String, AnyOf, DefaultVal,
-                   Deprecated, Description, DescribedLiteral,
+      rfl::Variant<Boolean, Null, Bytestring, Vectorstring, Int32, Int64,
+                   UInt32, UInt64, Integer, Float, Double, String, AnyOf,
+                   DefaultVal, Deprecated, Description, DescribedLiteral,
                    FixedSizeTypedArray, Literal, Object, Optional, Reference,
                    StringMap, Tuple, TypedArray, Validated>;
 
diff --git a/src/rfl/avro/to_schema.cpp b/src/rfl/avro/to_schema.cpp
index 5b8e25a3b..d1dedc867 100644
--- a/src/rfl/avro/to_schema.cpp
+++ b/src/rfl/avro/to_schema.cpp
@@ -50,6 +50,9 @@ schema::Type type_to_avro_schema_type(
     if constexpr (std::is_same<T, Type::Boolean>()) {
       return schema::Type{.value = schema::Type::Boolean{}};
 
+    } else if constexpr (std::is_same<T, Type::Null>()) {
+      return schema::Type{.value = schema::Type::Null{}};
+
     } else if constexpr (std::is_same<T, Type::Bytestring>() ||
                          std::is_same<T, Type::Vectorstring>()) {
       return schema::Type{.value = schema::Type::Bytes{}};
diff --git a/src/rfl/capnproto/to_schema.cpp b/src/rfl/capnproto/to_schema.cpp
index 6d166e286..cf2fd84ce 100644
--- a/src/rfl/capnproto/to_schema.cpp
+++ b/src/rfl/capnproto/to_schema.cpp
@@ -188,6 +188,9 @@ schema::Type type_to_capnproto_schema_type(
     if constexpr (std::is_same<T, Type::Boolean>()) {
       return schema::Type{.value = schema::Type::Bool{}};
 
+    } else if constexpr (std::is_same<T, Type::Null>()) {
+      return schema::Type{.value = schema::Type::Void{}};
+
     } else if constexpr (std::is_same<T, Type::Bytestring>() ||
                          std::is_same<T, Type::Vectorstring>()) {
       return schema::Type{.value = schema::Type::Data{}};
diff --git a/src/rfl/json/to_schema.cpp b/src/rfl/json/to_schema.cpp
index 3c5426e8d..06bb96442 100644
--- a/src/rfl/json/to_schema.cpp
+++ b/src/rfl/json/to_schema.cpp
@@ -47,6 +47,11 @@ bool is_optional(const parsing::schema::Type& _t) {
     } else if constexpr (std::is_same_v<T, parsing::schema::Type::Validated>) {
       return is_optional(*_v.type_);
 
+    } else if constexpr (std::is_same_v<T, parsing::schema::Type::AnyOf>) {
+      return !_v.types_.empty() &&
+             rfl::holds_alternative<parsing::schema::Type::Null>(
+                 _v.types_.front().variant_);
+
     } else {
       return std::is_same_v<T, parsing::schema::Type::Optional> ||
              std::is_same_v<T, parsing::schema::Type::DefaultVal>;
@@ -199,6 +204,9 @@ schema::Type type_to_json_schema_type(const parsing::schema::Type& _type,
     if constexpr (std::is_same<T, Type::Boolean>()) {
       return schema::Type{.value = schema::Type::Boolean{}};
 
+    } else if constexpr (std::is_same<T, Type::Null>()) {
+      return schema::Type{.value = schema::Type::Null{}};
+
     } else if constexpr (std::is_same<T, Type::Int32>() ||
                          std::is_same<T, Type::Int64>() ||
                          std::is_same<T, Type::UInt32>() ||
diff --git a/tests/avro/test_monostate.cpp b/tests/avro/test_monostate.cpp
new file mode 100644
index 000000000..d50af663d
--- /dev/null
+++ b/tests/avro/test_monostate.cpp
@@ -0,0 +1,29 @@
+#include <rfl.hpp>
+#include <string>
+#include <variant>
+
+#include "write_and_read.hpp"
+
+namespace test_monostate {
+
+struct Order {
+  std::variant<std::monostate, std::string, int> price;
+};
+
+struct RflOrder {
+  rfl::Variant<std::monostate, std::string, int> price;
+};
+
+TEST(avro, test_monostate) {
+  write_and_read(Order{.price = std::monostate{}});
+  write_and_read(Order{.price = "1.25"});
+  write_and_read(Order{.price = 2});
+}
+
+TEST(avro, test_monostate_rfl_variant) {
+  write_and_read(RflOrder{.price = std::monostate{}});
+  write_and_read(RflOrder{.price = std::string("1.25")});
+  write_and_read(RflOrder{.price = 2});
+}
+
+}  // namespace test_monostate
diff --git a/tests/cbor/test_monostate.cpp b/tests/cbor/test_monostate.cpp
new file mode 100644
index 000000000..a6f11daa6
--- /dev/null
+++ b/tests/cbor/test_monostate.cpp
@@ -0,0 +1,39 @@
+#include <rfl.hpp>
+#include <string>
+#include <variant>
+
+#include "write_and_read.hpp"
+
+namespace test_monostate {
+
+struct Order {
+  std::variant<std::monostate, std::string, int> price;
+};
+
+struct RflOrder {
+  rfl::Variant<std::monostate, std::string, int> price;
+};
+
+struct Empty {};
+
+TEST(cbor, test_monostate) {
+  write_and_read(Order{.price = std::monostate{}});
+  write_and_read(Order{.price = "1.25"});
+  write_and_read(Order{.price = 2});
+
+  const auto res = rfl::cbor::read<Order>(rfl::cbor::write(Empty{}));
+  ASSERT_TRUE(res) << res.error().what();
+  EXPECT_TRUE(std::holds_alternative<std::monostate>(res->price));
+}
+
+TEST(cbor, test_monostate_rfl_variant) {
+  write_and_read(RflOrder{.price = std::monostate{}});
+  write_and_read(RflOrder{.price = std::string("1.25")});
+  write_and_read(RflOrder{.price = 2});
+
+  const auto res = rfl::cbor::read<RflOrder>(rfl::cbor::write(Empty{}));
+  ASSERT_TRUE(res) << res.error().what();
+  EXPECT_TRUE(rfl::holds_alternative<std::monostate>(res->price));
+}
+
+}  // namespace test_monostate
diff --git a/tests/json/test_monostate.cpp b/tests/json/test_monostate.cpp
new file mode 100644
index 000000000..28e6aff9c
--- /dev/null
+++ b/tests/json/test_monostate.cpp
@@ -0,0 +1,79 @@
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <string>
+#include <variant>
+
+#include "write_and_read.hpp"
+
+namespace test_monostate {
+
+struct Order {
+  std::variant<std::monostate, std::string, int> price;
+};
+
+struct RflOrder {
+  rfl::Variant<std::monostate, std::string, int> price;
+};
+
+TEST(json, test_monostate) {
+  write_and_read(Order{.price = std::monostate{}}, R"({})");
+  write_and_read(Order{.price = "1.25"}, R"({"price":"1.25"})");
+  write_and_read(Order{.price = 2}, R"({"price":2})");
+
+  for (const auto json : {R"({})", R"({"price":null})"}) {
+    const auto res = rfl::json::read<Order>(json);
+    ASSERT_TRUE(res) << res.error().what();
+    EXPECT_TRUE(std::holds_alternative<std::monostate>(res->price));
+  }
+}
+
+TEST(json, test_monostate_rfl_variant) {
+  write_and_read(RflOrder{.price = std::monostate{}}, R"({})");
+  write_and_read(RflOrder{.price = std::string("1.25")}, R"({"price":"1.25"})");
+  write_and_read(RflOrder{.price = 2}, R"({"price":2})");
+
+  for (const auto json : {R"({})", R"({"price":null})"}) {
+    const auto res = rfl::json::read<RflOrder>(json);
+    ASSERT_TRUE(res) << res.error().what();
+    EXPECT_TRUE(rfl::holds_alternative<std::monostate>(res->price));
+  }
+}
+
+TEST(json, test_monostate_no_optionals) {
+  write_and_read<rfl::NoOptionals>(Order{.price = std::monostate{}},
+                                   R"({"price":null})");
+  write_and_read<rfl::NoOptionals>(Order{.price = 2}, R"({"price":2})");
+
+  EXPECT_FALSE((rfl::json::read<Order, rfl::NoOptionals>(R"({})")));
+}
+
+TEST(json, test_monostate_no_optionals_rfl_variant) {
+  write_and_read<rfl::NoOptionals>(RflOrder{.price = std::monostate{}},
+                                   R"({"price":null})");
+  write_and_read<rfl::NoOptionals>(RflOrder{.price = 2}, R"({"price":2})");
+
+  EXPECT_FALSE((rfl::json::read<RflOrder, rfl::NoOptionals>(R"({})")));
+}
+
+TEST(json, test_monostate_top_level) {
+  write_and_read(std::variant<std::monostate, int>{}, "null");
+  write_and_read(rfl::Variant<std::monostate, int>{}, "null");
+}
+
+TEST(json, test_monostate_rejects_non_null) {
+  EXPECT_FALSE(rfl::json::read<std::monostate>("1"));
+}
+
+TEST(json, test_monostate_schema) {
+  EXPECT_EQ(
+      rfl::json::to_schema<std::monostate>(),
+      R"({"$schema":"https://json-schema.org/draft/2020-12/schema","type":"null","$defs":{}})");
+}
+
+TEST(json, test_monostate_field_not_required_in_schema) {
+  EXPECT_EQ(
+      rfl::json::to_schema<Order>(),
+      R"({"$schema":"https://json-schema.org/draft/2020-12/schema","$ref":"#/$defs/test_monostate__Order","$defs":{"test_monostate__Order":{"type":"object","properties":{"price":{"anyOf":[{"type":"null"},{"type":"string"},{"type":"integer"}]}},"required":[]}}})");
+}
+
+}  // namespace test_monostate