diff --git a/v8pp/call_from_v8.hpp b/v8pp/call_from_v8.hpp
index 013cc6a3..065dedcb 100644
--- a/v8pp/call_from_v8.hpp
+++ b/v8pp/call_from_v8.hpp
@@ -11,12 +11,29 @@
 
 namespace v8pp { namespace detail {
 
+template<typename>
+struct optional_count_impl;
+
+template<typename... Ts>
+struct optional_count_impl<std::tuple<Ts...>>
+{
+	constexpr static std::size_t count =
+		(0 + ... + (is_optional<Ts>::value ? 1 : 0));
+};
+
+template<typename Tuple>
+constexpr auto optional_count() -> std::size_t
+{
+	return optional_count_impl<Tuple>::count;
+}
+
 template<typename F, size_t Offset = 0>
 struct call_from_v8_traits
 {
 	static constexpr size_t offset = Offset;
 	static constexpr bool is_mem_fun = std::is_member_function_pointer<F>::value;
 	using arguments = typename function_traits<F>::arguments;
+	static constexpr size_t optional_arg_count = optional_count<arguments>();
 
 	static constexpr size_t arg_count =
 		std::tuple_size<arguments>::value - is_mem_fun - offset;
@@ -91,7 +108,7 @@ decltype(auto) call_from_v8(F&& func, v8::FunctionCallbackInfo<v8::Value> const&
 		using call_traits = call_from_v8_traits<F, with_isolate>;
 		using indices = std::make_index_sequence<call_traits::arg_count>;
 
-		if (args.Length() != call_traits::arg_count)
+		if (args.Length() > call_traits::arg_count || args.Length() < call_traits::arg_count - call_traits::optional_arg_count)
 		{
 			throw std::runtime_error(
 				"Argument count does not match function definition. Expected " +
diff --git a/v8pp/convert.hpp b/v8pp/convert.hpp
index 06970dfa..fa2c288d 100644
--- a/v8pp/convert.hpp
+++ b/v8pp/convert.hpp
@@ -125,6 +125,33 @@ struct convert<wchar_t const*> : convert<std::basic_string_view<wchar_t>>
 #endif
 
 // converter specializations for primitive types
+template<>
+struct convert<std::monostate>
+{
+	using from_type = std::monostate;
+	using to_type = v8::Local<v8::Primitive>;
+
+	static bool is_valid(v8::Isolate*, v8::Local<v8::Value> value)
+	{
+		return value.IsEmpty() || value->IsNullOrUndefined();
+	}
+
+	static from_type from_v8(v8::Isolate* isolate, v8::Local<v8::Value> value)
+	{
+		if (!is_valid(isolate, value))
+		{
+			throw invalid_argument(isolate, value, "Undefined");
+		}
+
+		return from_type{};
+	}
+
+	static to_type to_v8(v8::Isolate* isolate, from_type value)
+	{
+		return v8::Undefined(isolate);
+	}
+};
+
 template<>
 struct convert<bool>
 {
@@ -265,6 +292,41 @@ struct convert<T, typename std::enable_if<std::is_floating_point<T>::value>::typ
 	}
 };
 
+// convert std::optional <-> value or undefined
+template<typename T>
+struct convert<std::optional<T>>
+{
+	using from_type = std::optional<T>;
+	using to_type = typename convert<T>::to_type;
+
+	static bool is_valid(v8::Isolate* isolate, v8::Local<v8::Value> value)
+	{
+		return convert<T>::is_valid(isolate, value);
+	}
+
+	static from_type from_v8(v8::Isolate* isolate, v8::Local<v8::Value> value)
+	{
+		if (!is_valid(isolate, value))
+		{
+			return from_type{};
+		}
+
+		return convert<T>::from_v8(isolate, value);
+	}
+
+	static to_type to_v8(v8::Isolate* isolate, from_type const& value)
+	{
+		if (value.has_value())
+		{
+			return convert<T>::to_v8(isolate, value.value());
+		}
+		else
+		{
+			return to_type::Cast(v8::Undefined(isolate));
+		}
+	}
+};
+
 // convert std::tuple <-> Array
 template<typename... Ts>
 struct convert<std::tuple<Ts...>>
@@ -373,6 +435,10 @@ struct convert<std::variant<Ts...>>
 				return alternate<is_wrapped_class, detail::is_shared_ptr>(isolate, value);
 			}
 		}
+		else if (value->IsNullOrUndefined())
+		{
+			return alternate<is_monostate>(isolate, value);
+		}
 		else
 		{
 			return alternate<is_any>(isolate, value);
@@ -392,6 +458,9 @@ struct convert<std::variant<Ts...>>
 	template<typename T>
 	using is_bool = std::is_same<T, bool>;
 
+	template<typename T>
+	using is_monostate = std::is_same<T, std::monostate>;
+
 	template<typename T>
 	using is_integral_not_bool = std::bool_constant<std::is_integral<T>::value && !is_bool<T>::value>;
 
@@ -427,7 +496,14 @@ struct convert<std::variant<Ts...>>
 	template<typename T>
 	static bool try_as(v8::Isolate* isolate, v8::Local<v8::Value> value, std::optional<from_type>& result)
 	{
-		if constexpr (detail::is_shared_ptr<T>::value)
+		if constexpr (std::is_same<T, std::monostate>::value)
+		{
+			if(v8pp::convert<std::monostate>::is_valid(isolate, value))
+			{
+				result = std::monostate{};
+			}
+		}
+		else if constexpr (detail::is_shared_ptr<T>::value)
 		{
 			using U = typename T::element_type;
 			if (auto obj = v8pp::class_<U, v8pp::shared_ptr_traits>::unwrap_object(isolate, value))
@@ -635,7 +711,8 @@ struct is_wrapped_class : std::conjunction<
 	std::negation<detail::is_sequence<T>>,
 	std::negation<detail::is_array<T>>,
 	std::negation<detail::is_tuple<T>>,
-	std::negation<detail::is_shared_ptr<T>>>
+	std::negation<detail::is_shared_ptr<T>>,
+	std::negation<detail::is_optional<T>>>
 {
 };
 
@@ -857,6 +934,15 @@ v8::Local<v8::String> to_v8(v8::Isolate* isolate,
 }
 #endif
 
+template<typename T>
+auto to_v8(v8::Isolate* isolate, std::optional<T> const& value) -> v8::Local<v8::Value>
+{
+	if (value.has_value())
+		return convert<T>::to_v8(isolate, value.value());
+	else
+		return v8::Undefined(isolate);
+}
+
 template<typename T>
 auto to_v8(v8::Isolate* isolate, T const& value)
 {
diff --git a/v8pp/utility.hpp b/v8pp/utility.hpp
index c1d2f4a8..195c65cc 100644
--- a/v8pp/utility.hpp
+++ b/v8pp/utility.hpp
@@ -5,6 +5,7 @@
 #include <memory>
 #include <string_view>
 #include <tuple>
+#include <optional>
 #include <type_traits>
 
 namespace v8pp { namespace detail {
@@ -158,6 +159,20 @@ struct is_shared_ptr<std::shared_ptr<T>> : std::true_type
 {
 };
 
+/////////////////////////////////////////////////////////////////////////////
+//
+// is_optional<T>
+//
+template<typename T>
+struct is_optional : std::false_type
+{
+};
+
+template<typename T>
+struct is_optional<std::optional<T>> : std::true_type
+{
+};
+
 /////////////////////////////////////////////////////////////////////////////
 //
 // Function traits