JSON Formatter
Pretty-print, minify and validate JSON instantly.
Output
{
"name": "Dev Hub Solutions",
"products": [
"PromptAxiom",
"LeadGenHub",
"BuildFlow"
],
"shipping": true
}About JSON Formatter
A fast, local JSON formatter. Pretty-print with configurable indent, minify, and validate with helpful error messages.
Why we built it
Every other JSON formatter on the web pings a server with your data — sometimes including secrets. This one runs entirely in your browser.
How to use
- 1Paste your JSON into the editor on the left.
- 2Pick pretty-print or minify mode.
- 3Copy the formatted output, or fix any flagged errors.
JSON is the lingua franca of modern APIs, configs, and data exchange. It is also one of the easiest formats to write incorrectly — a single trailing comma, a missed quote, an unescaped newline, and the parser throws an error with a line number that may or may not match what you're looking at. This formatter exists for those moments: paste, fix, copy, move on.
What "valid JSON" actually means
The JSON specification (RFC 8259, 2017) is shorter than most blog posts about it. A valid JSON document is one of six things: an object (curly braces, comma-separated key-value pairs, keys are always double-quoted strings), an array (square brackets, comma-separated values), a string (double-quoted, with `\"`, `\\`, `\n`, `\r`, `\t`, `\b`, `\f`, `\/`, or `\uXXXX` for escapes), a number (integer or decimal, no leading zeros except `0.x`, no trailing comma after the last digit), `true`, `false`, or `null`. That's it. No comments, no trailing commas, no single quotes, no `undefined`. JSONC (the format VS Code uses for `settings.json`) and JSON5 (a more permissive superset with comments and unquoted keys) are different formats — this tool validates strict JSON only.
Pretty-print vs minify, and why both matter
Pretty-printed JSON is for humans — code review, debugging, manual editing, documentation. Minified JSON is for machines — wire transport, storage, caching. The conversion is lossless: pretty-print expands every minified document, minify collapses every pretty-printed one, and a round-trip produces a byte-identical result. Indent depth defaults to 2 spaces here because that matches what most linters, IDEs, and language style guides converged on. If you need 4-space indents or tabs, tweak the indent setting.
Common errors and how to read them
When validation fails, you'll see a message like "Unexpected token } in JSON at position 142". That position is a zero-indexed character offset into the input — but most editors show 1-indexed line and column numbers. We translate the position to line and column so you can jump directly to the broken character. The three most common errors are trailing commas (allowed in JavaScript, never in JSON), unquoted object keys (`{name: "foo"}` is invalid — needs `{"name": "foo"}`), and single quotes around strings (`'foo'` is invalid — needs `"foo"`). If you're copy-pasting from JavaScript source, those are the three things to fix.
Why local-only matters
Most JSON formatters online run on a server: you paste your JSON, the server parses it, the server returns formatted output. That's fine for public data. It's not fine when the JSON contains an API key in a header, a JWT in a payload, customer PII in a webhook, or any other production data — every paste is a small leak. This formatter runs entirely in your browser. The parser is `JSON.parse()`, the pretty-printer is `JSON.stringify(parsed, null, indent)`, the validator is a try-catch around `JSON.parse()`. No network requests. Open DevTools and confirm.
Frequently asked questions
Quick answers to the questions people actually ask about JSON Formatter.
Is my JSON sent to a server?
Is my JSON sent to a server?
No. The formatter, validator and minifier all run in your browser. Your JSON never touches our servers, our logs, or any third-party service. Open DevTools and watch the Network tab while you paste — there are zero outbound requests on format or validate.
What's the difference between pretty-print and minify?
What's the difference between pretty-print and minify?
Pretty-print adds line breaks and indentation so JSON is readable to humans. Minify strips every byte that isn't required for a valid parse — line breaks, spaces, tabs — to produce the shortest payload. Use pretty-print while you're debugging or reviewing; use minify when you're shipping JSON over the wire and every byte costs you latency or egress.
Why is my JSON invalid?
Why is my JSON invalid?
The most common causes: a trailing comma after the last property, single quotes instead of double quotes, unquoted object keys, a stray comment (JSON doesn't allow comments — JSONC and JSON5 do, but they're not the same thing), or an unescaped newline inside a string. The validator highlights the exact line and column where parsing failed so you can fix it without hunting.
Can it handle deeply nested or very large JSON?
Can it handle deeply nested or very large JSON?
Yes. We've tested it on payloads up to ~10MB without issue. Past that point, browsers themselves start to choke — not because of the formatter, but because rendering tens of thousands of indented lines in the DOM is expensive. For files over 10MB, prefer a CLI tool like `jq`.
Does the formatter support JSONC, JSON5, or NDJSON?
Does the formatter support JSONC, JSON5, or NDJSON?
Right now, strict JSON only. JSONC (JSON with comments — used by VS Code config files) and JSON5 (a more permissive superset) will fail validation. NDJSON (newline-delimited JSON) needs to be parsed line by line, not as a single document. We're considering a dedicated mode for each — let us know if that would help.
Is there a JSON-to-CSV or JSON-to-YAML converter?
Is there a JSON-to-CSV or JSON-to-YAML converter?
Not yet — those are on the roadmap. For now, the formatter handles formatting, validation, and minification. Converters are coming.