What is a JSON pretty-diff?

A JSON pretty-diff compares two JSON documents and highlights the differences in a readable, formatted way. Rather than diffing raw text, it understands JSON structure — so it can tell you precisely which keys were added, which were removed and which values changed, even when the two documents are formatted differently or have their keys in a different order.

How is the structural diff different from a plain text diff?

A plain text diff compares characters and lines, so re-indenting a file or reordering keys produces noise. The structural diff walks the parsed JSON tree key by key and index by index, classifying each leaf as added, removed, changed or unchanged. With the Sort keys option on, two objects with the same data but different key order show as identical. This tool offers both views so you can pick whichever is clearer for your task.

Does it handle nested objects and arrays?

Yes. The tool recurses through nested objects and aligns arrays by index, so a change buried several levels deep is highlighted in place and its parent containers are marked as containing a change. Containers that exist on only one side are rendered with all of their nested contents.

Is my data sent anywhere?

No. Both documents are parsed and compared entirely in your browser using client-side JavaScript. Nothing is uploaded to a server, which makes the tool safe for configuration files, API payloads and other sensitive data. Your last inputs are saved only in your own browser via local storage.

Why does the tool say my JSON is invalid?

Each pane is parsed independently and shows the parser error inline — common causes are trailing commas, single quotes instead of double quotes, unquoted keys or missing brackets. Use the Pretty-print both button to reformat valid JSON, and fix the reported syntax before the diff can run.

Can I export the differences?

Yes. The Export report button produces a plain-text summary listing every change as a path: added keys are prefixed with a plus, removed keys with a minus and changed values shown as old to new. It also includes a one-line summary of how many keys were added, removed and changed, which is handy for changelogs or code review notes.

JSON Pretty-Diff — Gera Tools

JSON Pretty-Diff compares two JSON documents and shows you, at a glance, exactly what is different between them. Paste an original document on the left and a changed document on the right, and the tool produces a colour-coded structural diff: keys that were added appear in green, keys that were removed appear in red, and values that changed appear in amber, all laid out as an indented tree of the merged structure. It is built for anyone who works with JSON every day — comparing two API responses, reviewing a config change, checking what a migration script altered, or confirming that two package.json files really do differ only where you expect.

Unlike a plain text comparison, this tool understands the shape of your data. It parses both sides into real JSON values and walks them key by key and index by index, so it can tell the difference between a value that genuinely changed and one that simply moved because the file was re-formatted. Turn on Sort keys and two objects that hold the same data in a different key order are reported as identical — exactly what you want when one document came from a pretty-printer and the other from a minifier.

How it works

The tool parses each pane independently. If either side is not valid JSON, the error is shown inline next to that pane and the diff pauses until you fix it — no silent failures. Once both sides parse, each document is canonicalised: optionally key-sorted and normalised so formatting noise never shows up as a difference.

The structural engine then performs a deep, recursive comparison. For objects it takes the union of keys from both sides; for arrays it aligns elements by index. Every leaf is classified as added, removed, changed or unchanged, and every container that holds a change is marked so you can quickly find nested edits. A running summary counts how many keys were added, removed and changed.

If you prefer a patch-style view, switch to Text diff to see a classic line-by-line comparison of the formatted JSON, powered by a proper diff algorithm with added and removed lines highlighted. When you are done, Export report downloads a plain-text list of every change keyed by path.

Example

Suppose the left document is a package.json at version 1.4.0 with express pinned to 4.18.2, and the right document bumps the version to 2.0.1, upgrades express to 4.19.2, drops zod, adds pino, adds a lint script and appends http to the keywords array.

The structural tree shows:

version highlighted amber: "1.4.0" becomes "2.0.1"
dependencies.express amber: "4.18.2" becomes "4.19.2"
dependencies.zod red (removed) and dependencies.pino green (added)
scripts.lint green (added)
keywords.2 green (the new "http" element)

The summary bar reads something like 2 added, 1 removed, 3 changed, and the exported report lists each of those as a one-line path. Every figure is computed locally in your browser — none of your JSON is ever uploaded or stored on a server.