JSON Diff Checker

How to Use

1. Paste your original JSONinto the left editor (JSON 1). This is the “before” version.
2. Paste your modified JSONinto the right editor (JSON 2). This is the “after” version.
3. Click Compare to run the deep comparison. The tool parses both inputs, builds the object trees, and recursively diffs every key and value.
4. Review the results in the diff tree below. Each difference is color-coded: green for additions, red for removals, and amber for changes. Each entry shows the full path and the old/new values.
5. Check the summary to see the total number of additions, deletions, and changes at a glance.
6. Click Load Example to see how it works with sample config objects, or Clear to reset everything.

Deep Comparison vs Shallow

There are two approaches to comparing objects: shallow comparison and deep comparison. Shallow comparison only looks at the top level of an object — it checks whether the same keys exist and whether their immediate values are equal. If a key’s value is a nested object, shallow comparison compares by reference, not by content. This means that two different objects with identical contents would be reported as different, because they are different references in memory.

Deep comparison, on the other hand, recursively traverses the entire object tree. When it encounters a nested object or array, it doesn’t stop at the reference — it goes inside and compares every key and value within that nested structure. This ensures that changes deep within a JSON document are always detected, regardless of how many levels of nesting they are buried under. For example, if you have a configuration object like { server: { port: 3000 } } and the port changes to 8080, deep comparison will find it at the path server.port.

DevToolsHub’s JSON Diff Checker uses deep comparison exclusively. Every difference, no matter how deeply nested, is reported with its full path from the root of the JSON object. This makes it easy to locate exactly where changes occurred, even in large, complex JSON structures with many levels of nesting. Arrays are compared element by element using indices, so changes to individual array elements (and elements of arrays within arrays) are always detected.

Common Use Cases

• API response comparison— Compare two versions of an API response to see what fields changed. Useful when debugging why a frontend breaks after an API update.
• Configuration file changes— Diff an old config against a new one to verify that only intended settings changed and nothing was accidentally added or removed.
• Database document versioning— Compare two versions of a JSON document stored in a NoSQL database (like MongoDB) to track what fields were modified between revisions.
• CI/CD pipeline validation— Compare the JSON output of a build step against a known-good baseline to catch regressions automatically.
• Debugging state changes— Compare the before/after state objects in a Redux or Zustand store to understand exactly what a user action changed.
• Contract testing— Verify that an API response matches the expected schema by diffing the actual response against the expected template.
• Translation file sync— Compare two locale JSON files to find missing or extra keys that need translation.
• Data migration verification— After migrating data from one format to another, diff the before and after JSON to confirm no data was lost or corrupted.