Article

How to Split a Large CSV for Email Verification: Limits, Steps and Checks

By Unlimited Verifier Team ·

Diagram showing a 60,000-row master CSV split into three chunks for email verification, each with a repeated header row.

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

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.

  1. 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.
  2. Remove duplicates. Select the data, go to Data > Remove Duplicates, and choose the email column. Note how many rows were removed.
  3. 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.
  4. 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.
  5. 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).
  6. Create each chunk. For each slice, copy row 1 (the header) into a new sheet, then paste the slice beneath it.
  7. 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.
  8. 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.
  9. 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.
  10. 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

Example B: Free, 4,000 rows

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:

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

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 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.