JSON Formatter, Validator & Cleaner

How to format JSON online

1. Paste or open your JSON. Paste text into the input box, click Open file, or drag a .json file onto the box. Pasting formats automatically.
2. Pick an indent. Two spaces is the most common style (it is what JSON.stringify(data, null, 2) and Prettier produce); four spaces matches Python's json.dumps(indent=4); tabs keep files small and let each reader choose a width.
3. Click Format / Beautify (or press Ctrl/⌘ + Enter). Valid JSON is pretty-printed with syntax colours. Invalid JSON is not guessed at: you get the line, the column, the offending text and a hint.
4. Copy or download the result, or click Minify to get the same data back on a single line.

If the input is not strict JSON — a JavaScript object literal, a config file with comments, a Python dict printed to a log — use Clean & repair instead. It converts the input to valid JSON and lists every change it made.

JSON beautifier and prettier: pretty print options

Beautifying (also called pretty printing) only changes whitespace: each object member and array item goes on its own line, indented by its depth. The data — keys, values and their order — stays the same. Here is the same document minified and beautified with two-space indentation:

{"id":7,"tags":["new","sale"],"price":{"amount":19.99,"currency":"EUR"}}

{
  "id": 7,
  "tags": [
    "new",
    "sale"
  ],
  "price": {
    "amount": 19.99,
    "currency": "EUR"
  }
}

JSON sorter: sort keys alphabetically

The Keys menu turns the formatter into a JSON sorter. Sort A–Z (all levels) sorts the members of every object at every depth, like jq -S. Top level only sorts the outer object and leaves nested objects in their original order. Ignore case puts apple, Banana and cherry in dictionary order instead of ASCII order, where every uppercase letter sorts before every lowercase one. Arrays are never reordered, because array order is part of the data.

Sorted keys make config files diff cleanly in Git and line up objects that came from different serializers. To compare two documents directly, use the JSON diff checker, which ignores key order for you. Drop duplicate keys keeps only the last value of a repeated key, which is what JSON.parse and Python's json.loads do anyway. This way you can see exactly what your program will receive.

JSON syntax highlighting for docs and chat

The output is colour-coded by type: keys, strings, numbers, booleans and null. To paste highlighted JSON somewhere else, choose a format next to Copy. Markdown code block wraps the result in a ```json fence, which GitHub, GitLab, Slack, Notion and most static-site generators colour automatically. Coloured HTML copies a self-contained <pre> with inline styles that keeps its colours in a blog post, an email or a CMS that strips stylesheets.

This formatter also keeps numbers exactly as you wrote them. Most online formatters run your input through JavaScript's JSON.parse, which turns 12345678901234567890 into 12345678901234567000 and 1.50 into 1.5. That is a silent data change, and a real problem for 64-bit database IDs and tweet IDs. NeatJSON parses JSON with its own parser and prints each number from the original text. If you paste an integer that JavaScript cannot hold exactly, a note under the tool tells you which one.

JSON cleaner: clean up and tidy messy JSON

A lot of text that looks like JSON is not strict JSON. It might be a JavaScript object pasted from source code, a tsconfig.json or VS Code settings file with comments, a Python print(dict) from a log, output from an LLM, or a response cut off halfway through. Clean & repair turns all of these into valid, tidy JSON. Here is what it fixes:

Repairs are not silent. After cleaning you get a list of each kind of fix and how many times it was applied. Check that list: a truncated array has been closed, but the records that were cut off are still missing. Duplicate keys are kept and flagged, because most parsers would quietly keep only the last value.

JSON validator and fixer: common errors and how to fix them

The validator follows RFC 8259, the JSON standard, and stops at the first problem. Browsers report errors differently (“Unexpected token } in JSON at position 212” in Chrome, “JSON.parse: expected double-quoted property name” in Firefox), so NeatJSON gives its own message with the line, the column and the likely cause. These are the messages you will see most:

Why not just auto-fix everything? Some errors are ambiguous. A missing quote can end a string in more than one place, and a closed truncated array still lacks the cut-off records. So Validate and Format report the problem and leave your text alone, and Clean & repair fixes only the patterns it can fix safely and lists every change. For checks beyond syntax, such as required fields, types and allowed values, you need a schema. The JSON validator page covers that.

JSON parser online: what strict parsing accepts

Validate works like a strict RFC 8259 JSON parser, and it is useful for checking what an API or a JSON.parse call will accept before you ship it.

• Any value can be the top level. "hello", 42 and null are complete JSON documents, not just objects and arrays.
• One value per document. JSON Lines / NDJSON (one object per line) is not a single JSON document. Clean & repair wraps the lines in an array so you can format and inspect them.
• Numbers are exact text. The grammar allows integers of any size, but JSON.parse turns them into 64-bit floats. So {"n": 12345678901234567890} comes back as 12345678901234567000 in JavaScript. Here it is kept as written.
• Duplicate keys parse. The spec says names “SHOULD be unique” but does not forbid repeats. They parse, and this tool warns you about them.
• Only four whitespace characters count. These are space, tab, line feed and carriage return. A non-breaking space copied from a web page is a syntax error.

Simplify JSON: minify vs. beautify

Minifying removes every space and line break that is not inside a string. The data does not change and any JSON parser reads both versions the same way. Minified JSON is usually 15–30% smaller than two-space pretty JSON, and more when nesting is deep. Most of that difference disappears once the response is gzip- or brotli-compressed, so minify for storage, logs, query strings and payload limits (message queues, environment variables, localStorage). Beautify anything a person needs to read or review. The JSON minifier also reports byte savings, if that is all you need.

Pretty print JSON in code and on the command line

JavaScript / Node.js

const pretty = JSON.stringify(JSON.parse(text), null, 2); // 2-space indent
const min    = JSON.stringify(JSON.parse(text));          // minified

Python

import json
data = json.loads(text)
print(json.dumps(data, indent=2, ensure_ascii=False, sort_keys=True))

# from a shell: validate and pretty print a file
python3 -m json.tool data.json

jq (command line)

jq . data.json            # pretty print (also validates)
jq -c . data.json         # minify to one line
jq -S . data.json         # sort keys
curl -s https://api.example.com/users | jq .

Java (Jackson)

ObjectMapper mapper = new ObjectMapper();
Object tree = mapper.readTree(text);
String pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(tree);

These tools do not all behave the same way. Python's json.tool accepts NaN and Infinity, which strict JSON does not, and JavaScript rounds large integers. jq keeps number literals exactly in version 1.7 and later.

More JSON tools

Frequently asked questions