0/0

Drop a JSON file to load it

— Line 0 · Chars 0 Line 1, Col 1

0/0

Drop a JSON file to load it

— Line 0 · Chars 0 Line 1, Col 1

Array order matters Ignore key order Ignore case

Only changes

JSON 1

JSON 2

Enter two JSON documents and press “Compare” — the differences will appear here.

0 added 0 removed 0 changed 0 type changes 0 moved 0 total Not compared yet

JSON Diff — compare two JSON files in your browser, without uploading them

JSON Diff is a client-side JSON comparison tool. It walks two JSON documents recursively and highlights every added, removed, changed and type-changed value in a Git-style diff. Parsing, comparison and formatting all happen inside your browser: the JSON you paste is never sent to a server, which makes the tool usable on production payloads, API responses and any data you are not allowed to paste into a third-party website.

What a JSON diff does

A JSON diff compares two documents structurally, not line by line. It walks both trees in parallel, pairs keys by name, and reports what actually changed. A reindented, minified or reordered document that carries the same data is therefore recognised as identical — a difference is reported only when the data itself differs.

Every change carries its JSON Path, a pointer such as data.items[10].children[2].name that says exactly where in the document to look. Clicking a path in the tree view jumps straight to that node, so a change buried ten levels down is as easy to inspect as one at the top level.

The five kinds of difference

Every difference is classified and counted separately.
Kind	What it means	Example
Added	A key that exists in the second document only.	`"role": "admin"` appears on the right
Removed	A key that exists in the first document only.	`"debug": true` disappears
Changed	The same key holds a different value of the same type.	`"port": 8080` becomes `9090`
Type changed	The same key holds a value of a different JSON type.	`"id": 42` becomes `"42"`
Moved	An array element that changed position; reported only when array order is compared.	An element moves from index 0 to index 2

How to compare two JSON files

Load both documents. Paste the original JSON into the left editor and the updated JSON into the right one, or drag a .json file onto either editor, or press Open to pick a file from disk.
Set the comparison rules. Ignoring key order is on by default, so {"a":1,"b":2} and {"b":2,"a":1} compare as equal. Turn on Array order matters when position is part of the data, and open More diff settings to ignore letter case, empty values, or named fields such as createdAt.
Press Compare. The comparison runs locally — inside a Web Worker for large documents, so the interface stays responsive while it works.
Read the result. The tree view is the quickest way to explore structure, the diff view gives a Git-style line-by-line change list, and side by side shows both documents aligned.
Take the result with you. Copy the change list, download it as a file, or generate a link — the payload is compressed into the URL fragment rather than stored on a server.

If a document is not valid JSON, the editor reports the error with its line and column before comparing, so a diff is never polluted by a stray trailing comma.

Comparing JSON arrays: does order matter?

Arrays are where line-based tools fall apart. ["a","b","c"] and ["c","a","b"] hold the same three values, yet a text diff reports almost every line as changed. This tool supports both readings of an array, and you choose which applies.

Order-sensitive comparison

With Array order matters enabled, position is part of the data. The comparison runs a longest-common-subsequence pass, so inserting one element in the middle is reported as a single addition plus the elements that genuinely moved — instead of marking every following line as changed.

Order-insensitive comparison, and pairing elements by a key field

With array order ignored, the two arrays are compared as sets. For arrays of objects that is still ambiguous, so you can name an array pairing field — id, uuid, name, whatever identifies a record. Elements are matched on that field first, and a difference is then reported as a change to that element.

The effect is worth stating plainly. Without a pairing field, inserting one record at the start of a list is reported as a removal of everything after it plus an addition of everything after it. With the pairing field set to id, the same comparison reports one added element and leaves the rest untouched.

JSON diff vs plain text diff

A text diff answers "which lines differ". A JSON diff answers "which values differ". For JSON, the second question is almost always the one you meant to ask.

The same two documents, as each kind of tool reads them.
Situation	Structural JSON diff	Line-based text diff
Keys reordered	Not a difference — the data is the same	Every affected line reported as changed
Indentation changed	Not a difference	Reported as changes
Minified vs pretty-printed	Equal when the data is equal	Almost no line matches
A nested array element changed	The full JSON Path of that element	A line number, with no structural context
A value changed type	Reported and counted separately as a type change	Looks like an ordinary changed line

Key features

