JSON Formatter & Validator
Paste JSON to format with pretty printing, validate for syntax errors, explore as a collapsible tree, and minify. Handles large JSON files up to 5MB.
Why Nearly Every DevOps Toolchain Speaks This Format
JSON is the connective tissue between almost every system an infrastructure engineer touches day to day: API responses, Kubernetes ConfigMaps and API server output, Terraform state files, package.json manifests, CloudFormation templates, and GitHub Actions job outputs are all JSON, even when the tool wrapping them (YAML, HCL) hides that fact at the authoring layer. That ubiquity is precisely why a fast, no-install formatter earns a permanent spot in a browser bookmarks bar — there is rarely a day in infrastructure work that doesn't involve reading, reshaping, or validating a JSON blob someone else produced.
Reaching for jq Instead of a Browser Tab
This formatter and the command-line tool jq overlap but aren't substitutes for each other. For a one-off paste-and-read task — glancing at what an API just returned, or eyeballing a config a teammate dropped in Slack — the browser wins on friction: no terminal context switch, and a collapsible tree that's faster to scan visually than piping through jq . | less. jq takes over decisively the moment the task becomes querying or transforming rather than reading: an expression like jq '.items[] | select(.status=="failed") | .name' extracts exactly the failing item names and can feed directly into another command, which no formatter alone does. jq also streams its input rather than loading the whole document into memory, so it scales to multi-gigabyte files that would freeze a browser tab. The practical split most engineers settle into: format-and-inspect here, then reach for jq the moment the JSON needs to drive a script or a pipeline step.
Turning a 40KB API Dump Into Something Readable
Say curl -s https://api.internal/v1/orders/8834 returns a single unbroken line of JSON a few hundred bytes long, with no whitespace and no obvious structure at a glance. Pasted into the formatter with 2-space indentation selected, the same data resolves into a nested object where order.line_items is visibly an array of four objects, each with a sku, quantity, and a nested pricing object — structure that was completely invisible in the raw response. Switching to tree view collapses the four line items down to summary rows, letting you expand only the third one, which is the one with the unexpected null discount field the bug report mentioned. Running the same document through minify mode afterward strips it back down to one line, useful when you need to paste the corrected payload into a request body or an environment variable where every extra byte of whitespace is wasted.
What RFC 8259 Actually Requires
Both the parsing and the validation this tool performs are governed by RFC 8259, the IETF specification that supersedes the earlier RFC 7159 and formally defines the JSON grammar every conforming parser must accept. The spec is notably stricter than the informal "JavaScript object literal" most engineers picture: property names must be double-quoted (never single-quoted, never bare), trailing commas are not permitted after the final element of an object or array, and numbers cannot have leading zeros or a trailing decimal point with no digits after it. Parsing here runs on the browser's native JSON.parse(), which implements this grammar exactly and throws a descriptive SyntaxError with a character position the moment the input deviates from it — which is also why documents that work fine as a JavaScript literal in a script file will still get flagged as invalid here, correctly.
Syntax Errors That Look Like Ghosts
- A trailing comma left over from editing: Deleting the last property in an object often leaves a dangling comma after the new last property — legal in a JS literal, rejected outright by strict JSON.
- Single quotes copied from Python or JavaScript source: JSON requires double quotes for both keys and string values; single-quoted strings pasted from another language's source file will fail to parse.
- An unescaped newline or backslash inside a string value: A Windows file path pasted directly into a JSON string (
"C:\Users\...") breaks parsing because backslashes must be escaped as\\. - A duplicate key further down the same object: Valid per the JSON grammar but a frequent source of "why is this field different from what I set" bugs, since most parsers silently keep only the last occurrence.
Frequently Asked Questions
What does this JSON formatter do?
The formatter takes raw or minified JSON — including JSON that has been concatenated into a single line — validates it for syntax errors according to the JSON specification, and outputs it with proper indentation using your choice of 2 spaces, 4 spaces, or tab characters. It reports key count, nesting depth, and output size so you can quickly assess the structure of an unfamiliar JSON document. The collapsible tree view mode renders the JSON as an interactive nested list where you can expand and collapse individual objects and arrays, making it much easier to navigate large JSON documents than scrolling through formatted text. The minify mode produces the most compact valid JSON output, useful for embedding JSON in environment variables or HTTP request bodies where whitespace is wasted bytes.
What is the maximum JSON size this tool can handle?
Since all processing happens in your browser using JavaScript's native JSON.parse() and JSON.stringify() functions, the practical limit depends on your device's available memory and the browser's JavaScript heap size. Most modern browsers on desktop hardware can handle JSON documents up to 5 to 10 MB without issues. The tree view mode is more memory-intensive than the formatted text view because it builds a DOM representation of the entire document, so very large JSON files are better viewed in formatted text or minified mode. For JSON files over 10 MB, consider using the command-line tool jq, which processes streaming JSON without loading the entire document into memory, using a command like cat large.json | jq .
How do I find and fix a JSON syntax error?
When the formatter detects a syntax error, it displays the error message from the JSON parser along with the approximate character position where the error was detected. The most common JSON syntax errors are: trailing commas after the last property in an object ({"key": "value",}) or after the last element in an array ([1, 2, 3,]), which are legal in JavaScript but forbidden in strict JSON; using single quotes instead of double quotes around strings or property keys; omitting quotes around property keys entirely (as in JavaScript object literals); missing commas between object properties or array elements; and unescaped special characters within string values, such as bare newlines or unescaped backslashes. The character position indicator in the error message helps you navigate to the problem area in the input panel to make the correction.