Compare Files Online

Most online diff tools ask you to choose a mode before you've even pasted anything in — JSON diff, XML diff, YAML diff, each behind its own page. This comparison starts the other way around: give it two files, and it works out what they are.

Detection uses the file extension when you upload, and the content itself when you paste — a JSON object starts with { or [, XML starts with a tag, CSV has a consistent number of comma-separated fields across its lines, and YAML is recognized by its key-and-indentation structure. Whichever guess it makes is shown above the panels, so it's never a silent assumption.

Two files can represent identical data while looking nothing alike on disk — different indentation, single versus double quotes, a trailing newline, keys in a different order. Comparing that as raw text produces noise, not insight.

Once a file's format is known, both sides are parsed into their actual structure and then re-printed in a single, consistent style before anything is compared. That's true whether it's a minified JSON API response, a hand-edited YAML config, or an XML export from a legacy system — the comparison is based on the data, not on how it happened to be formatted that day.

XML and YAML both describe structured data, just with different syntax from JSON. Parsing an XML document turns each tag into an element with its own attributes and children, so a comparison can point at exactly the attribute or nested tag that changed rather than flagging a whole block of markup as different.

YAML is parsed the same way a YAML-aware application would read it — mappings, lists, and nested indentation become the same structure a JSON document would use internally — which is what makes it possible to compare a Kubernetes manifest or a CI config file by the settings it defines, not by its exact spacing.

A CSV file is really a table, and comparing it as plain text throws that structure away — a single changed value makes an entire line look different. Using the header row as field names turns each row back into a record, so a changed cell is reported by its row and column instead.

Rows are still matched by position, the same way JSON Compare treats arrays: inserting a row in the middle of an export will show every row after it as shifted. For most CSV exports — sorted, appended-to, or generated fresh each time — that position-based comparison is exactly what you want to see.

Auto-detection is a best guess, and real files aren't always well-formed. If the format detected from one file doesn't actually validate against the other — a stray comma breaking JSON, a missing closing tag in XML — a structural comparison would either fail or produce something misleading.

Instead, the comparison quietly falls back to a line-by-line text diff, the same one Text Compare uses, complete with word-level highlighting on changed lines. You still get a usable result immediately, and the error location is shown so you know what to fix if you wanted the structural view instead.

Every parser — JSON, XML, YAML, and CSV — runs entirely inside your browser using JavaScript on your own device. Files are read, detected, formatted, and compared locally; nothing is uploaded to a server, logged, or stored anywhere.

That matters most for the files people compare here: exported user data, infrastructure configs, API responses — content that often shouldn't leave your machine just to find out what changed. See the privacy page for the full explanation of what does and doesn't happen to your data.