Why does my JSON work in JavaScript but fail the validator?

JavaScript object literals are more forgiving than JSON. They allow trailing commas, comments, single-quoted strings, unquoted keys where variables exist, and functions. JSON accepts none of those, so data that runs fine inside a script can be rejected the moment it crosses an API boundary.

What is the difference between JSON and JSON5?

JSON5 is a superset designed for configuration files: it allows comments, trailing commas, single quotes and unquoted keys, all of which strict JSON forbids. If the file you are pasting is a config, try JSON5 rules; if it is an API payload, it must be strict JSON.

Does the validator check my data types or structure?

It checks syntax only — whether the brackets, quotes and commas are correct and the document parses. It will happily accept {"age": "thirty"} even if your application expects a number. For structure, validate against a JSON Schema after the syntax passes.

The error says unexpected token but I cannot find it — what now?

Look just before the reported column, and remember that the parser often trips after the real mistake: a missing comma a few characters earlier shows up as an unexpected brace later. Format the document first so line numbers are meaningful, then work backwards from the position the validator prints.

Is my JSON sent to a server when I validate it?

No. Parsing runs entirely in your browser tab. The payload never leaves the device, so you can safely check tokens, private records and internal API responses with it.

Validate JSON Online — Find Errors Instantly

Invalid JSON breaks APIs, crashes applications, and wastes hours of debugging. A JSON validator checks your data for syntax errors and tells you exactly where the problem is — line number, character position, and what went wrong.

Common JSON Errors

Missing commas between objects or array elements. Trailing commas after the last element (technically invalid in strict JSON). Single quotes instead of double quotes. Unquoted keys. Unclosed brackets or braces. Numbers with leading zeros (007 is invalid, 7 is valid). Comments (JSON does not support // or /* */ comments).

What I Tested

I used the JSON Validator with several inputs.

• Valid JSON: '{"name": "Alice", "age": 30}' → Result: 'Valid JSON'. No errors.

• Missing comma: '{"name": "Alice" "age": 30}' → Result: 'Error at line 1, column 20: Expected comma or closing brace'. Exact position identified.

• Trailing comma: '{"name": "Alice", "age": 30,}' → Result: 'Error at line 1, column 31: Unexpected token'. The trailing comma was caught.

• Single quotes: "{\"name\": \"Alice\"}" → Result: 'Error at line 1, column 2: Expected double quote'. Clear diagnosis.

• Empty input: '' → Result: 'Error: Empty input. Please enter JSON to validate'.

Step-by-Step

(1) Open the JSON Validator. (2) Paste your JSON data into the input field. (3) Click 'Validate'. (4) If valid, you see a green 'Valid JSON' message. If invalid, you see the exact error with line and column numbers.

How It Compares

JSONLint is the most well-known online validator but has a dated interface, no syntax highlighting, and shows ads. VS Code validates JSON built-in but requires installation. Our tool provides line-and-column error positions, syntax highlighting, and works in your browser with no upload.

Limitation

The validator checks syntax only — it cannot verify semantic correctness. For example, {"age": "thirty"} is valid JSON but may cause errors in your application if age should be a number. You need to add your own business logic validation.

Common Mistake

Pasting minified JSON and not understanding the error position. When JSON is on a single line, the column number in the error message becomes critical. Count characters from the beginning of the line to find the issue, or paste the JSON into the JSON Formatter first to make it readable.

Privacy: Your JSON data is processed entirely in your browser. It is never sent to any server.

Next Step: Once your JSON validates, use the JSON Formatter to pretty-print it for readability.

Reading the Error Position

Every message the validator prints has three parts: the line number, the character column, and what the parser expected instead. On pretty-printed JSON the line number alone is usually enough — the mistake is on that line. On minified JSON the whole document is one line, so the column is the only pointer you have, and it counts from the very first character including spaces.

Format before you read the error. Once the JSON is spread across lines, the reported line lands on the actual object or array where parsing stopped, and the fix is typically a missing comma between two properties, a quote left open, or a closing brace in the wrong place.

JSON Is Stricter Than You Think

Four rules account for most failures: strings and keys must use double quotes; there are no comments; the last element of an object or array takes no trailing comma; and numbers cannot have leading zeros, plus signs or hexadecimal form. Anything the validator accepts will parse in every language with a JSON reader, which is exactly the guarantee the strictness buys you.

If your data genuinely needs comments or trailing commas, keep the loose version for local configuration and produce a strict copy before sending it anywhere — the JSON Minifier strips comments and trailing commas on their way out.

Validating Before You Paste

Configuration files, API payloads and fixture data all travel through places that reject a syntax error with an unhelpful message — a generic 400, a stack trace, or a silent no-op. Running the JSON through a validator first turns those into a line number you can act on before the data ever leaves your machine.

Set the habit at the moment the JSON is produced rather than when it fails in transit: exported reports, generated test fixtures and copy-pasted API responses all get checked immediately, while the source of the problem is still open in another tab. The thirty seconds it takes to paste and read the result routinely saves the ten minutes spent later reconstructing what the file looked like before it was saved over.