JSON Formatter

Paste or open a JSON document and the tool parses it immediately. If it's valid, you can switch between three views:

• Tree — a collapsible outline of objects and arrays. Useful for inspecting nesting and finding a single value in a large response without scrolling through thousands of lines.
• Table — arrays of similar objects rendered as rows and columns, which is the fastest way to scan a list of records.
• Raw — the pretty-printed text, ready to copy back into your editor.

You choose the indentation (2 spaces, 4 spaces, or tabs) and can minify to a single line for sending over the wire. Validation runs as you edit: when parsing fails, you get the reason and the position of the error rather than a generic "invalid JSON" message, so you can jump straight to the offending character.

Suppose an API hands you this, all on one line with a stray comma:

{"user":{"id":42,"name":"Ada","roles":["admin","editor",]},"active":true}

Strict JSON rejects the trailing comma after "editor". The auto-fix step removes it, and formatting with 2-space indentation gives you:

{
  "user": {
    "id": 42,
    "name": "Ada",
    "roles": [
      "admin",
      "editor"
    ]
  },
  "active": true
}

Now the tree view shows user as an expandable node and roles as a three-item array, and the YAML conversion produces a flatter, comment-friendly version of the same data. The original input never left the page.

• Reading API responses. A minified response is unreadable; format it and open the tree to find the field you need.
• Reviewing config files. package.json, tsconfig.json, app manifests, and CI configs are JSON. Formatting normalises indentation before you commit so diffs stay clean.
• Debugging logs. Structured log lines are often single-line JSON. Paste one to expand the context, stack frame, or request metadata.
• Cleaning hand-written JSON. People leave trailing commas and inconsistent spacing; auto-fix and reformat fixes both in one pass.
• Comparing shapes. Drop two records into table view to confirm they have the same keys.
• Quick YAML conversion. When a tool wants YAML but you have JSON, convert without installing anything.

A few things that trip people up:

• Trailing commas are not valid JSON. They're legal in JavaScript object literals, so they sneak in constantly. The auto-fix handles them, but the raw string you paste elsewhere must not contain them.
• Keys must be double-quoted. {name: "Ada"} is a JavaScript object, not JSON. Keys need "name".
• No comments allowed. Standard JSON has no // or /* */. If your config uses them (some tools accept "JSONC"), strip them before validating.
• Single quotes don't count. JSON strings use double quotes only.
• NaN, Infinity, and undefined are invalid. Use null or a number.
• Large files render lazily. Tree and table views handle big arrays, but if your browser slows down, switch to raw view, which is lighter.

JSON is a deliberately small subset of JavaScript's object syntax, defined so that any compliant parser in any language accepts exactly the same documents. That strictness is the point: by banning trailing commas, comments, single quotes, and unquoted keys, the grammar stays unambiguous and easy to implement, which is why JSON works the same in a browser, a Go service, and a Postgres column.

The value types are also fixed: an object ({}), an array ([]), a string, a number, true, false, or null. Notably there is no date type, so dates travel as strings (commonly ISO 8601, like "2026-06-02T10:30:00Z") and your code reparses them. Numbers have no explicit integer/float distinction in the spec, and very large integers can lose precision once they exceed what a 64-bit float represents, which is why IDs are often sent as strings.