What next?
Valid, readable JSON, then the transforms around it.
How to use this tool
- Paste your JSON into the input.
- It is validated and formatted automatically.
- Copy the tidy output, or read the error if it is invalid.
What your result means
A green status means valid JSON, neatly indented; an error points to what is malformed and roughly where. Formatting only changes whitespace and layout — never your data’s values.
Why this one is different
A failed parse is pinned to a place in your own text, with a caret under the character that stopped the reader rather than the browser's own wording. When the document does parse, two quiet problems get named: a key repeated inside one object, where parsers keep the last and drop the rest, and an integer too large for a double, which returns rounded. Formatted size is reported apart from minified size.
The data format that quietly runs the internet
Almost every app you use talks to its servers in JSON — a simple, human-readable way to structure data that beat heavier rivals through sheer simplicity. When an app breaks, malformed JSON is often the culprit.
A single missing comma or stray quote can crash an entire request. Formatting and validating here shows you exactly where it went wrong — all in your browser, so sensitive data stays private.
How it works
Paste JSON into the input and click Beautify to indent it neatly, or Minify to strip whitespace for compact transfer. The tool parses your JSON in the browser and reports the exact position of any syntax error, so nothing is ever uploaded.
What the formatter checks
JSON is a strict format, and most "broken JSON" comes down to a handful of rules: keys must be double-quoted strings, trailing commas are not allowed, comments are not part of the format, and only double quotes count. This tool parses your input with the browser's own JSON parser, so if it accepts the text then every conforming parser will — and if it does not, you get the position of the first syntax error rather than a vague failure.
Worked example
One line of minified JSON, formatted:
{"name":"Ada","tags":["dev","maths"],"active":true}
Output
{
"name": "Ada",
"tags": [
"dev",
"maths"
],
"active": true
}
The data is identical — only whitespace changed, so the formatted version parses to exactly the same object. If the input had a trailing comma after true, or single quotes instead of double, the formatter would refuse it and point at the character: both are valid JavaScript but invalid JSON.
What valid JSON allows, and the four things people assume it does
JSON is deliberately smaller than JavaScript object syntax, and every difference is a common error. Trailing commas after the last item are illegal. Keys must be double-quoted strings — single quotes and bare identifiers both fail. Comments do not exist in any form. And NaN, Infinity and undefined are not values; a serialiser that produces them has produced something that is not JSON.
Two more limits are worth knowing before they surprise you in production. Numbers are IEEE 754 doubles, so integers above about 9 quadrillion lose precision — which is why large IDs, and anything derived from a 64-bit integer, should be transmitted as strings. And there is no date type at all: the near-universal convention is an ISO 8601 string such as 2026-08-02T09:00:00Z, which sorts correctly as plain text and carries its offset explicitly.
Formatting itself changes nothing about the data. Indentation and line breaks make the structure readable for a human; minifying strips them to shrink the payload. Both parse to exactly the same object, so it is always safe to format a file you are debugging and minify it again before sending.
Frequently asked questions
Why is my JSON invalid?＋
Common causes are trailing commas, single quotes instead of double quotes, or unquoted keys. The status message shows where parsing failed.
Is my data private?＋
Completely. All parsing and formatting happens locally in your browser — your JSON is never sent to a server.
What are the most common JSON syntax errors?＋
Trailing commas after the last item, single quotes instead of double, unquoted keys, and comments. All four are legal in JavaScript objects and illegal in JSON, which is why they slip through.
What is the difference between formatting and minifying?＋
Formatting adds indentation and line breaks so a human can read the structure. Minifying strips all optional whitespace to make the payload smaller for transmission. The data is identical either way.
Can JSON hold dates or comments?＋
Neither, officially. Dates are conventionally written as ISO 8601 strings such as 2026-08-02T09:00:00Z, and comments have to live in a dedicated field or outside the file.
Does reformatting change the key order?＋
No. Keys are kept in the order they appear, because although JSON objects are formally unordered, plenty of tools and diffs depend on the order being stable.
Related tools
Assumptions & limitations
Formatting never changes your data, but a few things about the process are worth knowing:
- Everything runs in your browser. Nothing is uploaded, which is why very large files are limited by your device's memory rather than by a server.
- JSON has no date, comment or trailing-comma syntax. Input using any of them is invalid and will be reported as an error.
- Numbers are parsed as IEEE 754 doubles, so integers beyond about 9 quadrillion lose precision. Very large IDs should be strings.
- Key order is preserved for readability even though the JSON specification treats objects as unordered.