JSON Diff — Compare Two JSON Objects Online

A JSON diff compares two JSON documents and produces a categorized report of every difference between them. The algorithm recursively traverses both documents in parallel, comparing values at each key path. At every node it can find one of four conditions:

• Added — a key exists in JSON B but not in JSON A (highlighted green)
• Removed — a key exists in JSON A but not in JSON B (highlighted red)
• Changed — a key exists in both but the values differ (highlighted amber, showing old → new)
• Unchanged — a key exists in both with identical values (can be hidden to focus on changes)

For nested structures, the diff recurses into objects and reports differences at the leaf level using full dot-notation key paths (e.g., user.address.city). Array differences use bracket notation for indices (e.g., items[0].price). Type changes — where the same key holds a string in one document and a number in another — are reported as changed values with both the old and new types shown. A summary count at the top of the results shows how many additions, removals, and changes were found at a glance.

A developer updates a user profile API and needs to document exactly what changed between v1 and v2 of the response schema. They paste v1 into JSON A:

{
  "id": 42,
  "name": "Alice",
  "role": "user",
  "legacy_id": "USR-042"
}

And v2 into JSON B:

{
  "id": 42,
  "name": "Alice",
  "role": "admin",
  "created_at": "2024-01-15"
}

The diff shows three changes immediately: role changed from "user" to "admin", legacy_id was removed, and created_at was added. The two unchanged fields — id and name — can be toggled off to focus only on what changed. The diff output becomes a precise, reviewable changelog that can be included in API documentation, a pull request description, or a migration guide for API consumers.

Deep vs. shallow comparison:This tool performs a full recursive diff — it inspects every level of nesting, not just top-level keys. A shallow comparison would flag an entire nested object as “changed” even if only one leaf field differed; a deep diff reports exactly which leaf field changed and what the old and new values were. This precision is essential when working with complex API responses or configuration objects.

Array ordering: Arrays are compared by index position, not by value identity. If two arrays contain the same items in a different order, the diff reports each element at the same index as changed. This is semantically correct for ordered data like paginated results, but may be surprising for unordered sets like permission lists or tag arrays. If order should not matter for a comparison, sort the arrays in both documents before diffing.

Common use cases: Comparing API response schemas across versions to document breaking changes; reviewing configuration differences between environments (dev, staging, production); debugging state mutations in front-end applications; validating that a data migration preserved all fields correctly; auditing changes to feature flag definitions or permission structures in access control configs; spotting unintended changes in test fixtures after a code update.