Merge Two Excel Workbooks with a Left or Inner Join on a Key Column

Basic left join on a shared key

File A is a product list, File B is a price table. leftKey and rightKey both = sku. Every product row gets the price column appended; the right key column (sku) is not duplicated.

File A (products, first sheet):
sku,name
A-1,Widget
A-2,Gadget
A-9,Sprocket

File B (prices, first sheet):
sku,price
A-1,9.99
A-2,14.50

Left join output (joined-data.xlsx, sheet "Joined"):
sku,name,price
A-1,Widget,9.99
A-2,Gadget,14.50
A-9,Sprocket,        <- no match: price left blank

Inner join drops the unmatched row

Same files, switch joinType to inner. Sprocket has no price in File B, so it is removed instead of kept with a blank.

joinType: inner

Output:
sku,name,price
A-1,Widget,9.99
A-2,Gadget,14.50

(A-9 Sprocket is gone — inner keeps only keys present in both files.)

Number key matches text key

File A stores the order id as a number, File B as text. VLOOKUP returns #N/A here; the joiner coerces both with String() so they match.

File A:        File B:
order,total    order,carrier
1001,42.00     "1001",FedEx
1002,18.50     "1002",UPS

Left join (leftKey=order, rightKey=order):
order,total,carrier
1001,42.00,FedEx
1002,18.50,UPS

One-to-many fan-out

File B has multiple rows per key. A left join emits one output row per File-B match, so File-A rows multiply. Output rows exceed File-A's input rows — confirm against the metrics panel.

File A (1 row):        File B (2 rows for K1):
key,owner             key,line_item
K1,Acme               K1,Bolts
                      K1,Nuts

Left join output (2 rows):
key,owner,line_item
K1,Acme,Bolts
K1,Acme,Nuts

Column-name collision — right wins

Both files have a status column. The join copies File B's status over File A's, since each right column except the key is written into the merged row. Rename one column first if you need both.

File A:           File B:
id,status         id,status
7,Pending         7,Shipped

Left join output:
id,status
7,Shipped        <- File B overwrote 'Pending'

The Sheet Joiner is Pro-minimum and the join itself needs two files, which exceeds the Free tier's 1-file allowance. The tool blocks the run with a 'Sheet Joiner requires Pro tier.' message. Upgrade to Pro (50 MB / 100,000 rows) to run joins.

A join needs both slots filled. With File B missing, the processor throws 'Two files are required for sheet joining.' Add the second file before running.

Keys are looked up by the exact header you type into leftKey / rightKey. A missing or misspelled header makes row[key] undefined, which String() turns into "" for every row — so on a left join all rows fall through unmatched (blank right columns), and on an inner join you get zero output rows. Check the headers exactly, including trailing spaces.

Empty, null, or missing key cells all coerce to the same empty string "". Every File-A row with a blank key matches every File-B row with a blank key, which can produce a large accidental cross-product. Clean blank keys out first if your data has them.

This is a left/inner join, not a full outer join. Rows that exist only in File B (no matching File-A key) are always discarded — there is no option to surface them. If you need them, swap which file is A and B and run again.

String comparison is case-sensitive: ACME and acme are different keys and will not join. Normalise case in both files first with the case converter so the keys line up.

Each file contributes its first worksheet only. A workbook whose join table lives on sheet 2 will be read as its sheet 1 instead. Move the table to the first tab, or save it as its own file, before joining.

Cells parse with cellDates on and format-on-read, so a date key becomes a formatted string before comparison. Two files must render the date identically (same display format) for the keys to match; standardise them first with the date standardizer.

The joiner matches on a single key column per side. Despite older copy mentioning composite keys, the actual contract has one leftKey and one rightKey. To emulate a composite key, concatenate the parts into one helper column in each file first, then join on that.

One-to-many matches fan out: a File-A row with N File-B matches becomes N output rows. The metrics panel shows output rows vs input rows so you can see the multiplication — it is not a bug, it is how a relational join works.