JSON Diff — Compare Two JSON Objects Online

How the Diff Engine Works

A text diff of two JSON files answers the wrong question. Re-indent a payload, sort its keys, or let a serialiser emit them in a different order and a line-based tool reports dozens of changes even though the data is identical. This tool parses both sides first with JSON.parse and compares the resulting values, so formatting, whitespace and key order carry no meaning at all — only structure and values do.

The comparison is a single recursive walk over both trees at once, and which branch it takes depends on what it finds at the current position:

• Two objects. It takes the union of the keys on both sides. A key only in A is reported as removed, a key only in B as added, and a key in both is followed one level deeper.
• Two arrays. It walks positions 0 to the longer array's last index. Positions present in both are compared recursively; the surplus tail of the longer array is reported as added or removed.
• Anything else. Two scalars, or a type mismatch such as an object on one side and a string on the other, are compared as whole values and reported as a single change if they differ.

The output is therefore a flat list of leaf paths rather than a nested tree. That is deliberate: a list can be scanned, counted and pasted into a ticket, and the summary tag gives you the added, removed and changed totals at a glance. When the two documents match, nothing is printed and the tool says so explicitly instead of showing an empty result.

Path Notation

Each reported path is a directly usable address into the document, built the same way you would write the accessor in JavaScript.

Where a Structural Diff Has Limits

Arrays are compared strictly by position, because JSON arrays are ordered and the tool has no way to know which element is meant to correspond to which. Insert one item at the front of a hundred-element list and every following index shifts, so the diff reports ninety-nine changes plus one addition rather than the single insertion you performed. That result is correct — position [7] really does hold a different value now — but it is not the summary you wanted. When element identity matters more than order, compare the arrays keyed by their id field instead, or sort both sides consistently before pasting them in.

Two other behaviours follow from parsing rather than from the diff itself. If a document contains the same key twice, JSON.parse keeps only the last occurrence, so a duplicate-key bug is invisible here. And numbers are compared after parsing, so 1, 1.0 and 1e0 are all the same value, while the string "1" is never equal to the number 1.

Diff Types

Examples

{
  "name": "Alice",
  "age": 30,
  "city": "Boston"
}

{
  "name": "Alice",
  "age": 31,
  "city": "New York"
}

{
  "user": {
    "name": "Bob",
    "role": "admin"
  },
  "active": true
}

{
  "user": {
    "name": "Bob",
    "role": "editor"
  },
  "active": true,
  "theme": "dark"
}

Use Cases

Related Tools