Article
How to Split a Large CSV for Email Verification: Limits, Steps and Checks
By Unlimited Verifier Team ·

Summary
To split a large CSV for email verification, cut it into chunks within your verifier's per-list cap and file-size limit, repeating the header row in each chunk. On Unlimited Verifier's Pro plan, that means 25,000 emails and 10MB per file, so a 60,000-row list becomes three files.To split a large CSV for email verification, cut it into chunks no bigger than your verifier's per-list cap, which on Unlimited Verifier's Pro plan is 25,000 emails and 10MB per file, and repeat the header row in every chunk. A 60,000-row list therefore becomes three files: two of 25,000 rows and one of 10,000.
Quick answer
- Know both limits. On Pro, each list holds up to 25,000 emails and each CSV or Excel file up to 10MB. On Free, each list holds 150 emails.
- Let the stricter limit decide. Wide exports hit 10MB before they reach 25,000 rows, so check file size as well as row count.
- Repair and dedupe the master list before you split. Broken quoting can hide duplicates, and an address that lands in two chunks gets verified twice.
- Use a record-aware splitter. Line-based tools cut records whose quoted fields contain line breaks.
- Reconcile every chunk. Valid, Risky and Invalid counts should add up to the rows you sent, file by file.
Splitting is mechanically simple. The failures come from details: a missing header that silently drops a contact, a record cut in half, or one address verified twice. This guide covers the limits, chunk-size tradeoffs, a seven-step process, an Excel tutorial, a script for messy files, worked examples and a reconciliation check. For the wider process, see the bulk email list verification workflow.
Why does a large list need splitting before verification?
Verification limits apply per list, so anything above the cap has to be divided before upload. Splitting also turns one 200,000-row job into smaller jobs you can restart and reconcile. Teams running email verification for ecommerce and SaaS programmes with constant list intake depend on that predictability.
Most people assume row count is the binding constraint, but for narrow exports it usually isn't. Dividing 10MB by 25,000 rows leaves about 400 bytes per row. A bare column of addresses is typically around 25 to 35 bytes per line (an estimate, not a measurement), so 25,000 addresses come to roughly 1MB. An export that also carries name, company, job title, source, tags and a free-text notes field can easily exceed 400 bytes per row. A chunk of "25,000 rows" can then break the 10MB limit. Check the byte size of every chunk.
Bottom line: Plan each split against both limits, and let the stricter one decide.
What limits should you split a CSV around?
Standard verification is unlimited on every plan, including Free. The limits that shape a split are list size, file size and the monthly deep-verification allowance. The file format guide covers accepted formats in more detail.
| Limit | Free ($0) | Pro ($29/month, or $25/month billed annually) |
|---|---|---|
| Emails per list | 150 | 25,000 |
| Lists per month | 25 | Unlimited |
| Upload format and size | CSV or Excel, up to 10MB | CSV or Excel, up to 10MB |
| Deep verifications per month | 750 | 25,000 |
| API access | No | Yes, 100,000 emails a month |
| Results kept | 24 hours | 30 days |
Two numbers change how you plan. Free allows 25 × 150 = 3,750 addresses a month, and its results are kept for only 24 hours, so download them the same day. Before you choose a plan, compare email verification pricing by these caps, not just the monthly fee.
Bottom line: On Pro, lists are unlimited but each one stops at 25,000 emails. On Free, your monthly ceiling is 3,750 addresses.
How do you choose the right chunk size?
Use the largest chunk that clears both caps. Larger chunks mean fewer files to track and merge. Smaller chunks make a failed run cheap to repeat. The table below uses 171,000 unique addresses as an example.
| Chunk size | Files for 171,000 unique rows | Strength | Weakness |
|---|---|---|---|
| 25,000 (Pro per-list maximum) | 7 | Fewest uploads and merges | Most expensive to redo if it fails; the 10MB limit may bind first |
| 10,000 (API batch maximum) | 18 | Matches the largest API batch, so one chunk can be one request | 18 files or requests to track and reconcile |
| 5,000 | 35 | Cheap to re-run; easy to spot-check by eye | Many more merges and reconciliations |
Use 10,000 if you'll verify through the API, and 25,000 for uploads, checking byte size as you go. Drop to 5,000 when the source is unfamiliar, such as a scraped or acquired list, because a bad chunk is cheaper to redo.
Bottom line: Use 25,000 for uploads and 10,000 for API batches. Go smaller only when a failed run would be costly.
How do you split a large CSV step by step?
Follow these seven steps in order. Each one prevents a specific failure.
- Count records and bytes. Count records rather than lines, and note the file size. One record can span several lines when a field contains a line break.
- Repair malformed rows. Fix unquoted commas, stray quotation marks and short rows. A broken row can shift every column in its chunk, and it can also hide a duplicate from step 4. The messy CSV cleanup guide covers common patterns.
- Normalise the addresses. Trim spaces and remove invisible characters. Match on a lowercase copy of each address. The domain part is case-insensitive, and while RFC 5321 allows the local part to be case-sensitive, most major providers ignore case in practice. Export the original casing.
- Deduplicate the whole master list. Keep the first occurrence of each address so every address is verified once. The duplicate removal guide covers variations such as trailing spaces and plus-addressing.
- Add a row ID and sort by domain. Sorting by domain keeps addresses from the same mail domain together, so a catch-all or blocked domain tends to land in one or two chunks. The row ID lets you restore the original order and join results without relying on position.
- Split with the header repeated. Every chunk needs the header row. Otherwise its first data row becomes the header and silently disappears from your counts.
- Name, log and reconcile. Use names such as
list_chunk_01.csv, record each chunk's row count, and check the totals after verification.
Bottom line: Repair and dedupe before you split, and keep a row ID so you can merge without guessing.
Which splitting method should you use?
The right method depends on file size and whether you can run a script.
| Method | Strength | Limitation |
|---|---|---|
| Excel (Windows or Mac) | No code, and you can see each slice | Holds up to 1,048,576 rows per sheet; long numeric IDs turn into scientific notation |
| Google Sheets | Easy to share with a team | Slows on large files; a copy sits in a cloud document, which your data-handling policy may restrict |
GNU split (Linux, macOS Terminal or WSL) |
Fast and scriptable | Counts lines, not records, so multi-line fields get cut mid-record; doesn't repeat the header |
Python csv module |
Record-aware; repeats the header; handles quoted line breaks | Needs Python and a short setup |
| API batching (Pro) | No files to manage; up to 10,000 emails per request | Pro only; 100,000 emails a month; you write the loop |
If you're also choosing a verifier, compare the best email verification tools on file limits, row handling and result retention. The verifier buying checklist covers the criteria in more depth.
Bottom line: Use Excel for files within its row limit, and a record-aware script for multi-line fields or anything larger.
How do you split and verify a 60,000-row list in Excel?
If you don't have an account yet, create one here. The Free plan is enough for the small test runs in the worked examples. This tutorial assumes the email address is in column B and row 1 is a header.
- Export a CSV with headers. From your ESP or CRM, export with the header row. Save it as CSV UTF-8 (in Excel's file type list) to keep accented names intact.
- Remove duplicates. Select the data, go to Data > Remove Duplicates, and choose the email column. Note how many rows were removed.
- Add a row ID. In the first empty column to the right of your data, enter
=ROW()and fill it down. Copy that column, then use Paste Special > Values so the IDs survive sorting. - Add a temporary domain column. In the next empty column, enter
=IFERROR(MID(B2,FIND("@",B2)+1,255),"")and fill it down. Sort the whole table by that column, then delete it so the file stays clean. The row IDs keep the original order. - Plan the slices. With 60,000 data rows, chunk 1 is rows 2 to 25,001 (25,000 rows), chunk 2 is rows 25,002 to 50,001 (25,000 rows), and chunk 3 is rows 50,002 to 60,001 (10,000 rows).
- Create each chunk. For each slice, copy row 1 (the header) into a new sheet, then paste the slice beneath it.
- Save each chunk. Save as CSV UTF-8 with names such as
list_chunk_01.csv. Check each file's size in File Explorer or Finder to confirm it is under 10MB. - Upload each chunk. Open the upload tool and upload the files one at a time. CSV and Excel files are accepted, and the email column is detected automatically.
- Download and save the results. Export each result set as CSV, Excel or JSON. Free results expire after 24 hours and Pro results after 30 days, so keep your own copies.
- Merge and reconcile. Stack the result files and check the totals against the rows you sent. The reconciliation section below explains how.
Bottom line: Excel can handle this 60,000-row job if you convert the IDs to values and save each chunk as CSV UTF-8.
How do you split a CSV whose fields contain line breaks?
RFC 4180 says fields containing line breaks, double quotes or commas should be enclosed in double quotes, so one record can span several physical lines. A line-based splitter ignores those quotes and can cut a contact in half. A record-aware reader, such as Python's csv module, respects the quoting. The Python csv documentation explains how the reader handles quoted fields.
import csv
CHUNK_SIZE = 25000 # Pro per-list cap; use 10000 for API batches
SOURCE = "master.csv"
with open(SOURCE, newline="", encoding="utf-8-sig") as src:
reader = csv.reader(src)
header = next(reader)
part, count, out, writer = 0, 0, None, None
for record in reader:
if not record: # skip blank lines
continue
if count % CHUNK_SIZE == 0:
if out:
out.close()
part += 1
out = open(f"chunk_{part:02d}.csv", "w", newline="", encoding="utf-8")
writer = csv.writer(out)
writer.writerow(header)
writer.writerow(record)
count += 1
if out:
out.close()
The utf-8-sig encoding strips a byte-order mark if one is present and does nothing if it isn't. Without it, the first header name can start with stray characters such as . Run the script on a copy of your file first, and confirm that each chunk's row count is what you expect.
Bottom line: Use a record-aware reader whenever the export can contain quoted line breaks.
What does a real split look like on Pro and Free?
Example A: Pro, 180,000 rows
- Dedupe: 180,000 − 9,000 duplicates = 171,000 unique addresses.
- Split: 171,000 ÷ 25,000 = 6.84, so 7 files: six of 25,000 (150,000 rows) plus one of 21,000, totalling 171,000.
- Standard verification: Included on every plan, so all 171,000 can be checked with no per-email fee.
- Deep verification: Pro includes 25,000 a month. Suppose (hypothetically) that 14% of the list is Risky. Deep-verifying only that bucket needs 171,000 × 0.14 = 23,940, which fits within 25,000 with 1,060 to spare. Deep-verifying the full list would need 171,000 ÷ 25,000 = 6.84 months of allowance, so plan your deep budget around the Risky bucket. Catch-all domains are a common reason an address lands there.
- Cost: One Pro month at $29 covers the uploads for this job. If you used the full 25,000 deep allowance, that works out to $29 ÷ 25 = $1.16 per 1,000 deep checks, or $1.00 on the annual plan.
- API route: Pro includes 100,000 API emails a month, so 171,000 spans two months. At 10,000 per request, the job is 18 requests (17.1, rounded up). Two months at $29 is $58 on monthly billing. The API keys page covers setup, and the email verification API and automation guide covers workflow patterns.
Example B: Free, 4,000 rows
- Split: 4,000 ÷ 150 = 26.67, so 27 lists.
- Schedule: Free allows 25 lists a month, which is 25 × 150 = 3,750 addresses. Verify those this month, then the remaining 250 (two lists) next month. Download each result set the same day.
- Method: Free has no API access, so you split the file in a spreadsheet or script.
- Scale check: A 1,000,000-row list needs 1,000,000 ÷ 150 = 6,667 Free lists, which is 6,667 ÷ 25 = 267 months. On Pro, the same list is 40 chunks (1,000,000 ÷ 25,000), with unlimited lists.
Bottom line: On Pro, the 25,000 cap and the monthly deep allowance drive the plan. On Free, the 150-per-list and 25-list limits set the timeline, and large lists take months.
How do you merge results and reconcile the counts?
Reconciliation catches dropped rows before they reach your sending list. For each chunk, Valid + Risky + Invalid must equal the rows you sent. A shortfall usually points to a malformed row or an encoding problem. The figures below are hypothetical and use the 60,000-row Excel split.
| Chunk | Rows sent | Valid | Risky | Invalid | Check |
|---|---|---|---|---|---|
| chunk_01 | 25,000 | 21,500 | 1,900 | 1,600 | Matches |
| chunk_02 | 25,000 | 21,300 | 2,050 | 1,650 | Matches |
| chunk_03 | 10,000 | 8,600 | 800 | 600 | Matches |
| Total | 60,000 | 51,400 | 4,750 | 3,850 | Matches |
Join the result files on the row ID or the email address, never on row position. If one chunk's Invalid share is well above the others, check its source, because a single system or import often causes that pattern. The 30% invalid guide covers that diagnosis.
Then act on each bucket:
- Valid: Re-import into your ESP as a segment. The segmentation guide shows how to split by status.
- Invalid: Suppress permanently. The delete or suppress guide explains how to decide.
- Risky: Hold back. The valid vs risky guide and the unknown email guide cover the handling. To check a single address, such as a VIP contact, use the free email checker.
If your CRM fields need to survive the round trip, follow the custom fields guide.
Bottom line: A split is finished only when the counts reconcile and you have acted on the merged file.
What do you do when a chunk is still over 10MB?
Split it again. Halve the row count until each file falls below 10MB. For example, a 25,000-row chunk at 500 bytes per row is 12.5MB, which becomes two chunks of 12,500 rows, each about 6.25MB. Trimming columns can help, but keep the email, the row ID and any field you need to match results back.
If your Excel workbook has several sheets, save the one you need as its own CSV, so each file holds a single list.
Bottom line: An oversized chunk is a sizing problem. Split it again rather than deleting data you may need later.
Common mistakes
- Splitting with
spliton a file with quoted line breaks. Records get cut in half, and the broken fragments can come back as invalid. - Splitting by row count alone. Wide exports can pass 10MB while staying under 25,000 rows. Check bytes too.
- Splitting before deduplicating or repairing. The same address in two chunks is verified twice, and broken quotes can hide duplicates.
- Forgetting the header. The first data row of each later chunk disappears from your counts. Reconciliation catches this, but only if you count.
- Letting Excel rewrite IDs. Long numbers turn into scientific notation and leading zeros vanish. Format ID and phone columns as text before you import.
- Saving with the default Excel CSV format. Choose CSV UTF-8, or accented names can garble.
- Treating one-off splits as ongoing hygiene. Lists decay as people change jobs. Follow the list maintenance practices and add real-time email validation to forms so new addresses are checked on arrival.
- Losing Free results to the 24-hour expiry. Download each result set on the day it finishes.
- Treating a Valid result as consent. Verification checks whether an address can receive mail, not whether its owner opted in. The compliance and hygiene guide covers the difference, and the FTC's CAN-SPAM guide sets out the US baseline.
Bottom line: Most split failures come from skipped checks, not from the split itself.
How we compared (and limitations)
This guide is based on public documentation: RFC 4180 and RFC 5321, Python's csv documentation, Excel's documented row limit, and Unlimited Verifier's published plan facts. We have not benchmarked other verification tools' splitting behaviour, so we make no claims about their limits. The 25 to 35 bytes per address, the 400-bytes-per-row figure, the 60,000- and 180,000-row examples and the 14% Risky rate are illustrative, not measured. Unlimited Verifier states 99.5% accuracy for deep verification; that is the company's own figure, not an independent benchmark. Run the script on a copy of your data before using it on the master file.
Worked example: 60,000-row list
| Chunk | Rows | Header | Action |
|---|---|---|---|
| chunk_1.csv | 25,000 | Yes | Verify, reconcile V+R+I=25,000 |
| chunk_2.csv | 25,000 | Yes | Verify, reconcile V+R+I=25,000 |
| chunk_3.csv | 10,000 | Yes | Verify, reconcile V+R+I=10,000 |
| Total | 60,000 | Sum must equal deduplicated master |
Frequently asked questions
What is the maximum number of emails per list for bulk verification?
On Unlimited Verifier's Pro plan, each list can hold up to 25,000 emails, and the file can be up to 10MB. The Free plan allows 150 emails per list. Check both row count and file size, since wide exports can hit 10MB before reaching 25,000 rows.
Should I repeat the header row in every CSV chunk?
Yes. Each chunk should include the header row so the verifier can map columns correctly. Without it, the first data row may be read as a header and that contact can be dropped silently. Confirm each file's first line is the header before uploading.
How do I calculate the right chunk size?
Divide the row limit by your list's expected rows and check average bytes per row against the 10MB cap. Narrow files with only an email column are usually limited by row count. Wide files with many columns are usually limited by file size, so use whichever allows fewer rows.
Why should I dedupe before splitting?
An address that appears in two chunks gets verified twice, wasting credits and making counts harder to reconcile. Dedupe the master list first, normalising case and whitespace, so each email appears once across all chunks.
Can a line-based splitter break a CSV?
Yes. If quoted fields contain line breaks, such as notes or addresses, a plain line splitter can cut a single record in half. Use a record-aware CSV parser that respects quoting, so each record stays whole in one chunk.
How do I check that no emails were lost during splitting?
Reconcile each chunk: Valid plus Risky plus Invalid should equal the number of rows you sent for that file. Then confirm the sum across all chunks matches the deduplicated master count. Any gap points to a missing header, a broken record or a skipped row.
Does splitting a list use more verification credits?
It shouldn't if you dedupe first, because each unique address is verified once. Duplicate addresses that span chunks would consume extra credits. Standard verification is unlimited on all plans, but deep verifications are capped monthly, so avoid repeat submissions.
Where do I find the file format rules before splitting?
Check the verifier's accepted formats and size limits in its documentation before you split. Confirm whether CSV or Excel is accepted and whether the 10MB cap applies to your export. Matching the format avoids rejected uploads and wasted re-splits.
Cut Bounces and Protect Your Sender Reputation With Unlimited Email Verification
Every invalid address you send to hurts your sender reputation and your inbox placement. Verifying your list before each send means fewer bounces, healthier deliverability, and a predictable cost. With Unlimited Verifier, standard verification is unlimited on every plan, with no per-email fees.
Unlimited Verifier checks syntax, domain, MX records and the SMTP mailbox. It also detects catch-all domains and flags disposable and role-based addresses. Export a CSV from your email platform or CRM, upload and verify the list, then re-import the clean results. You can also automate checks with the email verification API.
| Free | Pro | |
|---|---|---|
| Price | $0 | $29/month ($25/month billed annually) |
| Lists | 25 a month, up to 150 emails each | Unlimited, up to 25,000 emails each |
| Deep verifications | 750 a month | 25,000 a month |
| API access | No | Yes (100,000 emails a month) |
| Result retention | 24 hours | 30 days |
Why teams choose Unlimited Verifier
- Unlimited standard verification on all plans, including Free, with no per-email fees.
- Catch-all detection so you know which domains accept every address.
- Clear Valid / Risky / Invalid results, exportable as CSV, Excel or JSON.
- An open-source verification engine you can inspect on GitHub.
Unlimited Verifier states 99.5% accuracy for deep verification.
Create a free account and verify your next list before you hit send.
Want to test a single address first? Try the free email checker.