JSON Formatter, Validator & Minifier

JSON formatting, validation and minification

What is a JSON formatter?

A JSON formatter parses JSON text into a data structure and writes it back out with consistent indentation and line breaks. The data is untouched — only whitespace changes — so the formatted result is interchangeable with what you started from.

How do I format JSON?

1. Paste your JSON into the input editor, or drop a .json file onto it.
2. It is parsed and formatted as you type; the result appears on the right.
3. Pick 2 spaces, 4 spaces or tabs from the indentation control.
4. Press Copy or Download.

How do I validate JSON?

Validation runs on every change, and the Validate button reports on demand without altering the output. A valid document shows a Valid JSON status; an invalid one shows the reason, the line and column, and the offending line with a caret under the exact character.

How do I minify JSON?

Press Minify or Ctrl+Shift+M. The document is parsed first, so a compact string that does not parse can never be produced. The statistics panel reports exactly how many bytes the whitespace was costing.

Does formatting or minifying change my data?

No, in both directions. Formatting adds whitespace between tokens and minifying removes it; neither touches whitespace inside a string value, because that is data. Parse the input and parse the output and you get structures that are equal.

Why is my JSON invalid?

Almost always one of six things: a trailing comma before } or ], single quotes instead of double, an unquoted key, a missing comma between members, an unclosed bracket, or a // comment. Every one of them is legal JavaScript and none is legal JSON — which is exactly why they slip through.

JSON formatting examples

Minified and formatted

{"name":"John","age":30,"active":true}

{
  "name": "John",
  "age": 30,
  "active": true
}

Nested objects

{
  "user": {
    "name": "John",
    "profile": {
      "age": 30
    }
  }
}

Arrays

{
  "skills": [
    "JavaScript",
    "Python",
    "PHP"
  ]
}

Invalid JSON

{
  "name": "John",
  "age": 30,
}

Working with JSON

What is JSON?

JSON — JavaScript Object Notation — is a text format for structured data with exactly six value types: object, array, string, number, boolean and null. There is no date type, no comment syntax, no reference mechanism and no distinction between integers and floats. That small vocabulary is the point.

Its other defining quality is strictness. Keys must be double-quoted, commas separate members and must not trail, and there is one way to write any given structure. A JSON parser needs no configuration and cannot read the same bytes two ways, which is why JSON became the default for web APIs, log lines and configuration that machines exchange.

The same strictness makes JSON tiring to write and easy to break by hand. Almost every "invalid JSON" error comes from writing JavaScript out of habit — a trailing comma, a single quote, an unquoted key — none of which JSON accepts.

What a formatter actually does

The pipeline is short and it matters that it is done in this order: parse first, render second. The text is handed to JSON.parse, which either produces a value or throws. Only if it produces a value is anything rendered.

Doing it the other way round — manipulating the text with pattern matching to insert newlines — is how formatters end up producing output that looks indented and no longer parses. It also means such a tool cannot tell you whether your JSON was valid, because it never actually tried to read it.

Because every view here derives from one parsed value, the formatted code, the tree, the statistics and the minified copy can never disagree with one another. Change the indentation and everything re-renders from the same data.

JSON syntax rules

The complete grammar fits in a paragraph. A document is a single value. An object is zero or more "key": value pairs inside braces, separated by commas, with double-quoted keys. An array is zero or more values inside square brackets, separated by commas. A string is double-quoted, with backslash escapes for quote, backslash, slash, backspace, form feed, newline, carriage return, tab and \uXXXX. A number is an optional minus, digits, an optional fraction and an optional exponent — no leading plus, no leading zeros, no hex. And there are three bare literals: true, false and null, all lower case.

Everything else is invalid, including the things people most expect to work: comments, trailing commas, single quotes, unquoted keys, NaN, Infinity and undefined.

JSON strings, numbers and literals

Strings are where most surprises live. A literal newline cannot appear inside a JSON string — it must be written as \n — and neither can an unescaped control character. Backslashes in Windows paths must be doubled. None of that changes here: the string content you put in is the string content you get out, byte for byte.

Numbers carry a caveat worth stating plainly. JavaScript reads every JSON number as a 64-bit float, so an integer beyond 9,007,199,254,740,991 is already imprecise by the time any browser-based tool sees it. A 20-digit database identifier will come back subtly wrong — not because of this formatter, but because of how the language parses. Keep such identifiers as strings.

