What is the difference between a JSON diff and a text diff?

A text diff compares the two documents line by line, so it flags reordered keys, changed indentation, or re-serialised whitespace as differences even when the data is identical. A JSON diff parses both sides first, then compares the actual values by key and index — so it reports only real semantic changes and ignores formatting and key order.

How do I compare two JSON files online?

Paste the original JSON into box A and the changed JSON into box B. The diff appears instantly: a summary of added, removed, and changed counts, a colour-coded tree labelled with JSON Pointer paths, a flat path list, and an RFC 6902 JSON Patch you can copy. There is no upload button because nothing is sent to a server.

Does key order matter when comparing JSON objects?

No. RFC 8259 §4 defines a JSON object as an unordered collection of name/value pairs, so this tool matches keys by name, never by position. Swapping the order of two keys with the same values produces zero differences. Arrays, by contrast, are ordered — elements are compared by index.

Are 1 and 1.0 treated as equal in JSON?

Yes. A JSON number denotes a mathematical value (RFC 8259 §6), so 1, 1.0, and 1e0 all mean the same number and compare equal here. A number and a string, however — like 100 versus "100" — are different JSON types, so the tool flags that as a type change.

Is my JSON data sent to a server when I use this tool?

No. All parsing and comparison run in your browser with JavaScript. Your JSON is never uploaded, logged, or stored anywhere. That is why it is safe to paste API responses, config files, or database dumps that may contain sensitive data.

How are arrays compared?

Version 1 compares arrays positionally: element 0 against element 0, element 1 against element 1, and so on. If the changed array is longer, the extra trailing elements are marked added; if shorter, the extra originals are marked removed. Reordering an array therefore shows as changes rather than moves — keyed/longest-common-subsequence matching is planned for a later version.

What is the JSON Patch output for?

The JSON Patch panel gives you a valid RFC 6902 array of add, remove, and replace operations that transforms document A into document B. You can copy it into code, a test fixture, or any RFC 6902 library to apply the same change programmatically. This tool emits patches but does not apply arbitrary ones.

Does it accept JSON5, comments, or trailing commas?

No. Inputs must be strict RFC 8259 / ECMA-404 JSON. Comments, trailing commas, single quotes, and unquoted keys are rejected with a clear parse error showing the line and column, so the comparison stays unambiguous and standards-based.

What happens if one side is invalid JSON?

The tool never shows a misleading partial diff. The invalid side is highlighted and its parser error — including the line and column where parsing failed — is displayed beneath the box. Fix it and the diff appears automatically.

Developer · JSON

JSON Diff Checker — compare two JSON documents

Paste two JSON documents and see only the real changes — every added, removed, and changed value by path, ignoring key order and formatting. You also get a copyable RFC 6902 JSON Patch. It runs entirely in your browser, so nothing is uploaded.

By Induwara Ashinsana— Executive Director, Ryzera TechnologiesUpdated Jul 8, 2026

Compare two JSON documents

JSON A — original

Paste or type strict JSON.

JSON B — changed

Paste or type strict JSON.

Actions

Added

—

Removed

—

Changed

—

Status

—

Paste JSON into both boxes to see a structural, key-aware diff — every added, removed, and changed value with its JSON Pointer path, plus a ready-to-copy JSON Patch. Click Load sample to try it.

Runs entirely in your browser — nothing is uploaded, logged, or stored. Objects are compared key-set-wise (key order ignored, per RFC 8259 §4); numbers compare by value, so 1, 1.0 and 1e0 are equal. Arrays are compared positionally. Strict JSON only (no comments or trailing commas). Maximum 2,000,000 characters per side.

How it works

A line-based diff treats JSON as plain text, so it flags a reordered key or a change in indentation as a difference even when the data is identical. This tool does a structural comparison instead: it parses both documents into values and compares those values, so only genuine semantic changes are reported. The method is deterministic — the same two inputs always produce the same result.

