JSON Formatter

A keyboard-driven JSON formatter, validator, and minifier that runs entirely in your browser. Paste raw JSON, get a clean, indented, validated document back. Or reverse it — minify pretty-printed JSON down to the smallest valid representation. The validator is live: the badge on the input panel flips to green the moment your input becomes a legal JSON document, and red the moment it stops, with a line/column reference to the offending character. No payload ever leaves your device.

Why a dedicated JSON formatter

Most online JSON formatters do the work on a server. That makes them fast to build, but it also means every API response, config file, webhook body, and error payload you paste gets logged somewhere you do not control. For anyone working with production data — JWTs, access tokens, PII, payment metadata — that is a non-starter. A "pretty print" button is not worth leaking a production log line to a third party.

It is also the wrong architecture. JSON parsing is a pure function of a string. The browser you are already using ships a compliant parser in JSON.parse and a serialiser in JSON.stringify; there is no reason to send bytes across a network to run those two functions on a different computer. This tool uses the parser that is already on your machine, wraps it in a thin Result<T, E> interface so errors are typed rather than thrown, and renders the output next to the input. You get the same correctness guarantees as the V8 parser inside Node.js — because it is, literally, the same parser — without the round-trip.

The formatter also doubles as a strict validator. When a document passes here it will pass in JSON.parse, jq, Go's encoding/json, Python's json module, and every RFC 8259-compliant parser. A pretty-printer that silently accepts JSON5 comments is worse than useless — it makes you think your document is portable when it is not.

What it does

• Pretty-print with 2 spaces, 4 spaces, or tab indent. Output is RFC 8259-compliant and round-trips through any standard parser. Switching indent with output already on screen re-formats immediately.
• Minify to the smallest valid representation: whitespace between tokens stripped, strings byte-identical. Useful for HTTP payload budgeting, single-line JSON columns in Postgres or BigQuery, curl -d invocations, and environment-variable config.
• Validate as you type. The input badge goes green when the document parses, red when it does not; failure shows the native JSON.parse message plus a line and column derived from the error's byte position.
• Strip BOM automatically. Windows tooling, older Excel, and misconfigured PowerShell redirections emit a leading UTF-8 byte order mark that breaks naive parsers; the tool removes it before parsing.
• Trim whitespace at the edges. Leading and trailing spaces, newlines, and tabs pasted from a log file or chat message are ignored; the reported byte count is the trimmed size.
• Byte counters and savings after minify. Both sides are measured with TextEncoder so multi-byte characters count correctly, and the percentage is rounded to one decimal.
• Share via URL hash. Input and indent serialise into #s=… so pasting the link into Slack or a ticket reloads the exact same state on another machine. The hash is never transmitted.

Under the hood

The transform layer is three pure functions: validate, format, and minify. Each takes a string and returns a typed Result. That shape is deliberately boring — the UI never handles exceptions, never blocks on a worker, never shows a spinner. A 2 MB document parses in single-digit milliseconds and the output panel repaints on the next animation frame.

Error reporting is where the tool invests effort above what JSON.parse gives you. Native browser errors look like Unexpected token } in JSON at position 347 — accurate, but not useful when you are staring at a 50-line document. The tool pulls the byte offset out of that message, walks the trimmed input counting newlines, and appends (line 12, column 8) — the same notation your editor uses. Firefox emits a slightly different shape (line L column C) and the extractor handles both. When the parser gives no position at all the message is surfaced verbatim, so you are never left guessing whether the tool is hiding information.

The live validation badge uses useMemo keyed on the input string, so it runs on every keystroke without re-rendering the rest of the page. Formatting and minifying trigger only on explicit action — Format, Minify, or changing the indent while output already exists — which keeps the URL hash from being rewritten on every keystroke.

Indent mode is typed as the literal union 2 | 4 | "tab" end-to-end, so the dropdown cannot desync from the serialiser. No custom indent code path — the browser's JSON.stringify does the work, so output is guaranteed RFC 8259-clean.

Privacy, and runs entirely in the browser

No analytics on input content and no third-party script in the transform path. The page ships with no JSON-handling endpoint — open the network tab while you format and you will see zero outbound requests tied to the transform. We do load Google Analytics 4 for aggregate page-view counts (cookieless by default, honours DNT/GPC — details), but it never receives textarea content or URL-hash state. The Share button encodes a base64url snapshot of your input and indent into the URL fragment (#s=…), which by HTTP design is never sent to any server. Sharing a link is a peer-to-peer transfer of state, not an upload; even URL-rewriting intermediaries like Slack unfurling or corporate proxies only see the path and query, never the hash.

That matters more than it sounds. Production JSON routinely contains session tokens, API keys, JWT claims, webhook signing secrets, and internal service names. Pasting any of that into a server-rendered formatter is, functionally, emailing it to whoever runs the site.

Keyboard shortcuts

• ⌘/Ctrl + Enter — Format the current input.
• ⌘/Ctrl + Shift + M — Minify the current input.
• ⌘/Ctrl + K — Open the global command palette and jump to another tool without leaving the keyboard.

The shortcuts work even when focus is in the input textarea, because they include a modifier key — typing a literal newline into the input is still Enter alone.

What's not supported (yet)

• JSON5 / JSONC — comments, trailing commas, and unquoted keys are rejected. Strict-mode behaviour on purpose; a relaxed-parser tool for tsconfig.json and friends is on the roadmap.
• Sort keys / canonicalise — no alphabetical-sort toggle yet. Canonical JSON for hashing or snapshot tests is planned alongside a JCS (RFC 8785) mode.
• JSON Schema validation — this tool checks syntax, not shape. A forthcoming validator will handle $ref, oneOf, allOf, and format assertions.
• Structural diff — see the JSON Diff tool for key-by-key comparison of two documents.
• Path querying — for extracting a value from a large document by JSONPath, use the JSON Path tool.
• Streaming — documents bigger than browser memory belong in a CLI like jq or a streaming parser such as clarinet.
• Big-integer preservation — numbers round-trip through IEEE 754 doubles, so values above 2^53 lose precision. Represent them as strings if exactness matters.

Related tools

• JSON Minify — single-purpose minifier for one-click strip-whitespace without the full formatter UI.
• JSON Diff — key-by-key structural comparison of two documents with added, removed, and changed paths called out inline.
• JSON Escape — quote a raw string for embedding in a JSON value, or un-escape a quoted one, with correct \u, \n, and surrogate-pair handling.
• JSON Path — evaluate a JSONPath expression against a document and see the matching subtree.
• YAML Formatter — same "format and validate locally" contract for YAML configs.
• CSV to JSON — convert a CSV export into a JSON array of objects ready to paste back into this formatter.