JSON Diff — Compare JSON Online

Q: How does this JSON compare tool work?

Paste your original JSON on the left and the changed JSON on the right. The tool parses both and walks the structures key by key and item by item, listing every difference as an added, removed, or changed entry with its exact path (for example $.user.address.city). You also get a running count of additions, removals, and changes so you can see the scale of the difference at a glance.

Q: Is the comparison order-sensitive?

For objects, no — keys are matched by name, so {"a":1,"b":2} and {"b":2,"a":1} are treated as identical. That's correct JSON semantics: object key order is not meaningful. Arrays, however, are compared by position, because order usually is meaningful in a list. If two arrays contain the same items in a different order, that shows up as changes at the positions that differ.

Q: What is a 'type change' and why is it flagged?

A type change is when the value at a given path switched from one JSON type to another — for example the number 42 becoming the string "42", or a value becoming null. These are highlighted separately because they're a common and easily-missed source of bugs: code that expected a number may break when it suddenly receives a string, even though the two look similar.

Q: Can I compare formatted (pretty-printed) against minified JSON?

Yes. Whitespace and indentation are irrelevant — the tool compares the parsed data, not the text. A minified document and its pretty-printed equivalent will report zero differences, which makes this a reliable way to confirm that a reformat or minify didn't accidentally change any values.

Q: What if one side isn't valid JSON?

Each side is validated independently, and if either is invalid you'll see an error pointing to the side and the line and column where parsing failed, so you can fix it before comparing. Both sides must be valid JSON for a diff to be produced.

Q: Is my data sent to a server?

No. Both documents are parsed and compared entirely in your browser with JavaScript. Nothing is uploaded, so you can safely compare API responses or config files that contain sensitive values. You can copy the diff as text for a commit message, bug report, or code review.

Compare two JSON documents online and see exactly what changed. Added, removed and changed values with their paths, order-insensitive for objects. Runs in your browser.

Original (left)

Changed (right)

All comparison happens locally in your browser. No data is sent to any server. Your JSON stays completely private.

What It Does

This tool compares two JSON documents and tells you precisely how they differ. Instead of eyeballing two blobs of text or trusting a plain character diff — which drowns you in noise the moment indentation or key order changes — it compares the actual data. It parses both sides and walks them structurally: object keys are matched by name (so reordering keys is correctly treated as no change), and array items are matched by position. Every difference is reported as an addition, a removal, or a change, each with the exact path where it happened and a running count of how many of each there are. Values that changed type — a number becoming a string, or anything becoming null — are called out separately, because those are the differences most likely to break code downstream. Because it works on parsed data, comparing a minified file against its pretty-printed version correctly reports no differences at all.

When to Use It

You changed a config or API payload and need to confirm exactly which fields moved, and that nothing else did.
Two environments (staging vs production) return different JSON and you need to pinpoint the divergence.
A code review or bug report needs a clear, path-by-path list of what changed between two responses.
You reformatted or minified a file and want to verify the values are untouched — a structural diff should show zero changes.

Worked Examples

Change + add + remove a field

replicas changed (2 → 3), region was added, and active was removed — three differences, each shown with its path.

Same keys, different order

Same keys in a different order. Because object comparison is order-insensitive, this reports zero differences — exactly what a character diff would get wrong.

A type change and an array edit

id changed type (number 42 → string "42"), flagged separately, and the array item at position 1 changed (y → z).

Features

Structural comparison of two JSON documents

Added

removed and changed entries with exact paths

Running counts of each change type

Order-insensitive object comparison

Position-based array comparison

Type-change detection and highlighting

Ignores whitespace and key order

Independent validation of each side with line and column errors

Swap sides in one click

Copy the diff as text

Browser-only processing with no server uploads

How to Use

1. Paste the original JSON on the left and the changed JSON on the right. 2. The differences appear instantly, grouped into added, removed and changed with their paths. 3. Review the counts and any flagged type changes. 4. Use Swap to reverse the comparison, or Copy to copy the diff as text.

Common Mistakes

Using a plain text/character diff for JSON. Reindenting or reordering keys produces a wall of false differences; a structural diff ignores formatting and key order.
Assuming arrays are compared like sets. Arrays are matched by position, so the same items in a different order will show as changes — reorder or sort first if order isn't meaningful to you.
Overlooking type changes. A number that became a string looks almost identical but can break consumers; check the flagged type changes specifically.
Comparing when one side is invalid. Both documents must parse — fix any reported syntax error first, or you're comparing against nothing.

Frequently Asked Questions

How does this JSON compare tool work?

Is the comparison order-sensitive?

What is a 'type change' and why is it flagged?

Can I compare formatted (pretty-printed) against minified JSON?

What if one side isn't valid JSON?

Is my data sent to a server?