Your files never leave your device. All processing happens locally in your browser.
How do I merge multiple CSV files into one without uploading them?
Open Merge CSV Files, then drop or pick your .csv, .tsv or .txt files (up to 200 at once) and choose how to combine them: Append stacks the rows of every file into one long table, Side-by-side places each file’s columns next to each other, and Join by column runs a real SQL-style inner, left, right or outer join on a shared key. Drag the files to reorder them, because order matters for append and join. The parser reads each file in your browser — auto-detecting the delimiter (comma, semicolon, tab, pipe or caret), the character encoding and any BOM — and shows a live preview of the merged result with the output row and column counts. For Append you pick how headers are handled (union of all columns, first file only, or require identical) and can add a source_file column; optional de-duplication removes exact duplicate rows or rows sharing a key column. Export the merged table as CSV, TSV, Excel (.xlsx), JSON or NDJSON, copy it to the clipboard, and nothing ever leaves your device.
Three merge modes — Append (stack rows), Side-by-side (stack columns) and Join by column (inner / left / right / outer)
Auto-detects the delimiter, encoding and BOM of every file and parses quoted fields per RFC 4180
Header handling for Append (union, first-only or require-identical) plus an optional source_file column
De-duplicate exact rows or rows sharing a key column, with a live preview of the merged output
Export as CSV, TSV, Excel (.xlsx), JSON or NDJSON — 100% in your browser, nothing uploaded
What is
Merge CSV Files
Merging CSV files is the act of combining several comma-separated-values files into a single dataset. There are three fundamentally different operations, and picking the right one matters. A vertical merge or append stacks the rows of every file on top of one another — the correct choice when the files share the same columns (for example monthly exports of the same report), where the key decision is how to reconcile headers that do not line up exactly. A horizontal or side-by-side merge lays each file’s columns next to the others, aligning by row position. A join combines rows from different files by matching a shared key column, exactly like SQL: an inner join keeps only keys present in both, a left or right join keeps every row from one side and fills blanks for the other, and a full outer join keeps everything. Because CSV is only loosely standardised (RFC 4180 is a guideline, not a mandate), a real merge tool must also cope with different delimiters, quoted fields containing commas or newlines, mixed character encodings and byte-order marks, and duplicate rows. This tool performs all of that entirely in the browser and never uploads your files.
No. Every file is read and merged entirely in your browser with JavaScript — there is no upload, server or account, so your data never leaves your device.
Nothing is uploaded. When you drop or pick files, the tool reads each one locally with the browser’s File API, parses it in memory and computes the merge on your device — the row and column data never touch a network. There is no server, API, database or tracking in the processing path, so customer lists, financial exports or any other sensitive spreadsheet stay on your machine; the tool works offline once cached, and closing the tab discards everything. Even the Excel (.xlsx) export is built in the browser with a bundled library. The only optional network use anywhere on the site is consent-gated advertising, which never sees your data.
Append stacks rows (same columns, more rows); side-by-side stacks columns by row position; join matches rows across files on a shared key column, like a SQL inner/left/right/outer join.
Append (a vertical merge) concatenates the rows of every file into one longer table — use it when the files describe the same kind of data, such as twelve monthly exports, and choose whether the output columns are the union of all files, only the first file’s headers, or must be identical. Side-by-side (a horizontal merge) puts each file’s columns next to the others and lines rows up by their position, padding shorter files with blanks. Join by column is the relational operation: you pick a key that appears in every file, and the tool matches rows sharing that key — an inner join keeps only matched keys, a left or right join keeps all rows from one side, and an outer join keeps everything, filling gaps with empty cells. If two files have a column of the same name, the join and side-by-side modes automatically rename the collision so no data is lost.
Yes. Each file’s delimiter, encoding and BOM are auto-detected, headers are read from the first row, and Append lets you union columns, keep only the first header, or require identical headers.
The parser inspects every file independently: it detects the delimiter (comma, semicolon, tab, pipe or caret), the character encoding (UTF-8, UTF-16 with a byte-order mark, or a Windows-1252 fallback) and whether a BOM is present, then reads the first row as the header and the rest as data, correctly handling quoted fields that contain commas or line breaks per RFC 4180. For an append merge you control headers directly — union includes every column from every file (blanks where a file lacks one), first-only trusts the first file’s header, and require-identical warns and falls back to a union if the headers do not match. You can also add a source_file column so each row records which file it came from. On export you choose the output delimiter, LF or CRLF line endings, whether to write a UTF-8 BOM (helpful for Excel), and whether to quote every field.
Open Advanced and choose Dedupe exact rows to drop fully identical rows, or Dedupe on key column to keep only the first row for each value of a chosen column; the counter shows how many were removed.
De-duplication runs after the merge so it can see the combined table. Keep all leaves every row untouched; Dedupe exact rows removes any row whose entire contents duplicate an earlier row; and Dedupe on key column keeps only the first occurrence of each value in a column you select, which is ideal for collapsing repeated customer IDs or e-mail addresses gathered from several files. The summary bar reports how many duplicate rows were dropped and the final row and column totals, and the live preview (up to the first 500 rows) reflects the result immediately, so you can confirm the merge before exporting to CSV, TSV, Excel, JSON or NDJSON.
Detailed Explanation
📖How It Works
Merging CSV Files in Your Browser
Merge CSV Files combines many CSV, TSV or plain-text files into a single dataset without uploading anything. Drop or pick up to 200 files (100 MB each) and choose how to combine them: Append stacks the rows of every file into one long table, Side-by-side lays each file’s columns next to the others by row position, and Join by column runs a relational inner, left, right or outer join on a shared key. Each file is parsed independently in the browser — the delimiter (comma, semicolon, tab, pipe or caret), character encoding and any byte-order mark are auto-detected, and quoted fields that contain commas or line breaks are handled per RFC 4180. A live preview shows the first 500 rows of the merged result along with the input and output row and column counts, and files can be dragged to reorder them because order matters for append and join.
Three modes: Append (stack rows), Side-by-side (stack columns) and Join by column
Auto-detects delimiter, encoding and BOM for each file
Parses quoted fields with embedded commas or newlines per RFC 4180
Live preview of the first 500 merged rows with running row / column counts
📋Use Cases
Appending Reports, Joining on a Key, and Cleaning Up
The commonest job is a vertical merge: stacking many exports of the same report — monthly sales, per-store inventory, survey batches — into one file. For that, Append with union headers keeps every column even when the files drift apart, first-only trusts the first file’s header, and require-identical warns you if the shapes disagree; an optional source_file column records which file each row came from. When the files describe the same entities from different angles, Join by column matches them on a shared key such as an id or e-mail: an inner join keeps only the overlap, a left or right join keeps every row from one side, and an outer join keeps everything. After merging, de-duplication collapses fully identical rows or keeps just the first row per key value, so repeated customer records gathered from several files fold into one clean list ready to export.
Append monthly / per-source exports of the same report into one table
Union, first-only or require-identical header handling, plus a source_file column
Join on a key with inner / left / right / outer semantics
De-duplicate exact rows or rows sharing a key column after merging
🔧Technical Details
Parsing, Merge Engines and Export
Every file is read with the browser File API and decoded by sniffing the byte-order mark (UTF-8, UTF-16LE or UTF-16BE) or, when there is none, trying strict UTF-8 and falling back to Windows-1252. The delimiter is inferred from the first line and the body is parsed with an RFC 4180 state machine that respects quotes and escaped double-quotes. Append builds the output column set from the chosen header mode and maps each source row into it; Side-by-side concatenates every file’s columns and aligns rows by index; Join by column folds files together left-to-right, indexing the right side by key and emitting matches according to the join type, with colliding column names automatically suffixed by filename so nothing is overwritten. The merged table can be exported as CSV or TSV (with a selectable delimiter, LF or CRLF line endings, an optional UTF-8 BOM and quote-all), as Excel .xlsx built locally with a bundled library, or as JSON (an array of objects) or NDJSON (one object per line).
Encoding sniffed from the BOM, with a strict-UTF-8 then Windows-1252 fallback
RFC 4180 parser handling quotes and escaped double-quotes
Colliding column names are auto-renamed on join and side-by-side merges
Exports: CSV, TSV, Excel (.xlsx), JSON and NDJSON
⚠️Limitations
Honest Limitations
Everything runs in browser memory, so there are practical ceilings: up to 200 files, 100 MB per file, and the on-screen preview shows only the first 500 rows (the full result is still exported). Side-by-side merging aligns rows purely by position — it does not sort or match keys — so it assumes the files are already in a corresponding order. A join needs a column whose name appears in every file; if no shared header exists the tool tells you to rename headers so they match. Because CSV carries no type information, all values are treated as text, and a join on a key stored as “007” in one file and “7” in another will not match unless you normalise them first. Only .csv, .tsv and .txt inputs are accepted; a genuinely malformed or non-tabular file may parse into unexpected columns, which the live preview lets you catch before exporting.
Caps: 200 files, 100 MB each; preview shows the first 500 rows (full result still exports)
Side-by-side aligns by row position, not by a matching key
Join requires a shared column name; values compare as text, so 007 ≠ 7
Accepts .csv, .tsv and .txt only
🔒Privacy & Security
Privacy: Your Files Stay on Your Device
CSV exports are often sensitive — customer and contact lists, financial ledgers, order and inventory data, survey responses — and this tool is built so they never leave your machine. Each file is read and merged entirely in memory with the File API and plain JavaScript, with no server, upload, database, logging, API or CDN anywhere in the processing path; even the Excel export is generated locally. The tool works offline once cached, and closing the tab discards every byte. There is no login and no telemetry, and the only optional network use anywhere on the site is consent-gated advertising, which never sees your data.
Read and merged entirely in the browser with the File API
No server, upload, database, API or CDN in the processing path
Works offline once cached; closing the tab discards everything
Only optional network use is consent-gated ads, which never see your data
Merge CSV Files — modes, options and limits
Capability
Support
Notes
Merge modes
Append, Side-by-side, Join by column
Join supports inner, left, right and outer semantics
Header handling
Union, first-only or require-identical (Append)
Optional source_file column; colliding names auto-renamed on join / side-by-side
Delimiter, LF / CRLF, UTF-8 BOM and quote-all options; copy or download
Limits & scale
Up to 200 files, 100 MB each; 500-row preview
All in browser memory; full result still exports; 100% client-side, no upload
Merge CSV Files combines up to 200 CSV, TSV or text files in the browser via Append (stack rows), Side-by-side (stack columns) or Join by column (inner / left / right / outer). Each file’s delimiter, encoding and BOM are auto-detected and quoted fields are parsed per RFC 4180; header handling, an optional source_file column, automatic renaming of colliding columns and post-merge de-duplication are all supported, and the result exports as CSV, TSV, Excel, JSON or NDJSON. Side-by-side aligns by row position, a join needs a shared column, and values compare as text. Everything runs in browser memory; nothing is uploaded.