How to use this JSON formatter
Paste JSON into the input box and choose an action. Format pretty-prints it with consistent indentation. Minify strips every unnecessary byte. Validate only checks the syntax without producing output, which is what you want when you just need to know whether a file is well-formed.
All three parse the input first, so all three tell you if the JSON is broken — and they tell you where.
Error messages that point at the problem
Browsers report JSON syntax errors as a character offset, which is close to useless when you are staring at a 4,000-line API response. This tool converts that offset into a line and column number, so "Invalid JSON at line 847, column 23" gets you straight to the fault.
The errors you will hit most often, in rough order of frequency:
- Trailing comma.
{"a":1,}is valid JavaScript and invalid JSON. This is the single most common cause, especially in hand-edited config files. - Single quotes. JSON requires double quotes for both keys and string values.
{'name':'test'}is a JavaScript object literal, not JSON. - Unquoted keys.
{name:"test"}is likewise valid JavaScript and invalid JSON. Keys must always be quoted strings. - Comments. JSON has no comment syntax.
//and/* */both fail. If you need comments in configuration, use JSON5, YAML or TOML. - NaN, Infinity or undefined. None of these exist in JSON. Numbers must be finite,
and absence is expressed with
null. - Unescaped characters inside strings. A literal newline, tab or unescaped double
quote inside a string value breaks the parse. They must be written as
\n,\tand\".
Sorting keys
Tick "Sort keys A→Z" and every object in the structure, at every depth, is reordered alphabetically. This is the trick that makes two JSON files diffable. API responses often serialise keys in non-deterministic order, so a naive diff between two captures shows dozens of false changes. Sort both files, format both with the same indentation, and the diff shows only what actually differs.
Escape and unescape
These two handle a specific and annoying situation: JSON embedded inside JSON. When one system
stores a JSON document as a string field inside another JSON document, you get output full of
\" sequences that no formatter will parse.
Unescape string takes that mess and gives you back the real JSON, which you can then paste in again and format normally. Escape as string does the reverse — it turns your JSON into a properly escaped string literal ready to be embedded in another document, a shell script, or a test fixture.
The structure statistics
After a successful parse you get four numbers: total keys across all objects, maximum nesting depth, total value count, and the minified byte size. Depth is the one worth watching. Anything past five or six levels is usually a sign that a data model has grown organically rather than by design, and it makes both the code that consumes it and the humans who read it work harder than they should.
The minified size tells you what the payload actually costs on the wire, before HTTP compression. Formatting exists for humans; every byte of indentation in a production API response is pure waste, which is why every serious API minifies.
Why doing this locally matters
The JSON people need to format is very often exactly the JSON they should not paste into a random website: an API response containing customer records, a config file with database credentials, a decoded JWT with session claims, a webhook payload with personal data.
This page has no server component. The parsing is done by JSON.parse(), which is built
into your browser. Load the page once and you can work with the network disconnected — and if your
organisation's policy forbids pasting internal data into external services, a tool that provably makes
no network request is the one that keeps you compliant.