Article
Best Email Verifier for Very Large CSV Files: Limits, Pricing and Workflow
By Unlimited Verifier Team ·

Summary
For very large CSV files, Unlimited Verifier's Pro plan is the top pick, accepting uploads up to 10MB and lists of up to 25,000 emails at $25 per month billed annually. Most large-file failures come from file size, duplicates, spreadsheet formatting and merging results rather than from the verifier itself, so splitting and preparing the file matters as much as the tool.For very large CSV files, Unlimited Verifier's Pro plan is the top pick: it accepts CSV or Excel uploads up to 10MB, holds up to 25,000 emails per list, and offers unlimited standard verification for $25 per month billed annually. This guide is for marketers, list owners, agencies and SaaS teams cleaning databases of roughly 100,000 rows or more. Most large-file failures come from file handling, such as size, duplicates, spreadsheet formatting and merging results, rather than from the verifier itself, so the steps below focus there.
Quick answer
- Top pick: Unlimited Verifier Pro for large files you will clean repeatedly. The Free plan is for samples only, at 150 emails per list.
- The limit that bites first: on wide files, the 10MB file cap comes before the 25,000-row list cap. Split at about 20,000 rows.
- Effective cost: a 1,000,000-row list refreshed four times a year on annual Pro works out to about $0.075 per 1,000 checks, based on the published prices.
- Alternatives: ZeroBounce for granular suppression labels, NeverBounce for automated ESP sync, or MillionVerifier for a budget-led one-time scrub.
What makes a very large CSV harder to verify?
Large files usually fail on mechanics before accuracy becomes the question. Five issues cause most of the trouble.
File size beats row count. Divide 10MB by 25,000 rows and you get roughly 400 bytes per row. An email column alone fits easily, but a row carrying a long tracking URL, a user-agent string or several tag columns can use that budget by itself. A file that looks safely under the row limit can still be rejected. Export only a subscriber ID and the email address for the verification run, then join results back later.
Duplicates hide in plain sight. Lists merged from signup forms, CRMs and old imports often contain the same mailbox with different capitalization or stray spaces. Normalize and deduplicate before you pay to verify the same address twice.
Spreadsheets quietly change data. Excel stores numbers at 15 significant digits, so long numeric IDs lose precision, and re-saving a CSV can strip leading zeros. If your source is an .xlsx file, note that a single worksheet holds at most 1,048,576 rows, so a larger database has to come out of your ESP as CSV in the first place.
Column detection can pick the wrong column. Automatic email-column detection works well on a clean file. If the export also contains a backup or secondary address column, check the preview before the run starts.
Runtime is not linear. SMTP mailbox checks depend on remote mail servers responding at their own pace. Time the first chunk, then plan the rest of the run around that figure rather than assuming every file takes the same time.
The core check is the RCPT TO step of the SMTP dialogue, defined in RFC 5321. Many mail servers accept every recipient at that step, which is how catch-all domains work. A passing check on a catch-all domain does not prove that a specific mailbox exists. In a large B2B database, catch-all rows can form a meaningful share of the list, so routing them to a Risky bucket matters more at scale than it does on a small list. Check your own proportion after the first chunk.
Bottom line: plan for file size, duplicates, spreadsheet formatting, column detection and runtime before you choose a tool.
Which email verifiers are the best for very large CSV files?
Here are the best email verification tools for large files, with quick picks first and a side-by-side table after.
Quick picks
- Best overall for large files, one-off and recurring: Unlimited Verifier (Pro).
- Best for a budget-led one-time scrub: MillionVerifier, which is positioned on low per-credit cost for large lists.
- Best for automated ESP syncing: NeverBounce, through its Sync integrations.
- Best for threshold-based suppression: Kickbox, through its Sendex score.
- Best for granular suppression labels: ZeroBounce, which includes spamtrap and abuse statuses.
- Best for EU data-protection requirements: Bouncer, which is EU-based and offers a toxicity check.
- Best for explaining decisions to clients: Emailable, which returns reason codes.
- Best free option for testing a sample: Unlimited Verifier Free, for lists of up to 150 emails.
| Tool | Starting price | Free tier | Catch-all handling | Best for |
|---|---|---|---|---|
| Unlimited Verifier | $0 Free; Pro $29/mo ($25/mo billed annually) | Yes: 25 lists/mo × 150 emails, 750 deep verifications, 24-hour result retention, no API | Detects catch-alls and sorts them to Risky | Large files and repeated full-list passes |
| ZeroBounce | Varies | Varies | Dedicated catch-all status | Granular statuses, spamtrap and abuse labels |
| NeverBounce | Varies | Varies | "catchall" result | Automated ESP sync |
| Kickbox | Varies | Varies | "risky" result plus Sendex score | Score-based thresholds |
| Bouncer | Varies | Varies | "risky" result | EU-based teams and toxicity checks |
| Emailable | Varies | Varies | "risky" result | Reason codes for client reports |
| MillionVerifier | Varies | Varies | "catch_all" category | Budget one-time cleans |
Bottom line: for a large file you will re-run, cost behavior and catch-all handling matter more than any single accuracy claim.
How we compared (and limitations)
This comparison is based on public documentation and vendor-published information. We judged each option on the criteria that matter for large files:
- Limits per file and per list, including the file-size cap and the number of rows per list.
- Cost at volume, for a single large pass and for quarterly re-runs.
- Catch-all handling, and whether catch-alls are separated from confirmed-valid addresses.
- Output categories, and whether they map to clear actions: send, segment or suppress.
- Re-import workflow: export formats, API availability and native ESP sync.
For the broader criteria, see which email verifier features actually matter, and use the email verifier comparison checklist template to record each vendor's answers the same way.
What this comparison can't tell you:
- Accuracy on your list. Accuracy figures are vendor claims. Test them on a sample of your own data and compare the results with your actual bounces.
- Runtime. We did not time large runs on any service, so the timing guidance in this article is a method, not a benchmark.
- Current limits and prices. Competitor limits and prices change often. Where a figure was not clearly published, we mark it "varies" rather than guess.
- Review-site rankings. Scores from review sites were not used as an input. For that view, see top-rated email verifiers on G2 and Capterra.
- Engagement. Verification removes undeliverable addresses. It does not tell you who is reading.
Bottom line: every limit and price here should be re-checked on the vendor's current page before you commit to a large run.
Which email verifiers handle very large CSV files best?
Seven options, ordered by fit for large files.
1. Unlimited Verifier (best overall for large CSVs)
Unlimited Verifier is a bulk verification tool. You upload a CSV or Excel file of up to 10MB, and it detects the email column automatically. It then runs syntax, domain, MX and SMTP mailbox checks and sorts each address into Valid, Risky or Invalid. For large files, three facts matter: standard verification is unlimited on every plan, Pro lists can hold up to 25,000 emails each, and results export as CSV, Excel or JSON.
In practice, a 300,000-row database becomes 12 files of 25,000 rows, or more if you split for file size, and each file produces its own three-bucket output. The three buckets let you act on a whole file at once: Valid goes to active, Invalid goes to suppression, and Risky gets segmented.
Key features
- CSV or Excel uploads up to 10MB, with automatic email-column detection.
- Catch-all detection, with catch-all addresses routed to Risky rather than Valid. See catch-all email verification for how this works.
- Disposable and role-based flagging.
- 25,000 deep verifications a month on Pro, for addresses that need more scrutiny.
- REST API with bulk batches of up to 10,000 emails per request (Pro).
Pros
- Unlimited standard checks mean a quarterly full-list pass doesn't add to the bill.
- The three-bucket output maps directly to send, suppress and segment decisions.
- The verification engine is open source on GitHub, so technical teams can read how the checks are built.
Cons
- The 25,000-email list cap means a 300,000-row database needs at least 12 files, plus a manifest to merge the results.
- Pro results are kept for 30 days, so exports need to be downloaded promptly.
- No native ESP, CRM or Zapier integrations. Large runs are an export, verify and re-import loop, or a series of API calls.
Best for: teams cleaning large lists repeatedly on a fixed budget.
Where it falls short: teams that want their ESP to clean lists automatically with no file handling.
Pricing: Free ($0) includes 25 lists a month of up to 150 emails each, plus 750 deep verifications, with no API access. Pro is $29/month or $25/month billed annually, with unlimited lists of up to 25,000 emails each, 25,000 deep verifications a month, API access (100,000 emails a month) and 30-day result retention. The company states 99.5% accuracy for deep verification. Treat that as its claim and test it on your own sample.
Tip: keep chunks near 20,000 rows. The cost section below shows the arithmetic for a 1,000,000-row database.
2. ZeroBounce
ZeroBounce is known for detailed result labeling. Its top-level statuses include valid, invalid, catch-all, unknown, spamtrap, abuse and do_not_mail, and several of these carry sub-statuses. It also offers AI scoring for catch-all addresses as an additional layer. Beyond list cleaning, it sells an email finder and deliverability tools.
For a large file, the labeling depth is the main draw. Each row gets a status, so a 500,000-row export can be split into much finer suppression groups than a three-bucket output allows.
Key features
- Seven top-level statuses, with sub-statuses such as those under do_not_mail.
- AI scoring for catch-all addresses.
- A broad integration library and API.
Pros
- The spamtrap and abuse labels give large databases suppression signals that simpler outputs do not expose.
- Many integrations reduce manual file handling for teams that already run them.
Cons
- The sub-status taxonomy requires a written policy before a large export can be acted on. Without one, the team will improvise on each file.
- The wider product set (finder, deliverability tools) goes beyond what list cleaning typically needs.
- Pricing tiers and any file-size limits need checking on the current vendor page before a large run.
Best for: teams that want the most detailed suppression labels and have a written policy to apply them.
Where it falls short: repeated full-list passes where the budget is set by check volume.
Pricing: pay-as-you-go credits and subscriptions. Check current rates.
Tip: decide your rules before you upload. Suppress spamtrap and abuse outright. Review do_not_mail sub-statuses before deleting, because that group can include addresses you may still want to keep.
3. NeverBounce
NeverBounce is owned by ZoomInfo. Its Sync feature connects to supported email platforms and cleans lists on a schedule, so no file is exported or imported. Results come back as valid, invalid, disposable, catchall and unknown, and a real-time API covers signup forms.
Sync is a different workflow from uploading a CSV, so the file limits in this guide don't apply to it. Check NeverBounce's own limits before relying on it for a large database.
Key features
- Sync integrations with supported email platforms.
- Bulk upload and a real-time API.
- A dedicated "catchall" result.
Pros
- For a database already in a supported platform, automated syncing removes the export and re-import steps.
- The five categories are simple to act on, with few decisions per row.
Cons
- Sync applies its settings to every row. Decide whether catch-all addresses are tagged or suppressed before you connect the platform.
- Ownership by a B2B data company matters to some privacy-conscious buyers, so review its data-handling terms.
- Sync is a recurring service on top of verification, which changes how the cost compares with one-off file runs.
Best for: teams with large lists in a supported platform who want hands-off cleaning.
Where it falls short: teams whose platform isn't supported, or teams that want file-level control over each run.
Pricing: varies, with pay-as-you-go and subscription options.
Tip: run a test on a small segment first, then compare the results with the platform's bounce data before you let Sync act on the full database.
4. Kickbox
Kickbox returns deliverable, undeliverable, risky and unknown results. Its signature feature is the Sendex score, a 0-to-1 quality rating that lets you set your own cut-off instead of relying only on categories.
On a large file, a single threshold can be applied consistently across hundreds of thousands of rows. That consistency is the attraction, but the threshold has to be right first.
Key features
- Sendex quality score from 0 to 1.
- Four result categories.
- Bulk and real-time verification.
Pros
- One threshold applies the same rule to every row, which helps when a large file has to be handled in a single policy.
- A focused product, without prospecting tools bundled in.
Cons
- The threshold needs calibration. Set it too high and you over-suppress good addresses. Set it too low and risky addresses reach your sends.
- Sendex scores aren't comparable with other vendors' scores, which complicates using two verifiers.
- Over-suppression on a large file can silently remove a meaningful share of real subscribers, so the effect needs checking before the run.
Best for: data teams that want threshold-based rules across large files.
Where it falls short: senders who want simple buckets and no tuning.
Pricing: credit-based; varies.
Tip: calibrate on a random sample of about 5,000 rows. Compare the score bands with bounce results from a real send, then apply the threshold to the full file.
5. Bouncer
Bouncer is an EU-based verifier. It returns deliverable, risky, undeliverable and unknown results, and it offers a Toxicity Check that flags addresses associated with breaches, spam traps or litigious recipients.
For a large database, the toxicity check is a second pass on the same rows, so it adds runtime and cost on top of standard verification.
Key features
- EU base, which simplifies data-processing conversations.
- Toxicity checking as a separate risk layer.
- Four result categories, plus an API.
Pros
- The toxicity signal adds a risk dimension that standard checks don't provide.
- Useful for large databases with strict data-protection requirements.
Cons
- Toxicity checking is a separate layer that you configure and pay for, which doubles the passes you need to plan around on a large file.
- The EU base helps data-processing conversations, but it does not by itself make a list compliant. Consent and purpose still have to be documented.
- The "unknown" results still need a retry or suppression policy.
Best for: EU publishers and agencies managing large databases with GDPR obligations.
Where it falls short: non-EU senders choosing mainly on price.
Pricing: credit-based; varies.
Tip: run toxicity checks on your oldest segment first. Risky addresses tend to concentrate in older records, so that segment shows the value of the extra layer soonest.
6. Emailable
Emailable (formerly Blaze Verify) offers bulk and API verification with deliverable, undeliverable, risky and unknown results, plus a quality score and reason codes that explain why an address failed.
Reason codes are the feature that matters on a large file. Grouping the output by code shows where a problem is concentrated before you suppress anything.
Key features
- Reason codes for each result.
- Quality score alongside category results.
- Bulk, API and ESP integrations.
Pros
- Reason codes let you show a client exactly why thousands of addresses were removed.
- Grouping by reason code helps you spot a sign-up source or import problem rather than treating every failure as the same.
Cons
- Its category set overlaps heavily with Kickbox and Bouncer, so the differentiation rests largely on reporting.
- Reason codes have to be read and interpreted. Teams without someone who can do that gain less from them.
- Risky-handling rules are yours to write.
Best for: agencies that need explainable results across large client databases.
Where it falls short: high-volume repeated checks on a fixed budget.
Pricing: credit-based; varies.
Tip: after a bulk run, sort the output by reason code. A single code concentrated in one segment often points to a sign-up source problem rather than a list problem.
7. MillionVerifier
MillionVerifier positions itself on low per-credit cost for large lists. Its results are ok, catch_all, unknown, disposable and invalid, so catch-alls have their own category.
For a one-time clean of a dormant list, that focus can be a sensible fit. The trade-off is that low-cost positioning usually means fewer extras around each result.
Key features
- Bulk upload and an API.
- A dedicated catch_all category.
- Five result categories.
Pros
- Attractive for a single large scrub where unit cost is the main constraint.
- Few moving parts, which keeps the run simple to explain internally.
Cons
- Confirm how much context comes back per address before committing. Fewer extra fields make it harder to explain decisions later.
- The smaller ecosystem than ZeroBounce or NeverBounce means fewer native integrations.
- Per-credit billing compounds if you re-run the same file every quarter.
Best for: budget-led one-time cleans of large dormant lists.
Where it falls short: ongoing hygiene, or compliance programs that need documented reasoning for each address.
Pricing: credit-based; varies.
Tip: use a budget scrub for the initial clean, then keep new signups verified continuously. Otherwise the list decays back within months.
Bottom line: these seven options split into flat-cost tools suited to repeated passes and per-credit tools suited to one-off jobs or specific features.
How do you verify a very large CSV step by step?
These steps assume a database of several hundred thousand rows exported from your ESP and use the Unlimited Verifier workflow.
Export a clean source file. Export as UTF-8 CSV with the subscriber ID, the email column and any field you need to route results later.
Normalize and deduplicate. Trim whitespace, lowercase addresses, drop blanks and keep the first ID for each address. This script does all of it while keeping IDs as text:
import pandas as pd
df = pd.read_csv("list.csv", dtype=str) # read every column as text
df["email"] = df["email"].str.strip().str.lower()
df = df.dropna(subset=["email"])
df = df.drop_duplicates(subset="email", keep="first")
df.to_csv("list_clean.csv", index=False, encoding="utf-8")
Test a sample on Free. Pull 150 random rows from the cleaned file and sign up for the Free plan. Check the column detection, the output format and the Valid/Risky/Invalid split before you touch the full list.
Split into chunks of about 20,000 rows. Keep a manifest that records each chunk's file name and row count, so the chunks can be checked against the source total later.
size = 20000
for i, start in enumerate(range(0, len(df), size), start=1):
df.iloc[start:start + size].to_csv(f"list_part_{i:02d}.csv", index=False, encoding="utf-8")
Check each file's size. Every file should be well under 10MB. On Windows, check Properties. On macOS or Linux, use
ls -lh.Upload and verify each chunk. On Pro, upload each chunk and confirm the detected email column before the run starts.
Reconcile the counts. Record Valid, Risky and Invalid totals for each chunk. The row counts should add up to the cleaned source total. Any gap means a blank row, a dropped line or a split error, and it should be fixed before you continue.
Deep-verify Risky addresses. Spend deep verifications on the Risky bucket only, starting with the most engaged recipients.
Export the same day. Download CSV or Excel results immediately. Pro retains results for 30 days, and Free retains them for 24 hours.
Merge the results. Check whether the export keeps your ID column. If it does, merge on ID. If it doesn't, merge on the normalized email you uploaded in step 2, which matches the exact string the verifier received. Rebuild three lists: Valid, Risky and Invalid.
Re-import with rules. Mark Valid as active, add Invalid to your suppression list and tag Risky for segmentation. For sunset rules, see email list maintenance best practices.
Verify new signups continuously. For new addresses, the email verification API is available on Pro. For the design choices behind checks at signup, see real-time email validation. Automating this step is the core of email verification API and automation.
Repeat quarterly. Run the full-list pass again, verifying only what you have not already cleaned if your reconciliation shows the earlier results are still current.
Bottom line: a clean run is a sequence of small checks, including a sample test, a count reconciliation and a same-day export, rather than one large upload.
How much does it cost to verify a very large list?
Pricing for a large list depends on whether you pay per check or per plan. The email verification pricing model determines how a quarterly refresh scales, so run the numbers before you commit.
Unlimited Verifier, Pro billed annually: $25 × 12 = $300 per year. On monthly billing, the cost is $29 per month. For a 1,000,000-row database refreshed four times a year, that is 4,000,000 checks, or $300 ÷ 4,000 = $0.075 per 1,000 checks.
Per-credit tools (illustrative only): suppose a per-credit rate of $0.003 per check. That is $3 per 1,000 checks. One pass on 1,000,000 rows costs 1,000,000 × $0.003 = $3,000, and four quarterly passes cost $12,000 a year before any deep checks. Replace the illustrative rate with the vendor's actual price before comparing.
Worked example: a 1,000,000-row database
- File count: at the 25,000-row maximum, you need 40 files (1,000,000 ÷ 25,000). At the 20,000-row target, you need 50 files. The 50-file version leaves headroom for wide rows, since 10MB ÷ 20,000 rows is about 500 bytes per row.
- API versus CSV: the API allowance is 100,000 emails a month, so verifying the full list through the API alone would take 10 months (1,000,000 ÷ 100,000 = 10). Use CSV uploads for the one-off clean and reserve the API for signups.
- Deep verification: suppose 15% of the list comes back Risky. That is an illustrative figure, not a benchmark. It gives 150,000 addresses, or 6 months at 25,000 deep verifications a month (150,000 ÷ 25,000 = 6). Deep-check the 25,000 most engaged Risky addresses first.
- Free plan: 1,000,000 ÷ 150 = 6,667 lists. At 25 lists a month, that is 267 months (6,667 ÷ 25 ≈ 267). Free is for samples, not a database this size.
Bottom line: at quarterly refresh, a flat-cost plan spreads the cost across every pass, while per-credit pricing bills each pass in full.
Which verifier should you choose?
The right tool depends on your bottleneck. Use this table as a starting point, then work through the buying questions in questions to ask before buying an email verifier and red flags when choosing an email verification service.
| Your situation | Pick | Why |
|---|---|---|
| Large list, repeated full-list passes, fixed budget | Unlimited Verifier (Pro) | Unlimited standard checks on a flat plan |
| Large list in a supported ESP, no file handling | NeverBounce | Sync integrations |
| Threshold-based suppression across a big file | Kickbox | Sendex score |
| EU data-protection priority | Bouncer | EU base, toxicity check |
| Client reporting with explained failures | Emailable | Reason codes |
| One-time budget cleanup | MillionVerifier | Low per-credit positioning |
| Detailed suppression labels | ZeroBounce | Spamtrap and abuse statuses |
| Sign-up data from ecommerce or SaaS | Bulk tool plus real-time checks | See email verification for ecommerce and SaaS |
If you are deciding whether to rely on the verification built into your ESP, see whether to use your ESP's built-in verification. For the wider framework, see how to choose an email verifier.
If your list includes non-ASCII or internationalized domains, test a sample of those rows before a full run, as described in can an email verifier check international domains.
Building your own checker is possible, but running SMTP probes from a single server can invite throttling or blocking by receiving mail servers. That is one reason most teams buy a service instead. For prospecting lists specifically, see email verification for sales prospecting.
Bottom line: match the tool to your bottleneck, whether that is cost at repeated volume, ESP automation, compliance or client-facing explanations.
What mistakes do teams make with very large CSVs?
- Splitting at exactly 25,000 rows. Wide rows push a file past 10MB and the upload fails. Target about 20,000 rows and check the file size.
- Using Free for a big list. Free allows 150 emails per list, so a 1,000,000-row database would take 6,667 lists. Use Free for samples and Pro for the full run.
- Re-saving the source in Excel. Long IDs lose precision and leading zeros disappear. Keep IDs as text, or avoid re-saving the source at all.
- Merging on the wrong key. If the export drops your ID column, merging on a raw email from the original file can mismatch on case or spaces. Merge on the normalized string you uploaded.
- Skipping the count reconciliation. If chunk totals don't add up to the source total, a split or merge error is hiding in the results.
- Deep-checking everything. Spend deep verifications on the Risky bucket. Valid addresses don't need them.
- Not suppressing Invalid before the next import. Otherwise the next import brings the addresses back.
- Deleting every Risky address. Catch-alls often include real readers, so segment them by engagement instead.
- Treating verification as consent. Verification removes undeliverable addresses. It does not make a purchased or unconsented list lawful. The FTC's CAN-SPAM compliance guide covers US requirements, and the ICO covers UK data-protection guidance. For how these pieces fit together, see email verification compliance and hygiene.
Bottom line: most large-file failures come from process gaps, such as file size, data formatting, reconciliation and suppression, rather than from the verifier.
What if an upload fails or the results don't add up?
- The upload is rejected. Check the file size first. If the file is over 10MB, split it into smaller chunks and re-upload only the affected file, not the whole list.
- The wrong email column is detected. Look at the preview before the run. If a secondary address column is confusing detection, remove that column from the chunk and re-run only that chunk.
- Counts don't match the source. Check for blank rows, quoted line breaks and extra header lines introduced by an export tool. Fix the source, then regenerate the affected chunk.
- Your ID column disappeared. Check the export settings. If the output cannot carry your ID, keep a mapping file from normalized email to ID made in step 2.
- Results have expired. Pro results are kept for 30 days and Free results for 24 hours, so download exports the same day.
Bottom line: most failures are fixed by re-running a single chunk, not the full database.
Verdict
For very large CSV files, the deciding factor is what the work costs when you repeat it. Unlimited Verifier's Pro plan, at $25 per month billed annually, gives unlimited standard verification, uploads of up to 10MB per file and up to 25,000 emails per list. It also includes deep verifications and API access for new signups. Its stated 99.5% accuracy figure for deep verification is the company's own claim, so test it on your data. The main limitation is the lack of native ESP integrations, which means large runs are a planned export, verify and re-import loop.
Competitors each have real strengths: NeverBounce's Sync, Kickbox's Sendex threshold, Bouncer's EU base and toxicity check, Emailable's reason codes, ZeroBounce's detailed labels and MillionVerifier's low per-credit positioning. Their per-credit or credit-based models mean a quarterly pass on a large list is billed each time.
On deliverability thresholds, sources differ. Google's sender guidelines set the spam rate in Postmaster Tools at a level to stay under 0.10% and warn against reaching 0.30% (see Google's email sender guidelines). Many ESPs treat hard-bounce rates around 2% as a warning sign, though practice varies by provider. We recommend keeping hard bounces under 1% per send, which leaves headroom. The SMTP mechanics behind mailbox checks are defined in RFC 5321, and M3AAWG publishes sender best practices.
Bottom line: split at about 20,000 rows, deduplicate and keep IDs as text, reconcile counts after every chunk, verify with a flat-cost tool and download results the same day.
Splitting a 1,000,000-row list
- Export only subscriber ID and email.
- Trim spaces, lowercase addresses, remove exact duplicates.
- Split into chunks of about 20,000 rows (check the 10MB cap).
- Time the first chunk and estimate total runtime.
- Verify each chunk and save results with the ID column.
- Join results to the master file by ID.
- Route catch-all and risky rows to a separate bucket and measure their share.
Frequently asked questions
What is the maximum CSV size for Unlimited Verifier?
Unlimited Verifier's Pro plan accepts CSV or Excel uploads up to 10MB and lists of up to 25,000 emails per list, based on its published limits. On wide files the 10MB cap usually hits first, so splitting around 20,000 rows is a safe starting point.
How do I verify a list bigger than the per-list limit?
Split the master file into chunks below the per-list row cap, verify each chunk, then join the results back to your master file using a subscriber ID. Keep the ID column in every chunk so you can match each verified address to its original record.
Why does my CSV get rejected even with fewer rows than the limit?
File size is measured in bytes, not rows. Long tracking URLs, user-agent strings and extra tag columns can push a file past the size cap even when the row count is safely under the limit. Export only an ID and the email column for the verification run.
Why do leading zeros disappear when I open a CSV in Excel?
Excel treats columns that look like numbers as numeric and drops leading zeros, and it stores numbers at 15 significant digits, which can corrupt long IDs. Import the column as text, or keep IDs as strings in your export, before saving the file.
What is a catch-all domain?
A catch-all domain is a mail server configured to accept mail for any address at that domain. A verifier may get a positive response at the RCPT TO step, which does not confirm that the specific mailbox exists, so these addresses are usually labeled risky.
How much does it cost to verify 1 million emails?
Cost depends on the plan and how often you refresh the list. The article's example of a 1,000,000-row list refreshed four times a year on annual Pro works out to about $0.075 per 1,000 checks, based on published prices. Check current pricing before budgeting.
Should I deduplicate before or after verification?
Deduplicate before verification. Normalize capitalization and remove stray spaces first, so the same mailbox is not paid for twice. This is one of the cheapest ways to reduce cost on a merged list.
Is ZeroBounce or NeverBounce better for large files?
ZeroBounce suits teams that need granular suppression labels, while NeverBounce suits automated sync with an email service provider. MillionVerifier is a budget option for a one-time scrub. The right choice depends on your workflow, file handling needs and budget.
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.