JSON Diff Checker
Compare two JSON objects and see exactly what changed, path by path
About this tool
The JSON Diff Checker compares two JSON objects structurally and shows exactly what was added, removed, or changed — path by path, using JSONPath-style notation like $.user.email or $.items[2].price. Unlike a line-by-line text diff, it understands JSON structure: keys in a different order are treated as identical, and only real content differences are reported. Use it to compare API responses before and after a change, verify a config file migration didn't silently alter values, or review what a deploy actually changed in a serialized data blob. Each difference is color-coded — green for additions, red for removals, yellow for changes — with the exact old and new values shown inline. An Ignore array order option switches arrays from strict index-by-index comparison to an unordered multiset match — so re-sorting an array, or inserting an item in the middle, reports only the items that actually changed instead of cascading into every later index looking different. Everything runs 100% in your browser. Your JSON never leaves your machine — no server calls, no logging.
When to use it
- →Comparing an API response before and after a backend change to catch unintended field changes
- →Verifying a config file or feature flag migration didn't alter values it shouldn't have
- →Reviewing what changed between two versions of a serialized state object during debugging
- →Checking that a refactor produces byte-for-byte equivalent JSON output regardless of key order
- →Comparing a list-type field that got re-sorted without actually changing content, using Ignore array order
Tips
- ◆Key order never affects the result — only real value differences are reported, unlike a plain text diff.
- ◆By default, arrays are compared index by index, so inserting an item in the middle of an array shows every later item as 'changed' — turn on Ignore array order to compare by content instead of position when that's not what you want.
- ◆The path shown for each difference (e.g. $.user.roles[1]) can be pasted directly into a JSONPath-aware tool to locate the value.
- ◆Ignore array order treats duplicate values correctly as a multiset — [1,1,2] vs [1,2,2] reports one 1 removed and one 2 added, not a confusing full rewrite.
- ◆Click 'Export as JSON Patch' to get the same diff as an applyable RFC 6902 patch — useful when you need to actually send the change (e.g. as an HTTP PATCH body), not just review it.
Frequently asked questions
How is this different from a regular text diff tool?
A text diff (like ToolNinja's Diff Checker) compares JSON as plain text line by line — so reformatting, reordering keys, or changing whitespace shows up as a difference even when the data is identical. The JSON Diff Checker parses both inputs and compares the actual data structure, so key order and formatting never produce false positives — only genuine content differences are reported.
Why does reordering array items show as many changes instead of one?
By default, arrays are compared by position (index 0 vs index 0, index 1 vs index 1, and so on), not by content matching. If you insert or remove an item in the middle of an array, every item after that position appears as 'changed' even though most of them didn't really change — they just shifted position. Turn on Ignore array order to compare arrays as an unordered set of values instead, which reports only genuinely added or removed items regardless of position.
When should I use Ignore array order versus leaving it off?
Leave it off when array position is meaningful (an ordered list, a sequence of steps, a sorted result you want to confirm stayed sorted). Turn it on when an array represents an unordered collection (a set of tags, a list of IDs) where re-sorting or re-fetching in a different order shouldn't count as a real change.
What does the path notation like $.user.address[0].city mean?
It's JSONPath-style notation describing where in the JSON structure the difference occurs. $ is the root object, .user.address means the address property of the user object, and [0] means the first item in that array, followed by .city for the city property within it. It's the same notation used by JSONPath query tools.
Is my data uploaded anywhere when I use this tool?
No. Both JSON inputs are parsed and compared entirely in your browser using JavaScript. Nothing is sent to a server — this is safe to use with real API responses, even ones containing sensitive data.