Skip to content


// (1)
template<typename InputType>
static bool accept(InputType&& i,
                   const bool ignore_comments = false);

// (2)
template<typename IteratorType>
static bool accept(IteratorType first, IteratorType last,
                   const bool ignore_comments = false);

Checks whether the input is valid JSON.

  1. Reads from a compatible input.
  2. Reads from a pair of character iterators

    The value_type of the iterator must be an integral type with size of 1, 2 or 4 bytes, which will be interpreted respectively as UTF-8, UTF-16 and UTF-32.

Unlike the parse function, this function neither throws an exception in case of invalid JSON input (i.e., a parse error) nor creates diagnostic information.

Template parameters


A compatible input, for instance:

  • an std::istream object
  • a FILE pointer (must not be null)
  • a C-style array of characters
  • a pointer to a null-terminated string of single byte characters
  • a std::string
  • an object obj for which begin(obj) and end(obj) produces a valid pair of iterators.

a compatible iterator type, for instance.

  • a pair of std::string::iterator or std::vector<std::uint8_t>::iterator
  • a pair of pointers such as ptr and ptr + len


i (in)
Input to parse from.
ignore_comments (in)
whether comments should be ignored and treated like whitespace (true) or yield a parse error (false); (optional, false by default)
first (in)
iterator to start of character range
last (in)
iterator to end of character range

Return value

Whether the input is valid JSON.

Exception safety

Strong guarantee: if an exception is thrown, there are no changes in the JSON value.


Linear in the length of the input. The parser is a predictive LL(1) parser.


(1) A UTF-8 byte order mark is silently ignored.

Runtime assertion

The precondition that a passed FILE pointer must not be null is enforced with a runtime assertion.



The example below demonstrates the accept() function reading from a string.

#include <iostream>
#include <iomanip>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

int main()
    // a valid JSON text
    auto valid_text = R"(
        "numbers": [1, 2, 3]

    // an invalid JSON text
    auto invalid_text = R"(
        "strings": ["extra", "comma", ]

    std::cout << std::boolalpha
              << json::accept(valid_text) << ' '
              << json::accept(invalid_text) << '\n';


true false

See also

  • parse - deserialize from a compatible input
  • operator>> - deserialize from stream

Version history

  • Added in version 3.0.0.
  • Ignoring comments via ignore_comments added in version 3.9.0.


Overload (2) replaces calls to accept with a pair of iterators as their first parameter which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like accept({ptr, ptr+len}, ...); with accept(ptr, ptr+len, ...);.

You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.

Last update: July 28, 2022