How JSON validation works
The validator checks your input against RFC 8259 (the current JSON standard, equivalent to ECMA-404) using the browser's native JSON.parse — the same strict parser every JSON consumer relies on. If parsing succeeds you get a structural summary: the top-level type, how many keys and array items the document contains, and its maximum nesting depth. If parsing fails, the invalid line is highlighted in the editor and the error message reports the exact line and column.
Beyond syntax, the validator also runs an RFC 7493 (I-JSON) interoperability check for duplicate object keys. Duplicate keys are technically parseable — JSON.parse silently keeps the last value — but they are a common source of subtle bugs because different parsers disagree on which value wins, so the validator surfaces them as a warning.
Common JSON syntax errors
The most frequent mistake is a trailing comma after the last element in an array or object. JavaScript allows this, but the JSON specification does not, so copying object literals from source code often introduces this error. The validator will point directly to the unexpected comma.
Other common issues include single-quoted strings (JSON requires double quotes), unquoted property keys, comments (// or /* */), and hexadecimal number literals (0xFF). All of these are valid in JavaScript but rejected by JSON.parse. If you are working with a format that allows these extensions (like JSONC or JSON5), this validator will flag them because it checks strict JSON compliance.
Privacy and local processing
Validation runs entirely in your browser tab. The input text is passed to JSON.parse in local memory and never transmitted to any server. This makes the tool safe for validating configuration files with credentials, API responses with user data, or any payload you would not want to share with a third party.
No data is persisted between sessions. Closing or refreshing the page discards everything.
When to validate JSON
Validate before deploying configuration files, before importing data into a database, or when debugging a 400 error from an API that expects JSON input. A quick validation pass catches syntax issues before they turn into runtime errors in production.
The validator is also useful for checking output from code generators, template engines, or manual edits to package.json, tsconfig.json, or similar project files where a single misplaced comma can break your entire build toolchain.
Frequently asked questions
Which JSON specification does the validator check against?
RFC 8259 (equivalent to ECMA-404), via the browser's strict native parser — trailing commas, single quotes, comments, and unquoted keys are all rejected. It additionally warns about duplicate object keys per the RFC 7493 (I-JSON) interoperability profile, since different parsers disagree on which duplicate wins.
Can I validate JSON that has comments?
No. Comments are not part of the JSON specification. The validator checks strict JSON compliance, so // and /* */ comments will be reported as syntax errors. If you need comments, consider JSONC or JSON5 formats.
Is my JSON uploaded anywhere during validation?
No. The validator uses your browser's native JSON.parse function. Your input stays in local memory and is never sent over the network.
Why does my JavaScript object fail validation?
JavaScript object literals allow features that JSON does not: unquoted keys, single quotes, trailing commas, comments, and undefined values. Wrap all keys in double quotes, use double-quoted strings, and remove trailing commas and comments.
Does valid JSON guarantee my API will accept it?
Valid JSON means the syntax is correct. Your API may still reject it if the data does not match the expected schema, such as missing required fields or wrong value types. Syntax validation and schema validation are separate concerns.
What is the maximum size I can validate?
There is no imposed limit. The practical ceiling depends on your browser's memory. Most browsers handle inputs up to 50 MB without trouble, though very large files may cause a brief pause during parsing.