JSON Formatter

How to use this JSON formatter

1. Paste any raw or minified JSON.
2. It reformats with proper indentation automatically as you type.
3. If there's a syntax error, you'll see exactly where it is.

Why format JSON?

Minified JSON from APIs is hard to read. Formatting adds consistent indentation so you can quickly spot nested objects, arrays, and mismatched brackets.

Does this validate my JSON?

Yes. If the JSON is invalid, this tool shows the exact parser error and position so you can find and fix the problem quickly.

JSON's strict syntax rules — and why they exist

JSON looks almost identical to a JavaScript object literal, which is exactly why its stricter rules trip people up so often. Object keys must always be wrapped in double quotes — single quotes and unquoted keys, both perfectly legal in JavaScript itself, are invalid JSON. Trailing commas after the last item in an array or object, which JavaScript's parser has historically tolerated in some contexts, are also rejected outright. Comments of any kind — // or /* */ — have no place in the JSON specification at all. None of this is arbitrary strictness for its own sake: JSON was deliberately designed as a minimal, unambiguous data format that any language's parser could implement identically, and every one of these restrictions removes a case where different parsers might otherwise disagree on how to interpret the same text.

What JSON can't represent that JavaScript objects can

Because JSON is a data-interchange format rather than a programming language feature, it deliberately excludes several things JavaScript objects support natively. Functions can't be serialized into JSON at all — there's no valid representation for executable code. The special numeric values NaN and Infinity, both valid in JavaScript, have no JSON equivalent and must be represented some other way (commonly as a string, or omitted). The undefined value doesn't exist in JSON either — only null does. And while JavaScript's Map and Set data structures preserve insertion order and unique keys in ways plain objects don't always guarantee, converting them to JSON means first converting them into plain objects or arrays, which can lose some of that structure's original semantics if not done carefully.

Duplicate keys — technically valid, practically dangerous

The JSON specification doesn't actually forbid duplicate keys within the same object, which surprises many people once they learn it. What it doesn't specify is what a parser should do when it encounters one — and different implementations genuinely disagree. Most JavaScript environments, including the browser's own JSON.parse, silently keep only the last occurrence of a duplicate key and discard the earlier ones, but this isn't guaranteed by the spec itself, and some other languages' JSON parsers behave differently, occasionally throwing an error or keeping the first occurrence instead. Because this is genuinely unspecified behavior rather than a hard rule, relying on duplicate keys meaning anything consistent across different systems is a real, if under-recognized, source of subtle data bugs.

Why JSON displaced XML as the default data-interchange format

JSON emerged in the early 2000s as a lightweight alternative to XML, which had been the dominant data-interchange format up to that point, and it won out for reasons that still hold today. JSON's structure maps directly onto data structures nearly every programming language already has built in — objects/dictionaries and arrays — so parsing it typically means one function call rather than the more involved DOM or SAX-style parsing XML documents usually required. Its syntax is also considerably more compact, without XML's opening and closing tag pairs for every single value. This directness is precisely why JSON became especially well suited to web APIs and JavaScript-heavy applications, to the point that it's now the default response format for the overwhelming majority of modern web APIs, even ones built in languages that have nothing to do with JavaScript.

Limitations of this tool

This formatter validates and reformats JSON using your browser's built-in JSON parser, which strictly follows the JSON specification — it won't accept JSON5, JSONC (JSON with comments), or other relaxed JSON dialects some tools and config files use, since those aren't standard JSON at all. It doesn't detect or warn about duplicate keys, since as explained above that's technically unspecified rather than invalid. It also doesn't validate your JSON's structure or content against a schema (for example, checking that a "price" field is actually a number, or that a required field is present) — it only confirms the JSON is syntactically well-formed, which is a different and narrower guarantee than confirming it matches whatever shape your application actually expects.