diff --git a/docs/mkdocs/docs/api/basic_json/get.md b/docs/mkdocs/docs/api/basic_json/get.md
index 016595d5f..06e34218a 100644
--- a/docs/mkdocs/docs/api/basic_json/get.md
+++ b/docs/mkdocs/docs/api/basic_json/get.md
@@ -120,6 +120,16 @@ overload (3).
     See [Number conversion](../../features/types/number_handling.md#number-conversion)
     for more information.
 
+!!! note "Booleans as numbers"
+
+    A JSON boolean converts to `#!cpp 0` or `#!cpp 1` for every arithmetic type **except** [`number_integer_t`](number_integer_t.md),
+    [`number_unsigned_t`](number_unsigned_t.md) and [`number_float_t`](number_float_t.md) (by default `#!cpp std::int64_t`,
+    `#!cpp std::uint64_t`, and `#!cpp double`), for which `#!cpp get<T>()` throws
+    [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) ("type must be number, but is boolean"). So
+    `#!cpp json(true).get<int>()` is `#!cpp 1`, while `#!cpp json(true).get<std::int64_t>()` and
+    `#!cpp json(true).get<double>()` throw. This is the behavior of all 3.x versions;
+    [`basic_json_view::get<T>()`](../basic_json_view/get.md) behaves the same.
+
 !!! note "`std::optional` conversions"
 
     Prior to version 3.13.0, `#!cpp get<std::optional<T>>()` (and other conversions to `std::optional<T>`) failed to
diff --git a/docs/mkdocs/docs/api/basic_json_view/get.md b/docs/mkdocs/docs/api/basic_json_view/get.md
index 7ee7952bf..1739d372b 100644
--- a/docs/mkdocs/docs/api/basic_json_view/get.md
+++ b/docs/mkdocs/docs/api/basic_json_view/get.md
@@ -11,7 +11,8 @@ For the types below, the conversion works directly on the flat index — no `Bas
 
 - `#!cpp bool`
 - arithmetic types other than `#!cpp bool` (for a boolean, `#!cpp 0`/`#!cpp 1`, exactly as for
-  [`BasicJsonType::get<T>()`](../basic_json/get.md))
+  [`BasicJsonType::get<T>()`](../basic_json/get.md#notes), except for `number_integer_t`, `number_unsigned_t` and
+  `number_float_t`, which throw `type_error.302` for a boolean, as `BasicJsonType::get<T>()` does)
 - `#!cpp std::nullptr_t`
 - `#!cpp std::basic_string<char, Traits, Alloc>` (including `string_t`) — a copy of the string
 - [`string_view_t`](index.md#member-types) — **no copy**: the returned view points into the document's
diff --git a/include/nlohmann/detail/view/value.hpp b/include/nlohmann/detail/view/value.hpp
index ffdcc3605..81b175e2b 100644
--- a/include/nlohmann/detail/view/value.hpp
+++ b/include/nlohmann/detail/view/value.hpp
@@ -33,12 +33,37 @@ namespace view
 template<typename T>
 struct value_tag {};
 
+/// whether basic_json reads T with a dedicated from_json() overload that does
+/// not accept a boolean: exactly number_integer_t, number_unsigned_t and
+/// number_float_t (the other arithmetic types convert a boolean to 0 or 1)
+template<typename T, typename BasicJsonType>
+struct rejects_boolean : std::integral_constant < bool,
+    std::is_same<T, typename BasicJsonType::number_integer_t>::value
+    || std::is_same<T, typename BasicJsonType::number_unsigned_t>::value
+    || std::is_same<T, typename BasicJsonType::number_float_t>::value >
+{};
+
+/// a boolean as T: 0 or 1
+template<typename T>
+NLOHMANN_VIEW_ALWAYS_INLINE T boolean_as(const document_data& /*d*/, const node& n, std::false_type /*rejects*/)
+{
+    return static_cast<T>((n.flags & node_flags::is_true) != 0);
+}
+
+/// a boolean as number_integer_t, number_unsigned_t or number_float_t: type_error.302, as in basic_json
+template<typename T>
+[[noreturn]] NLOHMANN_VIEW_ALWAYS_INLINE T boolean_as(const document_data& d, const node& n, std::true_type /*rejects*/)
+{
+    throw_type_error(error_site(&d, &n), exception_id::type_mismatch, "type must be number, but is ", value_type_name(static_cast<value_t>(n.kind)));
+}
+
 /*!
 @brief the number or boolean of a node converted to an arithmetic type
 
 As basic_json's get<T>() for arithmetic types: integers and floats are
-converted with static_cast, booleans give 0 or 1, and other types throw
-type_error.302.
+converted with static_cast, booleans give 0 or 1 (but throw type_error.302 for
+number_integer_t, number_unsigned_t and number_float_t, as basic_json does),
+and other types throw type_error.302.
 */
 template<typename T, typename BasicJsonType>
 NLOHMANN_VIEW_ALWAYS_INLINE T arithmetic_value(const document_data& d, const node& n)
@@ -52,7 +77,7 @@ NLOHMANN_VIEW_ALWAYS_INLINE T arithmetic_value(const document_data& d, const nod
         case value_t::number_float:
             return static_cast<T>(float_value<typename BasicJsonType::number_float_t>(d, n));
         case value_t::boolean:
-            return static_cast<T>((n.flags & node_flags::is_true) != 0);
+            return boolean_as<T>(d, n, rejects_boolean<T, BasicJsonType> {});
         case value_t::null:
         case value_t::object:
         case value_t::array:
diff --git a/single_include/nlohmann/json_view.hpp b/single_include/nlohmann/json_view.hpp
index 6bb6ec771..4a7b949a8 100644
--- a/single_include/nlohmann/json_view.hpp
+++ b/single_include/nlohmann/json_view.hpp
@@ -10072,12 +10072,37 @@ namespace view
 template<typename T>
 struct value_tag {};
 
+/// whether basic_json reads T with a dedicated from_json() overload that does
+/// not accept a boolean: exactly number_integer_t, number_unsigned_t and
+/// number_float_t (the other arithmetic types convert a boolean to 0 or 1)
+template<typename T, typename BasicJsonType>
+struct rejects_boolean : std::integral_constant < bool,
+    std::is_same<T, typename BasicJsonType::number_integer_t>::value
+    || std::is_same<T, typename BasicJsonType::number_unsigned_t>::value
+    || std::is_same<T, typename BasicJsonType::number_float_t>::value >
+{};
+
+/// a boolean as T: 0 or 1
+template<typename T>
+NLOHMANN_VIEW_ALWAYS_INLINE T boolean_as(const document_data& /*d*/, const node& n, std::false_type /*rejects*/)
+{
+    return static_cast<T>((n.flags & node_flags::is_true) != 0);
+}
+
+/// a boolean as number_integer_t, number_unsigned_t or number_float_t: type_error.302, as in basic_json
+template<typename T>
+[[noreturn]] NLOHMANN_VIEW_ALWAYS_INLINE T boolean_as(const document_data& d, const node& n, std::true_type /*rejects*/)
+{
+    throw_type_error(error_site(&d, &n), exception_id::type_mismatch, "type must be number, but is ", value_type_name(static_cast<value_t>(n.kind)));
+}
+
 /*!
 @brief the number or boolean of a node converted to an arithmetic type
 
 As basic_json's get<T>() for arithmetic types: integers and floats are
-converted with static_cast, booleans give 0 or 1, and other types throw
-type_error.302.
+converted with static_cast, booleans give 0 or 1 (but throw type_error.302 for
+number_integer_t, number_unsigned_t and number_float_t, as basic_json does),
+and other types throw type_error.302.
 */
 template<typename T, typename BasicJsonType>
 NLOHMANN_VIEW_ALWAYS_INLINE T arithmetic_value(const document_data& d, const node& n)
@@ -10091,7 +10116,7 @@ NLOHMANN_VIEW_ALWAYS_INLINE T arithmetic_value(const document_data& d, const nod
         case value_t::number_float:
             return static_cast<T>(float_value<typename BasicJsonType::number_float_t>(d, n));
         case value_t::boolean:
-            return static_cast<T>((n.flags & node_flags::is_true) != 0);
+            return boolean_as<T>(d, n, rejects_boolean<T, BasicJsonType> {});
         case value_t::null:
         case value_t::object:
         case value_t::array:
diff --git a/tests/src/unit-conversions1.cpp b/tests/src/unit-conversions1.cpp
index 3d39e10c9..888979440 100644
--- a/tests/src/unit-conversions1.cpp
+++ b/tests/src/unit-conversions1.cpp
@@ -1260,6 +1260,44 @@ TEST_CASE("value conversion")
     #undef JSON_HAS_CPP_17
 #endif
 
+TEST_CASE("get<T>() of a boolean (#5988)")
+{
+    // a boolean converts to 0/1 for every arithmetic type except number_integer_t, number_unsigned_t and
+    // number_float_t, whose dedicated from_json() overloads throw
+    const json t = true;
+    const json f = false;
+
+    SECTION("0 and 1")
+    {
+        // long and unsigned long are left out: they are std::int64_t and std::uint64_t on some platforms
+        CHECK(t.get<bool>() == true);
+        CHECK(f.get<bool>() == false);
+        CHECK(t.get<char>() == 1);
+        CHECK(t.get<signed char>() == 1);
+        CHECK(t.get<unsigned char>() == 1);
+        CHECK(t.get<short>() == 1); // NOLINT(google-runtime-int)
+        CHECK(t.get<unsigned short>() == 1); // NOLINT(google-runtime-int)
+        CHECK(t.get<int>() == 1);
+        CHECK(t.get<unsigned>() == 1);
+        CHECK(t.get<float>() == 1.0F);
+        CHECK(t.get<long double>() == 1.0L);
+        CHECK(f.get<int>() == 0);
+        CHECK(f.get<float>() == 0.0F);
+    }
+
+#if !defined(JSON_NOEXCEPTION)
+    SECTION("number_integer_t, number_unsigned_t and number_float_t throw")
+    {
+        CHECK_THROWS_WITH_AS(t.get<json::number_integer_t>(), "[json.exception.type_error.302] type must be number, but is boolean", json::type_error&);
+        CHECK_THROWS_WITH_AS(t.get<json::number_unsigned_t>(), "[json.exception.type_error.302] type must be number, but is boolean", json::type_error&);
+        CHECK_THROWS_WITH_AS(t.get<json::number_float_t>(), "[json.exception.type_error.302] type must be number, but is boolean", json::type_error&);
+        CHECK_THROWS_WITH_AS(f.get<json::number_integer_t>(), "[json.exception.type_error.302] type must be number, but is boolean", json::type_error&);
+        CHECK_THROWS_WITH_AS(f.get<json::number_unsigned_t>(), "[json.exception.type_error.302] type must be number, but is boolean", json::type_error&);
+        CHECK_THROWS_WITH_AS(f.get<json::number_float_t>(), "[json.exception.type_error.302] type must be number, but is boolean", json::type_error&);
+    }
+#endif
+}
+
 #ifdef JSON_HAS_CPP_14
     #undef JSON_HAS_CPP_14
 #endif
diff --git a/tests/src/unit-json_view.cpp b/tests/src/unit-json_view.cpp
index c823ef9e2..8dc60e912 100644
--- a/tests/src/unit-json_view.cpp
+++ b/tests/src/unit-json_view.cpp
@@ -1551,6 +1551,85 @@ TEST_CASE("json_view values")
     }
 }
 
+namespace
+{
+// get<T>() of a boolean: the same value or the same exception in basic_json and in the view (#5988)
+template<typename T>
+void check_boolean_get_parity()
+{
+    for (const bool b :
+            {
+                true, false
+            })
+    {
+        const std::string text = b ? "true" : "false";
+        const json j = json::parse(text);
+        const json_document d = json_document::parse(text);
+        CAPTURE(text)
+#if !defined(JSON_NOEXCEPTION)
+        T dom_value {};
+        T view_value{};
+        const std::string dom_error = json_view_test::exception_of_call([&] { dom_value = j.get<T>(); });
+        const std::string view_error = json_view_test::exception_of_call([&] { view_value = d.root().template get<T>(); });
+        CHECK(dom_error == view_error);
+        if (dom_error.empty())
+        {
+            CHECK(dom_value == view_value);
+            CHECK(view_value == static_cast<T>(b));
+        }
+#else
+        // without exceptions, the combinations that throw (number_integer_t, number_unsigned_t, number_float_t)
+        // cannot be run: JSON_THROW aborts
+        const bool throws = std::is_same<T, json::number_integer_t>::value
+                            || std::is_same<T, json::number_unsigned_t>::value
+                            || std::is_same<T, json::number_float_t>::value;
+        if (!throws)
+        {
+            CHECK(j.get<T>() == d.root().template get<T>());
+        }
+#endif
+    }
+}
+} // namespace
+
+TEST_CASE("json_view get<T>() of a boolean (#5988)")
+{
+    check_boolean_get_parity<bool>();
+    check_boolean_get_parity<char>();
+    check_boolean_get_parity<signed char>();
+    check_boolean_get_parity<unsigned char>();
+    check_boolean_get_parity<short>(); // NOLINT(google-runtime-int)
+    check_boolean_get_parity<unsigned short>(); // NOLINT(google-runtime-int)
+    check_boolean_get_parity<int>();
+    check_boolean_get_parity<unsigned>();
+    check_boolean_get_parity<long>(); // NOLINT(google-runtime-int)
+    check_boolean_get_parity<unsigned long>(); // NOLINT(google-runtime-int)
+    check_boolean_get_parity<long long>(); // NOLINT(google-runtime-int)
+    check_boolean_get_parity<unsigned long long>(); // NOLINT(google-runtime-int)
+    check_boolean_get_parity<std::int64_t>();
+    check_boolean_get_parity<std::uint64_t>();
+    check_boolean_get_parity<float>();
+    check_boolean_get_parity<double>();
+    check_boolean_get_parity<long double>();
+
+#if !defined(JSON_NOEXCEPTION)
+    SECTION("the exceptions of the exact number types")
+    {
+        const json_document d = json_document::parse("true");
+        CHECK_THROWS_WITH_AS(d.root().get<json::number_integer_t>(), json_view_test::message("type_error.302", "", 0, 4, "type must be number, but is boolean").c_str(), json::type_error&);
+        CHECK_THROWS_WITH_AS(d.root().get<json::number_unsigned_t>(), json_view_test::message("type_error.302", "", 0, 4, "type must be number, but is boolean").c_str(), json::type_error&);
+        CHECK_THROWS_WITH_AS(d.root().get<json::number_float_t>(), json_view_test::message("type_error.302", "", 0, 4, "type must be number, but is boolean").c_str(), json::type_error&);
+        CHECK(d.root().get<int>() == 1);
+        // get_to() and value() go through get<T>()
+        json::number_float_t x = 0;
+        CHECK_THROWS_AS(d.root().get_to(x), json::type_error&);
+        const json_document o = json_document::parse("{\"b\":true}");
+        CHECK_THROWS_AS(static_cast<void>(o.root().value("b", 0.0)), json::type_error&);
+        CHECK(o.root().value("b", 0) == 1);
+    }
+#endif
+}
+
 TEST_CASE("json_view JSON pointers")
 {
     SECTION("every value of generated documents")