XLSX Sheet Compare

"Can you just make sure the numbers didn't change?" It sounds like ninety seconds of work. Then you open the old budget and the new budget side by side, realize nobody labeled which revision is which, and start scrolling two windows in parallel like a human comparator. By the third screen you're no longer reading values — you're pattern-matching them, which is a polite way of saying you're guessing. Twenty thousand cells in, the confidence that you would actually spot a changed 12,400 to 13,800 is approximately zero, and you know it.

The professional move in a spreadsheet shop is to reach for a real diff. The problem is that the genuinely good one Microsoft ships, Spreadsheet Compare, arrives only with certain Office licensing, and the online alternatives mostly want your file uploaded to their servers before they will tell you anything. Neither constraint is acceptable when the two files in question are the salary planning workbook.

This page is the third option: drop both workbooks, get a cell-level diff rendered in the browser, filter it down to changed, added, or removed content, and read a summary that says in one line what an afternoon of scrolling would have half-found. Nothing uploads. Nothing gets emailed to a converter.

A text diff, the kind your version control system runs, thinks in lines. That model fits poorly to spreadsheets, because a workbook is not a sequence of lines — it is a two-dimensional grid of addressed cells, plus shared lookup tables, plus style records, all zipped together. Comparing the raw bytes or the raw XML of two .xlsx files tells you they differ; it does not tell you that cell D17 on the Marketing tab moved from 12,400 to 13,800 while everything else on that sheet stayed put.

So this tool reconstructs both sheets into cell grids first, then compares them cell by cell by reference. For each address — A1 through XFD1048576 in principle, though real sheets are far smaller — it asks: does this cell exist on both sides, and if so, are its contents equal? Cells present on the left but absent on the right are removals; the reverse are additions; matching addresses with unequal contents are changes. Every result lands in a filterable diff grid with old value, new value, and location, and the top-line summary counts each category so you know at a glance whether you are looking at three edits or three thousand.

The comparison mode is your call. Value mode diffs calculated results — the pragmatic default for "did the numbers change." Formula mode diffs the formula text itself — the right choice when you are auditing a spreadsheet someone else reworked and the question is what logic moved, not what it printed.

1. 1

   Load file A

   Drop the original workbook on the left panel. The parser reads the Office Open XML package (or the legacy .xls binary) and lists every sheet it contains, hidden tabs included.

2. 2

   Load file B

   Drop the revision on the right panel. Same treatment: full sheet list, no judgment about which one is newer.

3. 3

   Choose the two sheets

   Pick which tab from each workbook forms side A and side B of the comparison. Same sheet name in both files is the normal case; comparing two different tabs from one file is equally allowed.

4. 4

   Set the mode

   Values or formulas, plus an optional numeric tolerance for decimals. Tolerance of zero means exact stored-precision comparison; two decimals means 0.30 and 0.30000000000000004 compare equal.

5. 5

   Read the diff

   The result grid lists every difference with its cell address, old content, and new content. Filter buttons narrow it to changed, added, or removed cells; the summary strip counts rows and columns touched.

6. 6

   Export or repeat

   Download the diff as CSV for documentation, or swap in the next pair of files — the panels reset without reloading the page.

For the paranoid — which in spreadsheet work is a compliment — the tool also shows sheet dimensions and cell counts for both sides before the diff runs. Two files that claim to be the same export with different row counts are already worth a question, and you will see it before you see a single flagged cell.

The interesting engineering in a cell diff is deciding what "equal" means, because an .xlsx file stores surprisingly little the way you'd guess. Text does not live inside the worksheet XML; it lives in a shared string pool that cells reference by index, and two identical strings are usually one entry used twice. The tool resolves those references first, so you compare the actual text, not the plumbing.

Numbers compare numerically. That sounds obvious until you meet the display trap: a cell showing 5% stores 0.05, a cell showing $1,250.00 stores 1250, and two cells that display identically can store different values under different formats. The diff always compares what the file stores, and displays both sides raw, precisely so format tricks can't hide a real change or invent a fake one. Dates, stored as numeric serials in the 1900 system, are resolved to their readable form for display but compared as the underlying numbers — January 1, 2020 is 43831 or it isn't.

Text comparison is exact and case-sensitive, byte for byte after shared-string resolution. A trailing space — the single most common invisible edit in shared spreadsheets — shows up as a change, with the old and new values printed side by side where the space is visible if unglamorous. Empty versus blank is another quiet distinction the tool surfaces: a cell containing the empty string and a cell containing nothing at all are different animals in the file format, and the diff reports them as such rather than papering over it.

Rename any .xlsx to .zip and open it. What you find is a small filesystem: workbook.xml holding the sheet registry, worksheets/sheet1.xml and its siblings holding cells, sharedStrings.xml holding the text pool, styles.xml, theme parts, maybe a calcChain describing formula evaluation order. A cell in the worksheet XML looks like <c r="D17" s="4" t="n"><v>13800</v></c> — address, style index, type, value — with the number sitting right there, but text sitting back in the shared pool and meaning distributed across three files.

This structure is why naive comparisons misfire. Diff the raw XML and the order of rows in the file, zip entry timestamps, and style renumbering all register as differences even when every cell is identical. Excel itself rewrites the package in ways that shuffle internal ordering. The only reliable method is what this tool does: parse both files to the same abstract representation — a grid of resolved values — and compare that. It is slower than a byte diff and incomparably more meaningful.

