JSON Diff Checker Free
Compare two JSON objects side by side. Instantly highlights keys that are added, removed, or changed between versions. Flatten paths for deep comparison. Runs entirely in your browser — no data uploaded.
JSON A (original)
JSON B (modified)
Diff Result
0 added 0 removed 0 changedPro — diff history, file upload, export patch, semantic diff, API access
API access · Priority queue · Team workspace
How It Works
Paste Both JSON Objects
Paste your original JSON into the left panel (JSON A) and the modified version into the right panel (JSON B). Click Load Sample to see a pre-loaded example showing a user profile before and after an update — with a changed age, a new city field, and a removed field — to understand the color coding before using your own data.
Set Options & Compare
Choose whether to ignore array order (arrays with the same elements in different order are treated as equal), enable deep path view to show all differences using dot-notation paths, and hide unchanged keys to focus only on what changed. Click Compare to run the diff instantly — no server round-trip required.
Review Color-Coded Result
Green rows with a + prefix are keys added in JSON B. Red rows with a − prefix are keys that exist in JSON A but are missing from JSON B. Orange rows with a ~ prefix show values that changed, displaying both the old value and the new value. The summary bar shows total counts. Copy the diff report to share with teammates.
JSON Diff Features
Deep structural comparison with readable color-coded output
Color-Coded Diff
Every difference is color-coded for instant visual scanning. Green highlights additions, red highlights removals, and orange highlights changed values. Unchanged keys are shown dimmed. The color scheme matches the convention used by git diff, making the output immediately familiar to developers reviewing version-controlled JSON config files, API responses, or database snapshots.
Deep Structural Diff
The diff recurses into nested objects to find exactly which leaf values changed — not just which top-level key changed. If user.address.city changes from "NYC" to "London", that exact path and both values are shown in the result. This saves time manually tracing changes through deeply nested structures like API responses or configuration hierarchies.
Array Order Tolerance
The "Ignore array order" option compares arrays as sets — two arrays with the same elements in different order are treated as equal. This prevents false positives when comparing JSON from APIs that don't guarantee ordering of list results. Disable this option when order matters, such as comparing ordered query results or step-by-step instructions where sequence is significant.
Hide Unchanged Keys
For large JSON objects with many keys, the "Hide unchanged keys" option filters the diff to show only additions, removals, and changed values. This focuses your attention on what actually changed without scrolling past rows of identical data. Especially useful when comparing full API response objects where only a few fields change between requests or versions.
Change Summary
The summary bar above the diff result shows exact counts of added, removed, and changed keys at a glance. This lets you quickly gauge the scale of differences before reviewing each individual change. If all three counters are zero, the two JSON objects are structurally identical (ignoring key order at the object level, which JSON does not define as significant).
100% Private
Both JSON payloads are compared entirely in your browser using JavaScript — nothing is sent to a server. This makes it safe to compare JSON containing authentication tokens, database connection strings, user PII, financial records, or any other sensitive data you cannot transmit externally. Monitor the browser Network tab to confirm zero requests are made during comparison.
Free vs Pro
| Feature | Free | Pro |
|---|---|---|
| JSON input size | Unlimited | Unlimited |
| Deep structural diff | ||
| Diff history & saved comparisons | — | |
| Export JSON Patch (RFC 6902) | — | |
| File upload diff | — | |
| REST API access | — |
Frequently Asked Questions
No — JSON objects are unordered by specification. Two objects with the same key-value pairs in different order are considered identical by this diff tool. Only values matter, not the order keys appear in the source text. If you need to detect key order differences for readability reasons, use a text diff tool instead, which compares line by line without parsing the JSON structure.
When enabled, arrays are compared as unordered sets — two arrays are equal if they contain the same primitive values regardless of order. For example, ["a","b","c"] and ["c","a","b"] would be considered identical. This is useful for API responses where tag lists or ID arrays may come back in different orders. When disabled, arrays are compared element-by-element at each index position.
Yes — paste any valid JSON in both panels, including arrays at the root level. The diff tool recursively compares any structure. If both inputs are arrays, each index position is compared as a key (0, 1, 2…). If the array items are objects, their keys are compared recursively at that index. For unordered comparison of root-level arrays, enable the "Ignore array order" option.
Deep path view shows all differences using their full dot-notation path rather than grouped by nesting level. For example, instead of showing a changed address object, it shows the specific leaf that changed: address.city: "NYC" → "London". This gives you an exact, flat list of every leaf-level change, which is easier to scan and share in bug reports or pull request comments.
A JSON Patch (RFC 6902) is a machine-readable list of add, remove, and replace operations that transforms JSON A into JSON B. It is the JSON equivalent of a unified diff. The free diff tool shows a human-readable color-coded diff. Pro users can export the result as a JSON Patch file that can be programmatically applied to JSON documents using any RFC 6902-compliant library.
No — both JSON inputs are compared entirely in your browser using JavaScript. No data is transmitted to any server. This is especially important for JSON diff use cases, which often involve comparing sensitive data like configuration files with secrets, API responses with user PII, or database snapshots with financial records. Your data never leaves your device.