JSON tools

JSON diff— See what changed in the data

Paste both JSON documents. Results update after you stop typing; turn off automatic comparison to run it manually.

Automatic comparison

Array comparison

Ignored pathsOne JSON Pointer per line, e.g. /updatedAt. No wildcards.

+ Added: 2− Removed: 1Changed: 7

Updated

1 / 10

Sync scrollingFold unchanged lines

Read-only display: formatting and record order are aligned using your comparison rules. Ignored paths are hidden; originals stay unchanged.

− Original JSON/users/0/id

+ Updated JSON/users/0/id

Loading comparison…

{
  "users": [
    {
      "id": 1,
      "name": "Ada",
      "role": "reader"
    },
    {
      "id": 2,
      "name": "Lin",
      "role": "editor"
    }
  ],
  "version": 1,
  "updatedAt": "2026-09-01"
}

{
  "users": [
    {
      "id": 2,
      "name": "Lin",
      "role": "admin"
    },
    {
      "id": 1,
      "name": "Ada",
      "role": "reader"
    },
    {
      "id": 3,
      "name": "Sam",
      "role": "reader"
    }
  ],
  "updatedAt": "2026-09-10",
  "active": true
}

Your inputs stay in this browser tab. No upload or persistent storage.

Structure details (10)

Root
- users
  - 0
    Changed
    Original JSON /users/0/id
    1
    Updated JSON /users/0/id
    2
    Changed
    Original JSON /users/0/name
    "Ada"
    Updated JSON /users/0/name
    "Lin"
    Changed
    Original JSON /users/0/role
    "reader"
    Updated JSON /users/0/role
    "admin"
  - 1
    Changed
    Original JSON /users/1/id
    2
    Updated JSON /users/1/id
    1
    Changed
    Original JSON /users/1/name
    "Lin"
    Updated JSON /users/1/name
    "Ada"
    Changed
    Original JSON /users/1/role
    "editor"
    Updated JSON /users/1/role
    "reader"
  - Added
    Original JSON
    Missing
    Updated JSON /users/2
    {"id":3,"name":"Sam","role":"reader"}
- Removed
  Original JSON /version
  1
  Updated JSON
  Missing
- Changed
  Original JSON /updatedAt
  "2026-09-01"
  Updated JSON /updatedAt
  "2026-09-10"
- Added
  Original JSON
  Missing
  Updated JSON /active
  true

An API response can look completely different after a formatter runs, even when no data changed. JSON compare should help you find the changed field, not make you review every line again. A JSON diff should point at that field, not at the reformatting around it.

Use this JSON difference checker to compare JSON files copied from fixtures or configuration snapshots. Start with the sample, switch to ID matching, and watch array reorder noise disappear. The JSON diff then lists only the values that actually moved.

Find meaningful changes in JSON

Match records even when their order changes

API responses often return the same records in a new order. When every object has a unique id, key matching aligns those records before comparing their fields. A changed permission remains visible without treating a reordered list as a series of unrelated edits. Use position mode when the sequence itself matters.

Matching identity shapes connect reordered record cards; one changed field is highlighted in amber.

Leave volatile fields out of the review

A fresh updatedAt value can distract from the configuration change you need to review. Exclude /updatedAt to skip that field and its descendants while keeping other differences visible. Exclusions use exact JSON Pointer paths, so choose the specific branch you intend to ignore.

Two data trees show faded timestamp fields and one highlighted change on a different branch.

Review a comparison in three steps

Add the original and updated data

Paste valid JSON into both editors, or load the example to explore the result tree. Automatic comparison updates the result after you pause typing.

Choose how records are matched

Keep position mode for ordered lists, or choose key mode and enter a unique property such as id. Add one exact path per line to exclude fields such as /updatedAt.

Inspect and save the differences

Switch to View comparison to see deletions in red and additions in green. Navigate between changes or expand Structure details for original paths, then copy or download the report.

Review changes by structure

Nested difference tree

Expand the affected branches to inspect old and new values. Each change carries a JSON Pointer; matched array records retain separate paths for the original and updated documents.

Choose what identifies a record

Position mode compares index 0 with index 0. Key mode pairs array objects using one direct property such as id, so reordering records alone does not count as an edit.

A report you can inspect later

Copy or download additions, removals, changes and the comparison options as JSON. Value snapshots are JSON source strings, preserving large numbers for downstream readers.

Comparison rules and limits

Strict input, exact values: Comments, trailing commas and duplicate object keys stop comparison. Strings stay distinct from numbers; null stays distinct from a missing field. Equivalent numeric spellings such as 1 and 1.0 compare equal without rounding.
Key matching has a contract: The selected property must be a unique string or number on every object in each compared array. Mixed object/primitive arrays fail in key mode; arrays without objects still compare by position. Numeric 1 and string "1" are different identities.
Ignore a path and its descendants: Enter one exact JSON Pointer per line, for example /updatedAt. Escape / as ~1 and ~ as ~0. No wildcards or JSONPath. In key mode, a match on either the original or updated index suppresses that paired branch.
Counts describe changed branches: Adding or removing a whole subtree counts once; replacing a type counts once. No move operations are emitted. The export is a review report, not an executable RFC 6902 patch. With a deeper path exclusion, added or removed containers are expanded so excluded children are skipped.
Bounded browser workload: Each input allows 500,000 UTF-16 code units, 50,000 nodes and depth 100; numeric tokens allow 1,000 characters. Over 5,000 changes stops comparison without a partial report. The tree shows 100 changes at a time; export includes all.

JSON diff FAQ

Can object keys appear in a different order?

Yes. Object key order and whitespace outside strings are ignored. Whitespace inside a string remains meaningful.

Can I match array objects despite reordering?

Select key mode and enter a unique property, usually id. This aligns object records; primitive arrays still use positions. Missing or duplicate identities produce an error.

How do I locate a nested change?

Expand the tree and follow its JSON Pointer. For a reordered record, the original and updated paths are both printed beside the corresponding values.

Are nested arrays supported?

Yes, including objects inside arrays and arrays inside objects, up to the documented depth and node limits. Array matching applies recursively.

Does comparison upload my input?

No upload is required. Copy and download are explicit actions; the page provides no account, saved comparison history or shareable payload URL.

Found a comparison case that looks wrong?

Run a JSON diff on both documents

Load the sample, switch to ID matching, and the JSON diff drops the array reordering noise.

Compare