JSON Beautifier & Validator Pro

What "beautifying" JSON really does

JSON (JavaScript Object Notation) is whitespace-insensitive: {"a":1,"b":2} and a neatly indented multi-line version mean the identical thing to a parser. Minified JSON saves bytes for transmission but is painful to read; beautifying re-inserts consistent indentation and line breaks so a human can follow the structure. This tool parses your input with the browser's native JSON.parse — the same engine your code uses — which means the moment it formats successfully, you also know the JSON is valid. If parsing fails, it shows the exact error message (for example, an unexpected token at a position), turning the formatter into a quick validator.

The transform options, and what each one changes

• Indent — 2 spaces, 4 spaces, or a tab. Two spaces is the most common web convention; tabs let each developer's editor render their preferred width.
• Sort keys — alphabetizes object keys at every level. This is invaluable when diffing two JSON files: with keys in a stable order, a version-control diff shows only genuine value changes instead of noise from reordering.
• Remove nulls — recursively drops any key whose value is null and strips null entries from arrays, producing a leaner document when nulls carry no meaning for you.
• Compact arrays — keeps short arrays of simple values on one line. An array of up to six primitives (no nested objects) renders as [95, 87, 102] instead of one number per line, which keeps the output readable without wasting vertical space.

A subtle but important detail: Minify serializes the raw parsed value with JSON.stringify and does not apply the sort/remove-nulls options — it is a pure size-stripping operation. The Format button is the one that applies your chosen transforms.

A worked example

Suppose you paste this minified object:

{"name":"Alice","scores":[95,87,null,102],"address":{"city":"Seoul","zip":null}}

With 2-space indent, remove nulls on, and compact arrays on, the output becomes a tidy block where "scores" reads [95, 87, 102] on a single line (the null dropped), and the "address" object loses its "zip": null entry entirely, leaving just the city. Turn sort keys on and address would appear before name before scores, alphabetically.

Three views: editor, tree, and schema

Beyond formatting, the tool offers two analytical views. The Tree view renders the document as collapsible nodes so you can expand only the branch you care about in a large file, and clicking a key copies its path (like $.address.city) — exactly what you need to reference that field in code or a JSONPath query. The Schema view infers a lightweight type map: each value is reported as string, number, boolean, null, or array<type>, and arrays show the union of element types they contain, e.g. array<number|null>. This gives you a fast structural summary of an unfamiliar API response without reading every value.

Common mistakes that JSON.parse rejects

• Trailing commas. [1, 2, 3,] is valid JavaScript but invalid JSON. Remove the last comma.
• Single quotes. JSON strings and keys must use double quotes; {'a': 1} fails.
• Unquoted keys. {name: "Alice"} is a JS object literal, not JSON — the key needs quotes: {"name": "Alice"}.
• Comments. Standard JSON forbids // and /* */ comments; strip them before pasting.
• NaN, Infinity, or undefined. None are valid JSON values. Replace them with null or a real number.

When to use each option together

The transforms compose, which unlocks a few high-value workflows. To make two API snapshots diffable, turn on sort keys and pick a fixed indent so only real value changes surface in a code review. To clean up a verbose configuration export, combine remove nulls with compact arrays so optional empty fields vanish and short lists stop sprawling across dozens of lines. To prepare JSON for embedding in source code, use Minify to collapse it to a single line. And when you simply want to understand a payload from an unfamiliar service, format it first to confirm it is valid, then switch to the Schema view for a one-glance map of its shape before you write any code against it.

Why a real parser beats find-and-replace

It is tempting to "format" JSON by hand with an editor's search-and-replace, but that breaks the moment a string value happens to contain a brace, a comma, or a quote. Because this tool parses the document into actual values before re-serializing, punctuation inside strings is left untouched, escape sequences are preserved correctly, and numbers keep their exact representation. The output is therefore guaranteed to parse back to the same data — something a blind text substitution can never promise.

Privacy

Parsing, formatting, tree rendering, and schema inference all run in your browser. Nothing you paste is transmitted to a server — so configuration files, API payloads, and other sensitive JSON stay entirely on your machine. You can verify this by going offline; the tool keeps working.