JSON Formatter / Validator

Pretty-printing JSON is a solved problem. Every formatter on the internet takes a minified blob and adds line breaks, and they all do it about equally well, so that isn't really why you'd pick one over another. The moments that actually cost you time are different. Your JSON won't parse and the formatter just refuses, throwing a cryptic error that points a couple characters past the real mistake, so you're stuck counting brackets by hand. Or the response is four thousand lines and you need one field buried in the middle, which is a different problem entirely. This tool has a button for each. Repair fixes broken JSON so you stop hunting for the missing comma, and the JSONPath filter pulls the field you want out of a giant payload without scrolling. Format, minify, and validate are here too, and all of it runs in your browser, so the tokens and customer data you paste never leave your machine.

1. Paste your JSON into the input box. Minified, pretty-printed, half-edited, it doesn't matter. The tool reads all of them.
2. Hit Format to pretty-print, or Minify to crush it back onto one line. Pick 2 spaces, 4 spaces, or tabs first if you care about the indent style.
3. If it won't parse, hit Repair. It fixes the usual breakage and rewrites your input in place so you can see what it changed, then formats the result.
4. Once you have valid JSON, a JSONPath box appears. Type an expression like $.tools[*] to filter down to just the part you want. Leave it blank for the whole document.
5. Flip the output between Text and Tree. Tree view lets you collapse and expand branches, which beats scrolling through a massive object to find one node.
6. Copy the output, Download it as a .json file, or Clear both boxes to start over. Load sample drops in an example if you just want to poke at it.

Most formatters have one response to malformed JSON, which is to stop and complain. You get a message like Unexpected token } in JSON at position 214 and then you're on your own to go hunting. Repair is there so you do not have to. It takes the mangled text, applies the fixes people actually need, and hands back clean JSON.

Here's what it handles: single quotes where JSON wants double, the trailing comma you left after deleting the last property, // line comments and /* block comments */ that strict JSON rejects, keys left unquoted the way JavaScript allows, and a handful of other common messes. It writes the corrected version straight back into the input box, so you're not just told it worked, you can read the change yourself and decide whether you agree with it.

One honest caveat. Repair is inferring what you meant, and inference can guess wrong. If a value is genuinely missing or the structure is truly ambiguous, it makes a reasonable call, and that call might not be the one you had in mind. So glance at the result before you trust it. For the everyday case, a config a human hand-edited, a chunk of JS-flavored pseudo-JSON, a copy-paste that dropped its quotes, it just works and saves you the tedium.

JSONPath is the thing a plain formatter doesn't give you. Once your JSON is valid, a filter box shows up, and you can run a query against the whole document live. Type, and the output updates as you go.

A few expressions cover most of what you'd reach for:

• $.tools[*] grabs every item in the top-level tools array.
• $..name finds every name key anywhere in the document, however deep it's nested. That recursive one is the workhorse when you don't even know which level the field lives on.
• $[?(@.free==true)] filters an array down to only the objects where free is true.

The output box then shows only the slice you asked for, formatted with your chosen indent, so you can select it right there and copy it out. For a big response where you only care about the email addresses or the IDs, this turns a long scroll-hunt into one line. If you'd rather work visually, the Tree view collapses the whole object so you can open just the branch you're chasing.

When JSON won't parse, the tool shows the exact message your browser's parser produced, position and all. Worth knowing how to read it. That position is where the parser gave up, not always where you went wrong. A missing comma gets reported at the start of the next token, because that's the first thing the parser couldn't reconcile, so the real fix is usually a line or two above where the message points. Nine times out of ten the culprit is a stray or missing comma, a quote that never closed, or a mismatched bracket. And if squinting at positions feels like more trouble than it's worth, that's what Repair is for.

Format and Minify are the two directions, and they undo each other cleanly. Pretty-print adds the whitespace back so a human can read and diff the structure, minify strips every spare byte so the payload travels light. Both produce identical data, only the whitespace moves, so bounce between them as often as you like with zero risk to the content. Need the data in a different shape entirely? The JSON to CSV and JSON to YAML converters take it from there.

Indent is your call, purely cosmetic. Two spaces is the web default and keeps deep nesting on screen, four spaces spreads it out, tabs let each editor render the width it prefers. It only touches the pretty-printed output, never the data.

All of this happens in your browser with the same JSON engine the browser already ships. Nothing you paste is uploaded, logged, or saved, which matters when the thing you're debugging is an API response full of auth tokens or a customer record. Plenty of cloud formatters send your paste to their server, and a few store it at a public URL that then gets indexed. This one can't, there's no server in the loop. Open your Network tab and paste something, you'll see zero outgoing requests. Close the tab and it's gone.