The legacy .xls format is even further from text: a binary record stream inside an OLE2 compound container. No line-oriented tool can touch it at all. Supporting both formats in one diff means the comparison you run between last quarter's archive and this quarter's export does not start with "first, convert everything," which historically was the step where the audit quietly stopped happening.

Here is the scenario the tool was born from, with real numbers. A finance team circulates budget_v7.xlsx, an ops director returns "budget_final.xlsx" (a name that means nothing), and someone must certify that the returned file contains only the agreed changes before it goes to the board pack.

Two flagged cells, both among the agreed edits, nothing else moved. That is the whole audit, and it took about ten seconds including file loading. The certification writes itself: "budget_final differs from budget_v7 in exactly two cells, B15 and D16, matching the approved adjustments." Try composing that sentence credibly after a manual scroll-through.

The second example is the one to internalize. A diff that reports only cell-address mismatches is technically correct and practically useless the moment anyone inserts a row. Matching rows on a stable key — an ID, a code, a name that doesn't repeat — is what turns the flood back into the single edit that actually happened. When your sheets have a natural key column, use it.

• Shifted grids without a key. Sort order changes, filters left applied, rows moved — all masquerade as mass edits under reference alignment. Match on a key column or re-sort both sheets before comparing.
• Cross-sheet formula dependencies. A value that comes from another tab changes when that tab changes, even though this sheet's cells were never touched. Values mode catches the outcome; formula mode on this sheet alone will not flag anything, because the formula text is identical. Compare the dependent sheets too.
• Volatile functions. NOW(), TODAY(), RAND() recompute every time the file opens. Two "identical" files saved a day apart will show differences in any cell touching those functions. Filter those rows out of the diff, or your audit noise drowns signal.
• External links. Workbooks pulling from other files (or databases, or the now long-dead MSN Money data feeds) store cache values that drift between saves. A diff flags the cached numbers, not the link — check Data → Queries and Connections in Excel if the changed cells all trace back to one source.
• Rounding display versus stored value. A cell displaying 12.4 that stores 12.400000000000002 will flag against a true 12.4 at zero tolerance. Set the tolerance to the number of decimals your numbers actually carry; four is plenty for most financial work.
• Merged cells compare at their anchor. The top-left cell of a merge holds the value; the rest are empty. Two files with the same visible layout can differ in merge structure without showing a content diff — this tool compares contents, not layout.
• Very large sheets hit browser memory. Multiple million-row sheets in both files can exhaust a tab. Trimming to the used range, or exporting the sheet to CSV first and diffing the text, is the escape hatch — CSV Filter Rows and XLS to CSV Converter cover that path.

The recurring users are predictable. Finance teams comparing circulating budget versions before a board meeting. Payroll and HR verifying that a vendor's updated headcount file contains only the agreed changes. Ops managers checking that a supplier's refreshed price list matches the negotiated one — a five-cent drift on one SKU across forty thousand units is real money, and exactly the kind of change no eyeball catches. Pricing analysts validating a spreadsheet regenerated by an export job against the previous run, where "the process worked" means "the only diffs are the ones the process was supposed to produce."

It shows up after mistakes, too. When two people edit what they believe is the same file, or someone pastes into the wrong window, the reconstruction question is always the same: what actually changed between this and that? A cell-level diff turns an hour of squinting at Freeze Panes into a sorted list with addresses. Data teams use it during migrations for exactly this reason — "compare the old extract to the new extract, prove the pipeline, sign it off."

And auditors, internal and external, have a standing need to evidence that a reviewed number is the number that shipped. A downloadable diff, produced locally, dated, listing exactly two changed cells, is the kind of artifact that makes review notes short.

Microsoft ships a genuinely thorough desktop diff tool: Spreadsheet Compare, which arrives with Office Professional Plus and the enterprise tiers of Microsoft 365 Apps, alongside the Inquire add-in. If you have that licensing and a Windows machine, it is the reference implementation — it diffs values, formulas, formatting, macros, and even VBA changes, and nobody serious disputes it.

The honest positioning: if you have the Microsoft tool, it does more. This page exists for everyone else — the contractor on a Mac, the analyst on a Microsoft 365 Business Standard license that doesn't include Inquire, the auditor who cannot install anything, and the person whose files simply must not take a trip to a vendor's upload endpoint. For contents-only diffing, which is what 90% of "did anything change" questions actually require, the cell grid here answers in seconds without prerequisites.

Both workbooks are opened with the browser's local File API and parsed in the tab. The comparison, the alignment, the diff grid, the CSV export — all JavaScript on your machine. There is no conversion queue, no storage bucket, no "we delete files after 24 hours" promise to take on faith, because there is nothing to delete. Load the page once and it keeps working with the network disconnected, which is not a party trick: it is how the air-gapped machine in the finance room gets to have working tools.

The no-upload property is the entire reason we built this as a browser tool rather than a free API with a page in front of it. The files people need to compare — salary plans, vendor contracts, client rosters — are the files with the least business being on a third-party server. Local comparison removes the judgment call entirely. If you want proof rather than prose, the browser's dev-tools network panel shows zero requests after the page loads.

The comparison habit generalizes. For JSON exports, the JSON Diff Checker runs the same value-level analysis on documents, and Text Diff Checker handles the line-oriented case — changelogs, configs, contracts. When a diff surfaces cells worth extracting rather than just flagging, XLSX to JSON Converter takes the sheet straight to structured data for scripting.

And when the finding is "the old file is the good file," XLS to CSV Converter is standing by to get its contents into a format the rest of your pipeline will accept.