Merge Several CSV Files Into One
Stack multiple CSV files into one, in order, sharing the first file's header row — right in your browser.
Drop your file here or click to browse
CSV files (.csv)
Your files stay on your device
Nothing to delete afterwards
Aggregation stays private
Works in every modern browser
How it works
- 1
Add your files
Drop all the CSVs onto the page at once, or click to select them.
- 2
Check the column mapping
Confirm the columns lined up the way you expected before downloading.
- 3
Download the combined file
One CSV with a single header row and every record beneath it.
Why use this tool
Columns matched by name
Files whose columns sit in a different order still line up, instead of shifting every value one column left.
One header row, at the top
The header from each file after the first is recognised and dropped rather than landing in the middle of your data.
Per-file separator detection
One export using commas and another using semicolons can be merged without editing either first.
Mismatched columns handled
A field present in only some files still gets a column, with blanks where it was absent.
Nothing is uploaded
The files are read in your browser — monthly exports full of customer rows never reach a server.
Free, no account
No signup, no watermark, no cap on how many files you combine.
Merging is not concatenation, and the difference is where files break
The obvious way to combine CSVs is to stack them end to end — the approach behind every `copy *.csv` and `cat` command people reach for first. It produces a file, and the file is wrong in a specific way: every CSV begins with a header row, so a stack of twelve monthly exports contains twelve header rows, eleven of them sitting in the middle of your data like ordinary records. Open the result in a spreadsheet and you get rows reading `date, amount, customer` scattered through the year. Sort by date and they scatter further. Import it into anything that expects numbers and the parse fails on a row that is text. A merge has to recognise those repeated headers and drop them, which is the first thing raw concatenation cannot do.
The failure that produces no error at all
Header rows are the visible problem. The dangerous one is column order. Two exports of the same report, generated three months apart or by two people with slightly different settings, can carry identical columns in a different sequence — `name, city, postcode` in one and `name, postcode, city` in the other. Stack them by position and every row from the second file has its city in the postcode column and its postcode in the city column. Nothing errors. The row count is right, the file opens, the columns look populated, and the data is quietly wrong in a way that survives review because it looks like a full spreadsheet. Matching by header name is the only defence, and it is the reason to use a merge tool rather than a shell command.
What to do when the files do not carry the same columns
Real exports drift. Someone adds a `discount_code` column in March, another field gets retired in July, and by the time you merge the year you have files that overlap without matching. There are two honest answers. Take the union — every column anyone had — and leave blanks where a file did not carry that field; you keep all the data and accept that some cells are empty because the field did not exist yet, not because it was empty. Or take the intersection — only the columns every file shares — and get a clean rectangle at the cost of discarding fields. This tool takes the union, because deleting data silently is worse than leaving a gap. But it is worth knowing which you got, because a blank in a merged file means "not applicable to this file" far more often than it means zero.
Each file brings its own encoding and its own separator
A merge is where format inconsistencies collide, and they collide more often than people expect because the files usually come from different places. One export was saved on a Mac, another on a Windows machine, a third downloaded from a web application. One uses commas; one uses semicolons, because it was exported on a computer whose locale treats the comma as a decimal mark. One is UTF-8, one is Latin-1, and one carries a byte order mark that becomes stray characters in front of the first column name. Each of these has to be resolved per file rather than decided once for the batch, which is precisely the work a naive concatenation skips — it copies bytes and lets the damage surface later. If you have ever merged files and found one block of rows full of question marks, this is what happened.
After the merge you can no longer tell where a row came from
This is the step people wish they had taken, usually about an hour too late. Once twelve files are one file, the information about which row came from which source is gone — and that is exactly the information you need when a total looks wrong, when duplicates appear, or when someone asks whether March was included. The fix takes two minutes and has to happen first: add a column to each file naming its source, whether that is the month, the region, the branch, or just the filename. Merged, it becomes a column you can filter and group by, and it turns "the numbers look off" from an afternoon of re-checking into a single pivot. Nothing in the merge itself can reconstruct it afterwards.
Why converting locally matters for this kind of file
The files people merge are almost never one-offs. They are the monthly export, the per-branch report, the split-by-region download — which means merging is the moment a year of customer records, or every branch at once, exists as a single file for the first time. A hosted merger receives all of it in one upload, and the combined file is more sensitive than any of its parts, because aggregation is what turns routine records into something worth stealing. This tool never sends any of it: the files are read from disk into the page and the merged CSV is written back with no request carrying the data, which is visible in the Network tab of your developer tools. For a job whose whole purpose is aggregation, that is the difference worth insisting on.
Common mistakes to avoid
- Concatenating with `copy` or `cat`. Every file after the first contributes its header row as a data row, so you end up with eleven text rows scattered through a year of numbers.
- Stacking files by column position. Two exports with the same columns in a different order will merge silently and put every city in the postcode column — no error, right row count, wrong data.
- Merging before adding a source column. Once the files are one file you cannot tell which row came from where; add the month, branch, or filename to each file first — it takes two minutes and cannot be reconstructed after.
- Assuming a blank cell means zero. In a merged file a blank usually means that file did not carry that column at all, which is a different fact from an empty value.
- Uploading a year of exports to an online merger. The combined file is more sensitive than any single export, because aggregation is exactly what makes records worth stealing; merge locally.
How it compares
| Aspect | This tool | copy / cat | Online mergers |
|---|---|---|---|
| Data sent to a server | Never | No | Usually yes |
| Repeated headers removed | Yes | No | Usually |
| Columns matched by name | Yes | No — by position | Varies |
| Mixed separators handled | Yes | No | Varies |
| File-count limit | Device memory only | None | Often capped |
| Price | Free | Free | Free / paid tiers |
Features
Name-based column matching
The header text decides where a value goes, not the position of the column in each file.
Header rows deduplicated
Only the first file’s header survives; the rest are recognised and removed.
Union of all columns
Every field found in any file gets a column, so nothing is silently dropped.
Mixed separators supported
Comma, semicolon, and tab files can go into the same merge.
UTF-8 preserved
Accented, Arabic, Turkish, and other non-ASCII text passes through unchanged.
No file-count limit
Merge two files or two hundred; your device memory is the only ceiling.
Nothing to install
No download, no runtime, no dependencies — it runs on the web page.
Arabic and RTL ready
Full interface in eight languages, including right-to-left Arabic.
Secure by default
Served over HTTPS, with no file tracking and no third-party upload.
Who uses it
Analysts
Rolling twelve monthly exports into one file before building a single report on the year.
Finance teams
Combining per-branch or per-region reports without checking every column alignment by hand.
Marketing teams
Merging contact exports from several sources into one list before deduplicating.
Developers
Stitching together split exports that a system produced in chunks rather than as one download.
Frequently Asked Questions
The rows from every file are stacked in the order you add them. The header row is taken from the first file, and the other files’ header rows are skipped.
For a clean result the files should share the same columns in the same order. Mismatched columns are still stacked as-is, so line them up first for best results.
No. Merging happens entirely in your browser — your files are never uploaded, stored, or shared.