Parse. Both sides are parsed against the strict JSON grammar defined by RFC 8259 and ECMA-404. If either fails, the exact parser error with its line and column is shown and no diff is produced — you never see a misleading partial comparison.
Compare recursively. Two objects are compared by the union of their keys: a key only in A is removed, only in B is added, and in both is compared recursively. Because RFC 8259 §4 defines an object as an unordered collection of name/value pairs, key order is never itself a difference. Two arrays are compared element by element by index (positional); trailing extras in B are added and trailing extras in A are removed. Two primitives are equal only when they share a JSON type and value.
Handle numbers and types. A JSON number denotes a value (RFC 8259 §6), so 1, 1.0, and 1e0 compare equal. A value whose JSON type changes — a number becoming a string, or an object becoming an array — is reported as a type change rather than a silent value change.
Label every change. Each difference carries its JSON Pointer (RFC 6901), built segment by segment, escaping ~ as ~0 and / as ~1 inside keys — for example /user/roles/1.
Emit a patch. Each change maps to an RFC 6902 operation: added → add, removed → remove, changed → replace. Array removals are ordered highest-index-first so the patch applies cleanly in sequence.

To prove the result is correct, the tool cross-checks itself: it applies the patch it just produced back to document A and confirms the outcome equals document B, value for value. The Verified · patch round-trips badge turns green only when that independent second computation succeeds — the same idea as double-entry verification.

Worked examples

Flat object — add, remove, and change

A — original

{"name":"Nimal","age":30,"city":"Colombo"}

B — changed

{"name":"Nimal","age":31,"country":"Sri Lanka"}

/name — unchanged ("Nimal" equals "Nimal")
/age — changed 30 → 31
/city — removed (only in A)
/country — added (only in B)
Counts: added 1, removed 1, changed 1
Patch: [replace /age 31, add /country "Sri Lanka", remove /city]

Nested object and array element

A — original

{"user":{"id":1,"roles":["admin","editor"]},"active":true}

B — changed

{"user":{"id":1,"roles":["admin","viewer"]},"active":true}

Recurse into /user — id equal (1 == 1)
Recurse into /user/roles — index 0 equal ("admin")
/user/roles/1 — changed "editor" → "viewer"
/active — unchanged (true == true)
Counts: added 0, removed 0, changed 1
Patch: [replace /user/roles/1 "viewer"]

Type change, number equivalence, array growth

A — original

{"price":100,"discount":1.0,"tags":["a"]}

B — changed

{"price":"100","discount":1,"tags":["a","b"]}

/price — changed 100 (number) → "100" (string): type change
/discount — unchanged (1.0 and 1 denote the same number)
/tags/0 — unchanged ("a")
/tags/1 — added "b" (array grew from length 1 to 2)
Counts: added 1, removed 0, changed 1
Patch: [replace /price "100", add /tags/1 "b"]

Frequently asked questions

Sources & references

The comparison rules and pointer/patch formats on this page were last cross-checked against these standards on 2026-07-08. Every diff is additionally self-verified at runtime by round-tripping its patch.

Related tools

LiveDeveloper

YAML ⇄ JSON Converter

Convert YAML to JSON and JSON to YAML entirely in your browser. Auto-detects direction, expands anchors/aliases and merge keys, handles multi-document streams, locates parse errors by line, and verifies each conversion with a round-trip check. No upload, no signup.

Open tool

LiveDeveloper

TOML ⇄ JSON Converter

Convert TOML to JSON and JSON to TOML in your browser with validation, type-mapping notes, and a round-trip integrity check, per the TOML v1.0.0 spec.

Open tool

LiveDeveloper

XML to JSON Converter

Convert XML to clean, well-formed JSON instantly and entirely in your browser. Handles attributes (configurable prefix), nested elements, repeated elements collapsed to arrays, CDATA, and a configurable text-node key. Locates well-formedness errors by line and column, and verifies every conversion with a JSON round-trip. No upload, no signup.

Open tool

Rate this tool

Be the first to rate

Comments & feedback

Spotted a bug or want an improvement? Tell us — our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] — most fixes ship within 24 hours.