JSON Formatter

Paste compact, minified, or messy JSON and get perfectly indented output instantly. The formatter parses your JSON with the browser's native JSON.parse (per ECMA-404), preserves Unicode characters, and re-emits with your chosen indent:

• 2 spaces (npm and prettier default)
• 4 spaces
• tab

Nested objects and arrays are correctly indented at every depth. Keys, strings, numbers, booleans, and null get distinct syntax-highlighting colors so you can scan structure at a glance.

The 'beautifier' label is interchangeable with 'formatter' or 'pretty printer' — all describe the same operation: producing human-readable JSON from compact input.

Validation runs as you type. If your JSON fails to parse, the formatter shows the exact line, column, and what the parser expected.

Validation is strict per RFC 8259 (the IETF Internet Standard) and ECMA-404 — no comments, no trailing commas, no single quotes, no unquoted keys, no NaN, no Infinity, no undefined. Top-level value can be any JSON value (object, array, string, number, true, false, null).

For UTF-8 encoded input, the formatter accepts the full Unicode character set; ASCII-only environments should use \uXXXX escapes.

Common errors and fixes:

• trailing comma after the last array/object element (remove it)
• single quotes around keys or strings (replace with double quotes)
• missing closing brace or bracket (the error column points near the truncation)
• unescaped control characters in strings (escape with \n, \t, \\)

Minification strips all insignificant whitespace — spaces between tokens, indentation, and newlines — leaving the most compact possible representation. Typical savings are 20–60% depending on how much your source JSON was indented.

Use minified JSON for:

• REST/GraphQL API responses
• WebSocket messages
• JWT payloads
• SaaS config blobs
• embedded data attributes in HTML

Keep formatted (pretty-printed) JSON for:

• source-controlled config files
• fixtures and snapshots in tests
• human-edited documents

Minified JSON is still 100% standard JSON — any compliant parser accepts it. The minifier here preserves data exactly: no key reordering, no value coercion, no precision loss on numbers within IEEE 754 double range.

Pure JSON syntax validation only checks that the document parses. JSON Schema validates the document's shape — that 'email' is a string, 'age' is an integer 0–150, 'role' is one of ['admin', 'user', 'guest']. A schema is itself a JSON document describing the constraints; instances are validated against it.

Common keywords: type, required, properties, items, enum, pattern (regex), minimum/maximum, minLength/maxLength, format (email, date-time, uri).

Reference implementations:

• Ajv (JavaScript, fastest)
• jsonschema (Python)
• networknt/json-schema-validator (Java)
• justinrainbow/json-schema (PHP)

Schema validation catches a huge class of bugs at the API boundary: missing required fields, wrong types, out-of-range values, malformed dates. OpenAPI 3.x specs use JSON Schema for request/response validation.

JSONPath is to JSON what XPath is to XML — a query language for navigating and extracting from nested JSON.

Syntax:

• $ (root)
• . (child)
• .. (recursive descent)
• [n] (array index)
• [start:end] (slice)
• [?(expression)] (filter)
• * (wildcard)

Examples on a typical store JSON:

• $.store.book[0].title gets the first book's title
• $..author returns every author across the document
• $.store.book[?(@.price < 10)] filters books cheaper than 10
• $.store..price[*] flattens all prices

