JSON formatter & validator

How to use the JSON formatter

Paste JSON into the Input box — or drag a file onto it, press Load file, or fetch it from a URL — and it is checked as you type. Press Format (or Ctrl+Enter) to pretty-print it with two spaces, four spaces or tabs, or Minify to strip every unnecessary space for the smallest payload. The output has line numbers and syntax colours that stay readable in light and dark mode, and can be copied, downloaded or moved back into the input with Use output as input.

Switch the output to Tree to browse a large document: objects and arrays expand on click, show how many keys or items they contain, and long arrays load in pages of 300 so a 50,000-item array doesn’t lock up the tab. Clicking any key copies its path, such as $.orders[1].customer, ready to paste into code.

The search box accepts a key name (every key containing that text, anywhere in the document) or a path with dots, brackets and wildcards: address.city, orders[0], orders[-1] for the last item, or $.orders[*].total to pull one field out of every element. JSON Lines files (one object per line, .jsonl or NDJSON) are recognised automatically: Minify keeps one record per line, and Format shows the records as an array.

Fetch asks your browser to download the address directly — nothing passes through our server — so it only works when that server allows other websites to read it (CORS). Many APIs don’t; in that case open the URL in a new tab and paste the result.

Reading validation errors

Browsers’ own error messages are terse (“Unexpected token } in JSON at position 1843”). This validator is written for humans: it gives the line and column (an emoji counts as one character), shows the offending line with a caret under the exact character, and explains the likely cause. The mistakes it recognises include:

• Trailing commas — [1, 2, ] is fine in JavaScript but not in JSON.
• Single quotes, curly quotes and unquoted property names — JSON requires straight double quotes around every string and key; “smart” quotes pasted from Word or Slack are named as such.
• Comments — // and /* */ are not part of JSON, even though some config files allow them.
• Python literals — True, False and None from a Python print() instead of json.dumps().
• Invisible characters — a non-breaking space or zero-width space is named rather than shown as a blank; a leading byte-order mark is simply ignored.
• Missing commas, mismatched brackets, line breaks inside strings, leading zeros, NaN and undefined, and several top-level values pasted one after another.

Repair is a forgiving parser that rewrites the input as valid JSON and lists every change: it strips comments, removes trailing and doubled commas, adds missing commas and colons, converts single, curly and backtick quotes, quotes bare keys (including accented ones such as café), turns JSON5 numbers such as 0x1F, +5 and .5 into plain decimals, maps Python True/None and tuples, unwraps ObjectId("…"), JSONP and Markdown code fences, and closes brackets and strings in truncated JSON. Because a missing comma or a cut-off file can hide real data loss, check the result — the Undo button restores your original.

Big numbers, duplicate keys and why formatting is exact

Most online formatters run JSON.parse then JSON.stringify. That quietly changes your data: JavaScript numbers are 64-bit floats, so an ID like 9007199254740993 becomes 9007199254740992, and when a key appears twice only the last value survives. For database IDs, Twitter/X snowflake IDs or payment references that is a real bug.

This tool never converts your numbers. Its own parser keeps every number as the digits you wrote and every object as an ordered list of key–value pairs, so big integers, 1.0000000000000001, 1E400, duplicate keys and key order come through untouched in every feature. Sort keys is a stable sort, so two entries with the same key stay next to each other in their original order. The status line still warns you about big integers and duplicate keys, because the next program to read the file probably won’t be as careful.

JSON to CSV, YAML and XML, and large files

JSON → CSV takes an array of objects (or the first array property of an object, as many APIs wrap results in {"data": [...]}) and builds one column per key across all rows, flattening nested objects into dot-named columns such as address.city. Choose a comma, a semicolon (what Excel expects in most of Europe) or a tab. Values starting with =, +, - or @ are prefixed with an apostrophe so spreadsheets can’t execute them as formulas, and the downloaded file starts with a UTF-8 byte-order mark so Excel shows £ and accents correctly.

JSON → YAML writes block-style YAML with two-space indentation and quotes any string a YAML parser would misread — yes, no, on, off, null, 007, dates and anything containing : or # — so the values come back exactly as they were. JSON → XML wraps the document in <root>, repeats an element for each array item, escapes & and <, and keeps keys that aren’t valid XML names in a key attribute.

Escape to string turns the input into a JSON string literal for embedding in another document; Unescape string reverses it, which is the fix for log lines full of \". To pass JSON through a URL or an HTTP header, encode it with Base64; for dummy text values in a mock payload, use the lorem ipsum generator.

Everything runs in your browser. Parsing and conversion happen in a background worker, with a progress bar and a Cancel button for big jobs, and the output view only draws the lines on screen. On a typical laptop a 6 MB file formats in well under a second while the page stays responsive; the time shown in the status line includes drawing the result. Checking as you type pauses above 1 MB — press Validate or Format instead. The limit is your device’s memory; files over 200 MB are refused.

Frequently asked questions