JSON validator

Last updated June 2026 · Maintained by the JSONNeat author

What this validator actually checks

The verdict you see here is whatever your browser's built-in JSON.parse returns. That's the same engine your Node backend or your front-end fetch().then(r => r.json()) calls, so if JSONNeat accepts your document, every other JavaScript runtime will too. The standard the parser implements is RFC 8259 — six rules cover everything: strings and keys must be in double quotes, braces and brackets must match, commas separate values but never trail the last one, comments are not allowed, numbers must be finite decimals without leading zeros, and the only value types are string, number, boolean, null, object and array.

The eight errors that account for most invalid JSON

After running thousands of validations, the same small set of mistakes shows up over and over. Recognising them on sight is faster than reading the error message:

1. Trailing commas. {"a": 1, "b": 2,} looks fine because most programming languages allow it, but JSON does not. Remove the comma before the closing brace or bracket.
2. Single quotes. {'a': 1} is invalid because JSON only allows double quotes for both keys and string values. This is the most common error when pasting JavaScript object literals.
3. Unquoted keys. {a: 1} is a JavaScript object literal, not JSON. Every key must be a double-quoted string.
4. Comments. JSON does not support // or /* */ comments. If you need comments in configuration files, consider JSON5, JSONC, or YAML instead.
5. Unescaped control characters. Raw tabs, newlines and carriage returns inside string values must be written as \t, \n and \r. Pasting multi-line text directly into a JSON string almost always produces this error.
6. Curly "smart" quotes. “like this” or ‘like this’ from a word processor will silently break JSON. The validator sees them as foreign characters, not delimiters.
7. Unescaped backslashes in Windows paths. {"path": "C:\Users\me"} needs double backslashes: C:\\Users\\me. A single backslash starts an escape sequence.
8. Missing or mismatched brackets. Easy to introduce when editing a deeply nested document. The line and column reporter in JSONNeat points to the location where parsing failed, which is usually a few characters after the actual problem.

Worked example

Here is a real-world snippet that fails validation:

{
  name: 'Ada Lovelace',
  born: 1815,
  skills: ['math', 'computing',],
  // first computer programmer
  bio: "Wrote the first
  algorithm intended for a machine.",
}

This document contains six separate errors: unquoted keys, single-quoted strings, a trailing comma after'computing', a JavaScript comment, an unescaped newline inside the bio string, and a trailing comma after the final value. The fixed version:

{
  "name": "Ada Lovelace",
  "born": 1815,
  "skills": ["math", "computing"],
  "bio": "Wrote the first\nalgorithm intended for a machine."
}

Both the \n escape inside the string and the removed trailing commas are what move the document from invalid to valid. Drop either fix and the validator rejects it.

Beyond syntax: structural validation

JSONNeat's validator answers a single question: is this parseable? That is necessary but rarely sufficient. A document can be syntactically perfect and still wrong for your API — missing a required field, using the wrong type, exceeding a value range, or violating a uniqueness constraint.

For those checks you need JSON Schema, a separate standard that describes the structure and constraints of valid JSON documents. A schema lets you declare that email must be a string matching an email pattern, that age must be an integer between 0 and 150, or that anitems array must contain at least one element. Tools like Ajv (JavaScript), jsonschema (Python) and JSON.NET (C#) consume the same schemas across languages.

See our JSON Schema tutorial for a hands-on introduction.

When validation alone is not the right tool

• Untrusted input from the web. Valid JSON can still be dangerous if it contains unexpectedly large nested structures (an "exponential JSON" denial-of-service) or extremely long strings. Cap input size and parse depth at your application boundary.
• JSON Lines / NDJSON streams. Each line is its own JSON document, but the file as a whole is not valid JSON. Validate one line at a time or convert to an array first.
• Tagged or self-referential JSON. Some systems extend JSON with $refpointers, type tags, or BSON-style typed values. Those documents are valid plain JSON but require application-level interpretation to be useful.
• Very large files. Browser-based parsers load the entire document into memory. For files over a few hundred megabytes use a streaming parser like jq, stream-json or oboe.js, which process JSON as a token stream.

How JSONNeat reports errors

When validation fails, JSONNeat shows the parser's message along with a line and column number computed from the position offset returned by V8 or SpiderMonkey. The reported location is the first character the parser could not consume — which is often a character or two after the actual mistake. For example, a missing comma between two object properties is detected when the parser reaches the next key, not at the comma's intended position. Look slightly to the left of the reported column to find the cause.

Privacy and what happens to your data

JSON content you paste here is processed entirely by JavaScript running in your browser tab. Nothing is uploaded, logged, cached or transmitted to JSONNeat or any third party. That makes the validator safe for checking responses from internal APIs, production payloads, or documents containing secrets — the same guarantee you would get from running jq on your own machine, with no install required.