The three literals are exact and lower case. null stays null; it never becomes the string "null", never becomes undefined, and is never dropped from an object or an array.

Common JSON errors and how to fix them

• Trailing comma. {"a": 1,} — remove the last comma. The single most common error, because JavaScript allows it.
• Single quotes. {'a': 1} — JSON has only double quotes.
• Unquoted key. {a: 1} — keys are strings and must be quoted.
• Missing comma. Two members with nothing between them; the parser stops at the start of the second.
• Unclosed bracket. Reported at the end of the document rather than where it opened — count from the top when the position looks wrong.
• Comments. Not part of JSON in any form.
• Bad escape. "\q" is not a defined escape; only a fixed set is legal.
• Trailing content. A document holds exactly one value; anything after it is an error.

Reading a line-and-column error

The position reported is where the parser gave up, which is not always where the mistake was made. A missing closing brace is only detectable at the end of the file, so it reports there. A missing comma reports at the start of the next member, one token past the omission.

The practical technique is to read the reported line, then look at the line before it. If the reported position is the very last character of the document, you are almost certainly missing a closing bracket somewhere above. Where the cause is unambiguous — a trailing comma, a single quote, an unquoted key, a comment — this tool names it directly instead of leaving you to work it out.

Duplicate keys

A JSON object may contain the same key twice. The specification does not forbid it and simply calls the behaviour undefined, so parsers differ: JavaScript keeps the last occurrence and silently discards the earlier ones.

That silence is the problem. A configuration file with "port" written twice will do something, and it will not be what whoever wrote the first one intended. This tool detects duplicates by scanning the text — the information is gone from the parsed value — and reports the key and line, without removing anything. Which occurrence should survive is a decision about your data, not one a formatter should make for you.

Minification and payload size

Minifying JSON removes the whitespace between tokens. It is not compression, and it is worth keeping the two ideas separate: gzip or Brotli on the wire will do far more for payload size than removing indentation, and most servers already apply one of them.

Where minification does earn its place is in storage and in transports that are not compressed — a database column, a message queue payload, a query parameter, a log line. The statistics panel shows the formatted size, the minified size and the difference in bytes and per cent, calculated from your actual document rather than estimated.

Tree view

The tree is the fastest way to answer "what shape is this?" for an unfamiliar payload. Each branch names its type and member count; each leaf shows its value with the type spelled out in words next to it, so the distinction between the number 30 and the string "30" is visible rather than inferred from colour.

Clicking a leaf reveals its path — $.user.profile.name — using dot notation for identifier-safe keys and bracket notation for everything else. The filter box dims non-matching rows and opens the ancestors of every match, which is the quickest way to find where email appears in a deeply nested response.

For very large documents the tree opens collapsed. Rendering tens of thousands of nodes eagerly is the classic way a JSON viewer locks the tab, and lazily is not worth the complexity when starting collapsed solves it.

Formatting best practices

• Two spaces is the common default and what most tooling emits. Four is easier to scan at depth; tabs let each reader choose. Be consistent within a repository.
• Format on commit, not on read. A config file that is reformatted by whoever opened it last produces diffs full of whitespace.
• Keep hand-edited config formatted and machine payloads minified. The audiences are different.
• Do not sort keys in files where order carries meaning. Sorting is available here and is deliberately off by default.
• Keep large identifiers as strings so no parser can round them.
• If you need comments, you do not need JSON — use YAML, or a schema with a description field.

Security, and why it matters for a JSON tool

JSON is data, not code, and a formatter must treat it that way. This one never calls eval. Parsing is JSON.parse; the syntax highlighter escapes every slice of text it emits; the tree is built with createElement and textContent rather than string concatenation.

The practical result is that a document containing <img src=x onerror=alert(1)> or a <script> tag is displayed as those characters and nothing else happens. That is the correct behaviour, and it is worth checking in any tool you paste production data into.

The privacy side matters just as much. JSON pasted into a formatter is routinely an API response with a bearer token in it, or a config file with a database URL. Nothing here is uploaded: parse, format, minify and download all run in the page, and once it has loaded you can disconnect and it still works.

Frequently asked questions

Related developer tools

Other ToolAdda converters and formatters that run entirely in your browser.