Question 1

How is JSON Diff different from a regular text Diff?

Accepted Answer

A text diff like Unix diff or our Diff Checker compares two files line by line. If your two JSON files have the same keys but different whitespace, different key order, or different indentation, a text diff reports them as completely different. JSON Diff compares the parsed VALUE trees — it sees {a:1,b:2} and {b:2,a:1} as identical because the data is the same. Use text diff for prose, code, and arbitrary text; use JSON Diff for structured data where you care about the actual values, not the surface formatting.

Question 2

What does the path syntax mean?

Accepted Answer

Each change record carries a dot-and-bracket path locating the change in the JSON tree. user.settings.theme means: the top-level "user" object's "settings" object's "theme" key. items[3].sku means: the 4th element (zero-indexed) of the "items" array, then its "sku" key. The path mirrors JavaScript / jq syntax so you can use it directly in code: data.user.settings.theme, data.items[3].sku. Empty path "$" means the document root itself differs (e.g. one input was an object, the other was an array).

Question 3

How are arrays compared?

Accepted Answer

By INDEX. items[0] in left compares to items[0] in right, items[1] to items[1], and so on. If the right array is longer, extra elements show as "added". If left is longer, extras show as "removed". This is intentionally simplistic — it does NOT detect that an element was "moved" within the array (insertion at position 0 shifts everything else). For move-aware array comparison, more complex algorithms like Longest Common Subsequence (LCS) are needed; those are out of scope for this lightweight tool. For most config files and API payloads, index-based comparison is what you want.

Question 4

Are types compared strictly?

Accepted Answer

Yes. The number 1 does NOT equal the string "1"; null does NOT equal undefined or the empty string. true does NOT equal 1. JSON.parse preserves all types correctly, and the diff respects them. This is correct behavior for API debugging — if a field changed from number to string, you want to KNOW about it (likely a deserialization bug). If you need lenient type comparison (1 ≈ "1"), pre-normalize both inputs before diffing.

Question 5

What happens with nested objects?

Accepted Answer

They recurse. If both sides have user.settings as an object, we walk INTO it and diff its keys. If left has user.settings as an object but right has it as a string, the entire user.settings is one "changed" record (no recursion across type boundaries). For each leaf-level difference, you get a single change record. Same path may appear once with kind=changed (different scalar values) or multiple times (one per changed sub-key in an object).

Question 6

Why is "Hide unchanged" on by default?

Accepted Answer

For typical API debugging, you want to see WHAT CHANGED — not be drowned in identical keys. Most production APIs have dozens of fields, only a few of which actually differ between two responses. Hiding unchanged records is the default; toggle off to see the complete diff including unchanged keys (useful for verifying coverage during code review or auditing).

Question 7

Can I diff two huge JSON files?

Accepted Answer

For files up to a few megabytes (hundreds of thousands of records), the in-memory diff runs in well under a second on modern browsers. JavaScript object traversal is fast for typical API payloads. For multi-gigabyte data dumps, browser-side tools are not the right answer — use a streaming JSON differ in Node.js, Python (jsondiff), or a CLI tool (jq paired with diff). This tool is optimized for the common case: API responses, config files, snapshot tests.

Question 8

Is this JSON Diff tool free?

Accepted Answer

Yes. It is 100% free with no signup and no usage cap. The comparison runs entirely in your browser using native JSON.parse, so there is no server cost to pass on. Paste two JSON documents, see the path-indexed differences, and export a plain-text patch — all without an account.

Question 9

Why do two formatted-identical JSON files show one "unchanged" record instead of zero changes?

Accepted Answer

Because the algorithm short-circuits at the root. When both parsed trees are deeply equal, the diff pushes a single record at path "$" with kind=unchanged and stops recursing — it does not walk every key. So reformatting JSON (minified vs pretty, reordered keys) yields exactly one unchanged record, which the "Hide unchanged" filter then suppresses, leaving an empty diff. That empty result IS the "they are the same" answer.

Question 10

Is my JSON sent to any server?

Accepted Answer

No. The parser uses native JSON.parse; the diff algorithm walks the resulting JavaScript objects in memory. No fetch, no XHR, no analytics event with JSON content. Verify in DevTools → Network. API payloads often contain auth tokens, customer IDs, or sensitive content; this tool keeps everything on your device.

Context	Why JSON Diff Helps
API response debugging	Compare two API responses across versions or environments to see exactly which fields changed.
Config drift detection	Diff staging-vs-production config files (or two regions) to spot the unintended differences before deploy.
Snapshot test review	When a Jest snapshot test fails, paste old vs new JSON to see precisely what shifted.
Schema migration validation	After running a migration, diff a sample document before and after to verify only the intended fields changed.
GraphQL response comparison	Compare two GraphQL responses with different query selections to validate field-level data.
Webhook payload investigation	Diff two webhook payloads (e.g. before/after a status change) to identify the trigger field.

Aspect	Text Diff (Diff Checker)	JSON Diff (this tool)
Comparison unit	Lines (or characters within lines)	Keys, values, array indices at any depth
Whitespace impact	Different whitespace = different lines = noise	Ignored entirely — pretty vs minified compare equal
Key order	{a:1,b:2} differs from {b:2,a:1}	Same — semantic equality
Path readability	Just a line number	user.settings.theme (clear data-model path)
Output format	Two side-by-side text panes or unified ±	Path-indexed list of change records
Best for	Prose, code, plain text, logs	Structured data, API payloads, configs

JSON Diff — Compare Two JSON Objects Online, Free

Semantic Comparison

Path-Indexed Changes

Added / Removed / Changed

100% Client-Side

JSON Diff: compare two JSON objects by key, not by line

How to compare two JSON files

What is a semantic JSON diff and how does it work?

Worked examples: input → diff

Six Real-World Uses for JSON Diff

Text Diff vs JSON Diff — Pick the Right Tool

Four JSON Diff Gotchas Worth Knowing

The root short-circuit most diff tools never explain

Runs 100% in your browser

Related JSON & data utilities

Need a different tool?