Recursive JSON diff — descends through objects and arrays and pinpoints every difference.
JSON Path for every change — each difference is reported as data.items[10].children[2].name, and clicking it jumps to the node.
Type-change detection — recognises changes such as number → string and counts them separately.
Order-sensitive or order-insensitive arrays — ignore array order to compare as a set, or keep it strict and have moved elements reported as moves.
Array pairing field — match records on id or any other key so one inserted element is a single addition, not a rewrite of the list.
Ignore rules — ignore key order, letter case, null, empty strings, empty arrays, empty objects, or any field you name.
Built-in JSON editor — line numbers, current-line highlight, syntax highlighting, error line and column, key/value search, scroll sync and cursor metrics.
URL decoding — detects and decodes multi-layer percent-encoding and will hand the result straight to the comparison.
Large files — parsing, formatting and diffing run in a Web Worker so the interface stays responsive.
Local history and favourites — stored in IndexedDB on your own machine, and available again after a reload.
Shareable links — the payload is compressed into the URL fragment, so a comparison can be shared without a server ever seeing it.

Common use cases

API responses. Compare the response you expected with the response you got, and see the exact path of every field that shifted — including the quiet ones, such as a number that became a string.
Configuration across environments. Diff development, staging and production config so the unexpected difference is obvious before a customer finds it.
package.json and lockfiles. See which dependencies a branch actually added, removed or bumped.
Translation files. Compare en.json with a locale file and find the missing keys instead of guessing at them.
Feature flags and remote config. Check what a rollout changed across your flag payloads.
Test fixtures and snapshots. When a snapshot test fails, compare expected and received directly rather than reading a diff produced elsewhere.
GeoJSON and data exports. Compare two exports from the same pipeline to confirm the data is stable between runs.
OpenAPI and JSON Schema documents. Review what a specification change means for the clients that consume it.

What "client-side" means here

Most JSON tools now describe themselves as private, so it is worth stating precisely what this one does and does not do.

No upload. There is no backend API. The site is a set of static files; nothing you paste is transmitted anywhere.
No account. There is no sign-up, no quota, and no server-side session to be logged.
Local storage only. History and favourites use IndexedDB and localStorage on your own machine, and you can clear them at any time.
Share links stay in the fragment. A shared comparison is compressed into the part of the URL after #, which browsers do not send to the server. Treat such a link as you would the underlying data, because anyone holding it can read it.
What is not claimed. The page is served over HTTP, so the hosting provider sees ordinary request logs — an IP address, a user agent, and the requested URL without its fragment. It never sees your JSON.

Frequently asked questions

Is my JSON uploaded to a server?

No. This is a static, client-side page with no backend API. Everything you paste stays in your browser memory, localStorage and IndexedDB.

How do I compare two JSON files?

Paste the original JSON into the left editor and the updated JSON into the right one, or drag a .json file onto either editor, then press Compare. The comparison runs locally in a Web Worker; no file is uploaded.

How large can the JSON files be?

Tens of thousands of lines and a few megabytes are handled smoothly in most browsers. For files above roughly 20 MB, turn off syntax highlighting and the Only changes filter for better performance.

Can I ignore fields such as timestamps?

Yes. Open More diff settings and list the field names to ignore, one per line, for example createdAt, updatedAt or id.

Does key order matter when comparing JSON?

No, not by default. Ignore key order is enabled out of the box, so two objects with the same keys in a different order compare as equal. Turn the option off if key order is meaningful in your data.

Can I compare two JSON arrays regardless of element order?

Yes. Turn off Array order matters and the arrays are compared as sets. For arrays of objects you can also name an array pairing field such as id, uuid or name, so elements are matched by that field and one inserted record is reported as a single addition instead of a removal plus an addition.

What is a type change, and why is it counted separately?

A type change is the same key holding a value of a different JSON type, for example 42 becoming "42", or null becoming 0. These are easy to miss in a line diff yet they break strict API clients, so they are detected and counted separately from ordinary value changes.

Can I compare a minified file with a pretty-printed one?

Yes. Both documents are parsed and normalised before comparison, so indentation, whitespace and line breaks never produce false differences. A minified file and a formatted file holding the same data compare as identical.

Does the tool work offline?

Yes. The page registers a service worker and precaches its own assets, so once it has been loaded it can be reopened and used without a network connection. Parsing and comparison never needed the network in the first place.

Is there a sign-up, a file limit or a paid tier?

No. There is no account, no quota and no paid tier. The tool is a set of static files, so there is nothing to meter and no server-side cost to pass on.

Does it tell me where my JSON is invalid?

Yes. When a document cannot be parsed, the editor reports the error together with the line and column of the first offending character, so you can fix it before comparing.

How do I share a comparison with someone else?

Press Share. The two documents and the active options are compressed into the URL fragment after the # character, which browsers never send to a server. Anyone with the link sees the identical comparison, so treat such a link exactly as you would the data itself.