A private JSON diff checker
DiffBunker's JSON diff checker compares two documents by their parsed structure, not their text. Reordered keys, changed indentation and pretty-printing are ignored — you see only the values that were added, removed or changed, in a collapsible tree. Every comparison runs in your browser; nothing you paste is uploaded, and you can confirm that in the Network tab.
Both inputs are parsed as JSON and compared by structure, so reordered keys and reformatted whitespace never count as changes.
What "semantic" means here
A regular diff tool treats a JSON file as a block of text. That makes it report differences that are not really there: if one side has been run through a formatter, or its keys have been sorted alphabetically, or it uses tabs where the other uses spaces, a text diff fills up with noise and the one value you actually care about is buried in it. This tool parses both inputs into JSON values first and compares those values. Whitespace and key order do not survive parsing, so they cannot show up as changes. What is reported is structural: a different value at a path, a key that was added or removed, an array element that appeared or moved.
Ignore key order and ignore array order, with an example
Take an object that changed from{"qty": 3, "price": 12.00}to{"price": 12.50, "qty": 3}. The keys have been swapped around and the price went up. With "Ignore key order" on — the default — the swap is invisible and the only thing reported ispricechanging from 12 to 12.5. Arrays are different. Compared as text or in the default mode,["read", "write", "admin"]versus["admin", "read", "write"]reports that "admin" moved to the front. Turn "Ignore array order" on and each array becomes an unordered bag of values, so those two are equivalent and nothing is reported. Key order is always meaningless in JSON; array order sometimes matters, so the two are separate switches.
The tree view, and what it deliberately does not do
Results are shown as a collapsible tree that follows the shape of your data. Each changed node carries a path breadcrumb — something like$.customer.address.cityor$.items[2].price— so you can see exactly where in the document the change is. Additions are green, removals red, changed values amber, and moved or reordered nodes violet, matching the colour language of the text diff tool. Parent nodes show a count of what changed underneath them; "Expand all" opens every branch at once, or you can drill in one level at a time. What this tool does not attempt is mapping the diff back onto character positions in your original text with inline highlighting. Doing that reliably means tracking line and column offsets through a parser and reconciling them against reformatted whitespace, and it breaks in the cases that matter most. A structural tree is more honest about what actually changed.
Arrays of objects
When an array contains objects, the tool matches elements across the two sides by an identity field, tryingid,_id,key,uuid,guid,sku,code,name, then slug. That is what lets it say "one element was inserted at index 2" instead of reporting that every element from index 2 onward changed. If your objects have none of those fields, elements are compared by position, which is fine for edits in place but will over-report when something is inserted or deleted in the middle. Adding a stable id to each object gives the cleanest results.
Why it is actually private, and how to check
The comparison, including the JSON parse, runs entirely in a Web Worker that is bundled from this site's own source. There is no remote script, no importScripts from a CDN, and no API call. The page loads its own HTML, CSS and JavaScript once when you open it and then makes no network requests at all — no analytics, no ad tags, no web fonts, no telemetry, and no "save" or "share link" feature that would need a server. To verify it, open developer tools, select the Network tab, paste two large JSON documents, and run comparisons with both toggles on and off. Nothing new appears. Because there is no sign-in and no server-side diff, the privacy guarantee is a property of how the tool is built, not a line in a policy.
When to use something else
To check a document against a contract — required fields, types, allowed values — you want a JSON Schema validator, not a diff. To compare two API responses that are each megabytes of minified JSON, a command-line tool that streams the input will handle it better than a browser tab. For tracking changes to a config file over time, committing it to git and reading git diff is simpler. DiffBunker's JSON diff is for the common case: two versions of a document, pasted in, compared now, without any of it leaving your browser.
Frequently asked questions
How is this different from a plain text diff of two JSON files?
A text diff compares the two files character by character, so anything that changes the text changes the result: pretty-printing one side, sorting the keys, switching indentation from two spaces to four, or moving a block of fields all light up as differences even though the data is the same. This tool parses both sides into actual JSON values first and compares those. Formatting and key order are gone by the time the comparison happens, so what is left is only the real structural change — a value that differs, a key that appeared or disappeared, an array element that was added.
Why don't reordered keys show up as changes?
In JSON an object is an unordered set of name/value pairs — {"a":1,"b":2} and {"b":2,"a":1} are the same object. The diff matches keys by name, not by position, so moving a key does nothing. That is what the "Ignore key order" toggle controls: leave it on (the default) and key order is invisible; turn it off and the tool additionally reports objects whose keys carry the same names and values but in a different sequence, labelled "reordered".
What does "Ignore array order" do?
By default arrays are position-sensitive: ["read","write","admin"] compared with ["admin","read","write"] reports that "admin" moved. Turn "Ignore array order" on and each array is treated as a bag of values — the two are then equivalent and nothing is reported. This is useful for things like permission lists, tags, or sets of IDs where the order is not meaningful. It is a separate toggle from key order because the two situations are genuinely different: object keys are never ordered in JSON, array elements sometimes are.
How does it match items inside an array of objects?
When an array holds objects, the tool looks for an identity field on each one — it tries id, _id, key, uuid, guid, sku, code, name, then slug — and matches elements across the two sides by that value. That is how it can tell that one object was inserted in the middle rather than reporting that every object after it changed. If the objects have no such field, elements are matched by position instead, which is less precise for mid-array inserts.
Is my JSON really kept private?
Yes, structurally rather than as a promise. The comparison runs in a Web Worker built from this site's own code. The page loads its HTML, CSS and JavaScript once and then makes no further network requests: no analytics, no ads, no fonts from a CDN, and no save, share or sync endpoint. The diff library is bundled into the page, not loaded from anywhere. Your pasted JSON has nowhere to go.
Can I verify that myself?
Open your browser's developer tools, switch to the Network tab, paste two large JSON documents, and run comparisons with both toggles flipped. The request count does not move. There is no account and no server component for the diff, so there is nothing to take on trust.
How large a document can it handle?
Comfortably into the tens of thousands of lines per side. The parse and comparison happen off the main thread so the page stays responsive. Above roughly 8 MB of combined input it stops rather than lock the tab and asks you to compare smaller documents.
Does it validate my JSON against a schema?
No. It reports a parse error with a line and column when the input is not valid JSON, but it does not check types, required fields, or a JSON Schema. It is a diff tool, not a validator.
Can I upload files instead of pasting?
Not in this version — it is paste-only, on purpose, so the privacy guarantee stays simple to reason about. The same applies to the text and code diff tool.