Tools: jq (slightly different syntax but the same capabilities, dominant in shell scripting), Postman test scripts, JMESPath (AWS CLI's --query), and JSONPath libraries in every major language.

JSON Lines (jsonlines.org), also known as NDJSON or LDJSON, is a format where each line is a complete JSON value. The file as a whole is not valid JSON — but each line individually is.

Used heavily for log streaming (Loki, Splunk HEC, Vector), ETL pipelines, machine learning training data (OpenAI fine-tuning files), and any append-only data flow.

Advantages:

• streaming-friendly (parse one record at a time, constant memory)
• append-only (just write the next line)
• grep-able and awk-able with standard Unix tools

File extensions: .jsonl, .ndjson. Convert from a JSON array with `jq -c '.[]'`; convert to a JSON array with `jq -s` (slurp). BigQuery, Athena, Snowflake, and most modern data warehouses ingest NDJSON natively.

JSON5 (json5.org) extends JSON with developer conveniences:

• comments (// and /* */)
• trailing commas
• single-quoted strings
• unquoted keys
• multi-line strings (with backslash continuation)
• hexadecimal numbers
• IEEE 754 special values (NaN, Infinity)

It is NOT compatible with JSON.parse — you need a JSON5 parser (json5 npm package, PyJson5).

Use JSON5 for human-edited config files where comments are valuable: babel.config.json5, some build tool configs, .vscode/settings.json (which uses JSONC, a similar JSON-with-comments dialect).

Stick to strict JSON for: HTTP APIs, data interchange, storage formats, and anything machine-generated. Mixing the two confuses tooling — pick one per file and stick with it.

The most frequent JSON parse errors and fixes:

• (1) Trailing comma after the last element — `{"a":1,}` or `[1,2,3,]` — remove the dangling comma.
• (2) Single quotes on keys or string values — `{'name':'Alice'}` — must be double quotes.
• (3) Unquoted keys — `{name:"Alice"}` — quote them.
• (4) Comments using // or /* */ — strict JSON does not allow them; strip or switch to JSON5/JSONC.
• (5) JavaScript values that don't exist in JSON — undefined, NaN, Infinity, functions — replace with null or remove.
• (6) Truncated input — the parser usually points to the line where it ran out of expected content.
• (7) BOM (byte-order mark) at the start of a UTF-8 file — most parsers reject it; strip with `sed -i '1s/^\xEF\xBB\xBF//'`.
• (8) Mixed tabs and spaces don't break parsing but break diffs — pick one indent style.

Three categories of JSON-related vulnerabilities every developer should understand.

• (1) Prototype pollution: merging untrusted JSON into an existing object can pollute Object.prototype if the input contains __proto__, constructor, or prototype keys — affecting every object in the runtime. Use Object.create(null), structuredClone, or libraries like lodash's defaultsDeep that explicitly block these keys.
• (2) Never use eval() to parse JSON — eval executes any JavaScript, while JSON.parse is sandboxed. The 'eval is faster' myth was debunked years ago.
• (3) Re-serialization gotchas: JSON.stringify silently omits functions, undefined, and Symbol values from objects (converts to null in arrays). It also throws on circular references and BigInt by default.

Validate untrusted JSON with JSON Schema before processing, set a max body size on your API, and use Content-Type checks to reject non-JSON inputs early. OWASP's REST Security Cheat Sheet covers the full picture.

JSON ↔ YAML is the most lossless conversion — both support nested objects/arrays. Watch out for YAML's automatic type coercion (yes/no/on/off become booleans, unquoted numbers stay numbers, the literal string 'null' becomes null) — quote ambiguous values. Tools: js-yaml (npm), PyYAML, yq.

JSON → CSV requires flattening nested structure — works best for arrays of flat objects. Pick a strategy for nested values: stringify (write as JSON in a cell) or dot-notation columns (`address.city`, `address.zip`). Tools: csvkit's in2csv, pandas pd.json_normalize, json2csv (npm).

JSON → XML is straightforward for tree structures but loses the array vs object distinction — XML siblings could be either. Watch for invalid XML element names (can't start with digits, can't contain spaces). Tools: xml-js, xmltodict (Python).

For all conversions, decide upfront whether you preserve type information or flatten everything to strings.

JSON.parse loads the entire document into memory — fine for typical API responses, problematic for files over a few hundred MB. Streaming parsers process one token (or one record) at a time, holding constant memory regardless of file size.

• JavaScript: stream-json or oboe.js for SAX-style parsing.
• Python: ijson for incremental parsing, or convert to JSON Lines first and read line-by-line.
• Java: Jackson Streaming API (JsonParser).
• Shell: jq processes streaming JSON via --stream.

For files generated as JSON arrays of records, consider switching the producer to emit JSON Lines instead — every downstream consumer benefits. When you must handle a huge JSON array in memory, prefer iterating and discarding records rather than building a parallel data structure. Watch heap size, set --max-old-space-size in Node, and profile before optimizing.

Quick reference for everyday JSON tasks.

• Indent: prettier and npm default to 2 spaces; pick 4 for enterprise codebases that already use 4-space indent across languages; tabs are valid but rare in JSON.
• Sort keys (for cleaner diffs): JSON.stringify(obj, Object.keys(obj).sort(), 2) for shallow objects; jq --sort-keys for deep recursion; Python json.dumps(obj, sort_keys=True).
• Diff two JSON files: jq --sort-keys both files, then run regular diff; or use json-diff (npm), DeepDiff (Python), VS Code's built-in JSON-aware compare.
• Escape sequences in strings: \\" (double quote), \\\\ (backslash), \\/ (forward slash, optional), \\b (backspace), \\f (form feed), \\n (newline), \\r (carriage return), \\t (tab), \\uXXXX (Unicode code point).
• Numbers: JSON allows decimals and exponents (1.5e3) but no leading zeros (0123 is invalid) and no trailing decimal point (1. is invalid).
• Strings must be double-quoted — single quotes are JSON5 only.