Article
How Long Does It Take to Verify 100,000 Emails?
By Unlimited Verifier Team ·

Summary
Verifying 100,000 emails usually takes 30 minutes to 6 hours of processing, depending on how fast recipient mail servers answer SMTP checks. Once export, cleaning, review, and re-import are included, budget about one working day. Measure your own rate on a small pilot before you schedule the job.Verifying 100,000 emails takes roughly 30 minutes to 6 hours of processing at speeds of 5 to 50 addresses per second, and about a working day once preparation and re-import are included. The processing time depends mostly on how quickly recipient mail servers answer SMTP checks, so measure your own rate on a pilot before you plan.
Quick answer
- Processing time: At 10 addresses per second, 100,000 emails take about 2.8 hours. At 50 per second, about 33 minutes.
- Full project: Budget about one working day. Export, cleaning, review and re-import usually take longer than the processing itself.
- Pro limits: Each list on Pro holds up to 25,000 emails, so 100,000 addresses need at least four uploads. Pro includes 25,000 deep verifications a month and unlimited standard verification.
- Free plan: 25 lists of 150 emails a month is 3,750 emails. At that cap, 100,000 emails would take about 27 months.
- API route: Pro includes 100,000 API emails a month, and bulk requests take up to 10,000 emails each. One full run is 10 requests.
What determines how long a 100,000-email verification takes?
Verification is a pipeline of stages with very different costs. Syntax checks run in memory and finish almost instantly. Domain and MX lookups are DNS queries, and well-built verifiers typically cache results per domain, so 40,000 Gmail addresses don't require 40,000 separate MX lookups.
The mailbox check is where the time goes. The verifier opens a connection to the recipient's mail server and walks through SMTP commands defined in RFC 5321 to learn whether the mailbox accepts mail, without sending a message. Each conversation costs network round trips, and an unresponsive server costs a full timeout.
| Stage | What it does | Relative cost | Why it matters at 100k |
|---|---|---|---|
| Syntax | Checks format and characters | Negligible | Removes malformed rows before slower steps run |
| Domain and MX | DNS lookup for mail servers | Low, usually cached per domain | Cost scales with unique domains, not rows |
| SMTP mailbox | Conversation with the recipient's server | High, the bottleneck | Latency and timeouts dominate wall-clock time |
| Catch-all detection | Tests whether a domain accepts any address | Moderate, extra probes | Ambiguous results should go to Risky, not Valid |
| Classification and export | Sorts results and writes the file | Negligible | Rarely the constraint |
The slow tail sets the schedule. Most addresses answer in a second or two. A small share sit on servers that stall or throttle, and those few dominate the clock. Illustratively, if 3% of 100,000 addresses (3,000) each wait out a 20-second timeout one at a time, that is 60,000 seconds, or about 16.7 hours. Spread across 50 concurrent workers, the same waiting takes about 20 minutes. Concurrency and timeout handling therefore matter more than any headline speed.
Timeouts are a trade-off. RFC 5321 sets upper timeout limits in its section on timeouts, and the limits for the server greeting and each MAIL and RCPT command are measured in minutes. A 20-second timeout is far shorter than those ceilings, which speeds up a bulk job but can cut off a slow server that would have answered. Public guidance on how reliable SMTP probing is for large consumer providers is mixed, which is why ambiguous results belong in Risky rather than Valid.
File size is the second constraint. Unlimited Verifier accepts CSV and Excel files up to 10MB. Ten megabytes across 100,000 rows is roughly 100 bytes per row. A bare email column is usually around 25 to 35 bytes per row, but adding name, company, signup date and ID columns can push a 100k file over the limit. Splitting the file solves both problems.
Bottom line: Run time comes from SMTP round trips and the slow tail, so measure those on a pilot rather than extrapolating from row count.
How long does 100,000 emails take at different speeds?
Use this formula: hours = number of emails ÷ (emails per second × 3,600).
| Throughput (emails per second) | Total time for 100,000 | Typical situation (illustrative) |
|---|---|---|
| 2 | About 13.9 hours | Serial checks with frequent timeouts |
| 5 | About 5.6 hours | Modest concurrency, many slow domains |
| 10 | About 2.8 hours | Moderate concurrency |
| 20 | About 1.4 hours | Good concurrency, mostly responsive domains |
| 50 | About 33 minutes | High concurrency, mostly cached or fast responses |
Vendors generally don't publish a single throughput figure, so these rows are planning assumptions. The arithmetic scales linearly with row count. A 250,000-row list at 20 per second takes about 3.5 hours (250,000 ÷ 20 = 12,500 seconds). Public documentation doesn't give per-mode speeds for Unlimited Verifier's standard and deep checks, so measure each mode separately if you plan to mix them.
Bottom line: Use the formula with your measured rate. Even the slowest row finishes overnight, so scheduling and review matter more than shaving minutes off the run.
Which verification method should you use for 100,000 emails?
The right method depends on your plan limits, your team's skills and who controls concurrency. For a wider market view, see our best email verification tools roundup, or how to choose an email verifier for a buyer's checklist.
| Method | Capacity per run | Who controls throughput | Cost for 100,000 | Best fit |
|---|---|---|---|---|
| Web upload, split into lists (Pro) | Up to 25,000 per list, unlimited lists | The platform | $29/month, or $25/month billed annually | One-off or quarterly cleanups |
| REST API (Pro) | Up to 10,000 per request; 100,000 API emails a month | You, through your scripts | Within Pro's 100,000 monthly API emails | Verifying at signup or on a schedule |
| Free plan (web) | 150 per list, 25 lists a month | The platform | $0 | Sampling a few hundred addresses, not 100k |
| Self-hosted open-source engine | Limited by your infrastructure | You | Your own server time | Engineering teams that want full control |
What separates these options in practice:
- Web upload (Pro): Results are kept for 30 days, so you have a month to export them. Splitting is manual, but the steps repeat easily for each file. Each list can hold 25,000 rows, which sets your file count.
- API (Pro): The 100,000-email monthly allowance matches this job exactly, which leaves no headroom for a second full run in the same month. Time the run accordingly. Email verification API and automation covers scripting patterns. Pro also includes API access, which the Free plan does not.
- Free plan: Results are kept for only 24 hours, the API is not included, and each list is capped at 150 emails. It suits testing a sample before you commit to Pro.
- Self-hosted engine: The open-source verification engine lets you set your own concurrency and retry logic. The trade-off is that SMTP probes come from your own IP addresses, so you own the reputation risk and must handle timeouts and retries yourself.
Bottom line: Use the web upload on Pro for a one-off cleanup, the API if you verify continuously, and self-hosting only if you have engineering time to run the probing infrastructure.
How do you plan a 100,000-email verification run?
Follow these seven steps before you upload anything. Each one cuts wasted time or prevents a rerun.
- Count and profile the file. Record rows, columns and file size. Divide size by rows to get bytes per row. A 7.3MB file of 100,000 rows averages 73 bytes per row, which fits the 10MB limit.
- Deduplicate and normalise. Trim whitespace, remove blank rows and drop exact duplicates. Duplicates are wasted work. If 8,000 of the 100,000 rows are duplicates, 8% of your run re-checks addresses you already have.
- Segment by source and recency. Tag rows by origin (signup, import, purchased, legacy CRM) and by last activity. You need these tags to allocate deep checks and to read results later. How to segment a list by verification status explains the logic.
- Run a 1,000-row pilot from each source. Measure rows per second, the share of Risky results and any format problems. This pilot turns the speed table into your real schedule. Samples of 500 rows often miss the slow tail, so use at least 1,000.
- Split into batches of 25,000 rows or fewer. Keep source segments intact where you can, so each batch tells a coherent story.
- Run batches in sequence and log each one. Record the start time, finish time and bucket counts for every batch.
- Reconcile and export. Check that Valid + Risky + Invalid equals the input row count for every batch before acting on any result. Export within the retention window.
Why the pilot matters: The pilot is the only input that reflects your list, your network and your timeouts on the day you run. Extrapolating from a published speed or a vendor's claim skips the factors that actually slow large runs.
Bottom line: A short profile and a 1,000-row pilot per source prevent most of the reruns that stretch 100k verifications into several days.
How do you verify 100,000 emails on Unlimited Verifier Pro?
You need Pro for this job, since Free lists are capped at 150 emails. Sign up and move to Pro before you start.
- Export your contacts as CSV from your ESP or CRM. Include the email column and any source or date fields you want to keep for segmentation. If your tool offers UTF-8 encoding, choose it. What file formats email verifiers accept covers the details.
- Clean the file. Remove blank rows, stray spaces and duplicates. How to clean a messy CSV of emails before upload walks through the common problems.
- Check the size and row count. If the file is over 10MB or over 25,000 rows, split it before uploading.
- Split into files of 25,000 rows or fewer. Name each file for its source, for example
list-01-tradeshow.csv. How to split a large CSV for email verification shows how to do this in a spreadsheet or with a short script. - Upload the first file on the upload and verify a list page. CSV and Excel files are accepted, and the email column is detected automatically. How to upload a CSV to an email verifier covers the screen-by-screen steps.
- Choose your verification mode. Use deep verification for your highest-risk segment and standard verification for the rest. Standard verification is unlimited on every plan, while Pro's deep allowance is 25,000 a month, so reserve deep checks for the segment that needs them most.
- Wait for the run to finish, and note the start and end times in your log.
- Read the three buckets: Valid, Risky and Invalid. How to read an email verification results file explains each column.
- Export the results as CSV, Excel or JSON. Pro keeps results for 30 days, so export before that window closes.
- Repeat for the remaining files, then reconcile the totals against your original row count.
- Re-import the Valid contacts into your ESP as a new segment, and suppress the Invalid ones. How to re-import a cleaned list into my ESP covers that step. Unlimited Verifier has no native ESP, CRM or Zapier integrations, so this is an export-and-import workflow.
To spot-check one high-value address before you commit it to a campaign, use the free email checker.
Bottom line: Clean, split, upload, export, reconcile, re-import. Each step is short, and the reconciliation check is the one teams most often skip.
What does a 100,000-contact cleanup look like in practice?
This scenario is hypothetical, and the result percentages are illustrative. The plan limits and arithmetic are real.
The list: An online retailer has 100,000 contacts: 60,000 signups from the last 12 months, 25,000 from a 2019 trade-show import, and 15,000 older contacts. The retailer's ecommerce and SaaS email verification needs are typical of this mix.
Splitting:
- The trade-show import is exactly 25,000 rows, so it becomes one file.
- The other 75,000 rows split into three files of 25,000.
- Four files, 100,000 rows in total.
- At about 73 bytes per row, each file is roughly 1.8MB, well under the 10MB limit.
Deep verification budget: Pro includes 25,000 deep verifications a month. The trade-show file is the riskiest segment, so it uses the whole allowance. The remaining 75,000 rows run on standard verification, which is unlimited. Any later deep run in the same month would need the next monthly allowance, so plan deep checks before you start.
Time at 20 emails per second (illustrative):
- Each 25,000-row file: 25,000 ÷ 20 = 1,250 seconds, about 21 minutes.
- Four files: 100,000 ÷ 20 = 5,000 seconds, about 83 minutes of processing.
Hypothetical results:
| Bucket | Count | Share | Action |
|---|---|---|---|
| Valid | 86,000 | 86% | Send to this segment, starting with recent engagement |
| Risky | 6,500 | 6.5% | Hold back; review catch-all and role addresses separately |
| Invalid | 7,500 | 7.5% | Suppress permanently |
Check: 86,000 + 6,500 + 7,500 = 100,000.
Risky contacts need their own handling. What to do with unknown emails after verification and what to do with invalid emails after list cleaning cover the next steps. Catch-all domains are the most common source of ambiguity, and the catch-all email verification page explains how they are handled. If a large share of your list comes back invalid, what to do if 30 percent of your list is invalid covers the root-cause work.
Cost: One Pro month at $29 works out to $0.29 per 1,000 emails if you charge the full month's fee to this run. On annual billing at $25 a month, it is $0.25 per 1,000. For how pricing compares across the market, see email verification pricing.
The same job via API: 100,000 ÷ 10,000 = 10 bulk requests. That fits inside Pro's 100,000 monthly API emails, but it uses the whole allowance, so a second full run would wait until the next month.
The same job on Free: 100,000 ÷ 150 = 667 lists. At 25 lists a month, 667 ÷ 25 ≈ 26.7, so roughly 27 months at the cap, with no API access and results kept for 24 hours.
Bottom line: One Pro month and about 90 minutes of processing cleaned 100,000 contacts with a clear audit trail. The Free plan would take more than two years.
How long does the whole project take, not just the run?
Verification is the longest single block of machine time, but it is rarely the longest block of your attention. The phases below are practitioner estimates, not measured benchmarks.
| Phase | Typical time (estimate) | Where time goes |
|---|---|---|
| Export and cleaning | 30–90 minutes the first time | Encoding, duplicates, stray columns |
| Splitting | 10–20 minutes | Spreadsheet or script |
| Verification processing | About 35 minutes to 6 hours at 5–50 per second | SMTP round trips and timeouts |
| Review and reconciliation | 30–60 minutes | Checking counts and segments |
| Re-import and ESP processing | 30–90 minutes plus ESP time | Import settings, suppression rules |
Adding those phases gives roughly 2 to 10 hours of hands-on and processing time, which fits in one working day for most teams. The biggest variable is verification speed, and the biggest controllable factor is preparation.
Bottom line: Prepare properly, and the run itself is rarely the bottleneck.
What are the common mistakes that slow down a 100,000-email verification?
- Uploading 100,000 rows as one file. This breaks the 25,000-per-list cap on Pro and can exceed the 10MB limit once extra columns are added.
- Extrapolating from a tiny test. A 500-row sample often misses the slow tail. Use at least 1,000 rows from each source.
- Spending deep checks on the whole list. The 25,000 monthly deep allowance runs out after one full file, leaving nothing for later checks that month.
- Rerunning the same list without a reason. Each rerun costs hours. Reconcile results first, then decide whether a rerun will change anything.
- Skipping deduplication. Duplicates inflate runtime and make your counts of Valid addresses look better than they are.
- Letting results expire. Free results are kept for 24 hours and Pro results for 30 days. Export each batch as soon as it finishes.
- Treating Risky as Valid. Catch-all and role addresses belong in a held-back segment, not in your first send.
- Assuming Valid means consent. Verification confirms that an address is deliverable. It does not prove the person opted in. See email verification compliance and hygiene and the FTC's CAN-SPAM compliance guide.
- Running the Free plan for production. At 150 emails per list and 25 lists a month, it is built for sampling, not for a 100k cleanup.
- Treating one cleanup as permanent. A 100k cleanup gets the list clean for a while, not forever. Set a schedule using email list maintenance best practices, and consider real-time email validation at signup to stop new bad addresses entering the list.
Bottom line: Most slow verifications are slow because of planning gaps, not because of the tool.
How we compared (and limitations)
This article draws on public documentation: Unlimited Verifier's published plan limits and feature descriptions, the timeout and SMTP behaviour described in RFC 5321, and general DNS and SMTP practice.
We have not run controlled timing benchmarks against any verifier. The throughput figures are illustrative, and your real rate will depend on your list, your network, your timeouts and how each mailbox provider responds that day. The worked example's results are hypothetical.
Unlimited Verifier's 99.5% accuracy figure for deep verification is the company's own stated figure, not an independent benchmark. Plan limits reflect the published Free and Pro terms and may change, so check the pricing page before you buy.
Bottom line: Treat the numbers here as planning assumptions, and replace them with the rate you measure on your own pilot.
If you want that measurement, start with a 1,000-row pilot from your largest source. Then create a free account, run the pilot, and use the result to schedule the full 100,000. For the broader process, see the bulk email list verification workflow guide.
Slow-tail worked example
Illustrative math from the article: 3% of 100,000 addresses is 3,000 slow addresses. Each waits a 20-second timeout one at a time: 3,000 x 20 = 60,000 seconds, about 16.7 hours. Spread across 50 concurrent workers: 60,000 / 50 = 1,200 seconds, about 20 minutes. Concurrency removes most of the delay.
Frequently asked questions
How many emails can a verifier process per second?
Based on the speeds cited in this article, typical bulk verification runs at roughly 5 to 50 addresses per second. Actual throughput depends mostly on how quickly recipient mail servers respond to SMTP checks, so the only reliable number is the one you measure on your own list.
Why does verifying a large list take so long?
Most of the time goes to the SMTP mailbox check, which requires a conversation with each recipient's mail server. Slow or throttling servers can stall that conversation until it times out, and a small share of slow addresses can dominate the total runtime.
Does concurrency speed up email verification?
Yes. Running many checks in parallel prevents slow servers from blocking the queue. In the article's illustrative example, 3,000 addresses waiting on 20-second timeouts take about 16.7 hours one at a time but about 20 minutes across 50 concurrent workers.
Should I split 100,000 emails into smaller files?
Often yes, if your plan caps the size of each upload. Pro lists in this article hold up to 25,000 emails, so 100,000 addresses need at least four uploads. Splitting also makes it easier to track progress and recover if one batch fails.
How long does the whole project take, not just processing?
Plan for about one working day. Export, cleaning, reviewing Risky results, and re-importing the cleaned list usually take longer than the verification run itself, so schedule time for those steps as well.
Can I verify 100,000 emails on a free plan?
It is impractical. The free plan described in this article allows 3,750 emails a month across 25 lists of 150 addresses. At that cap, 100,000 emails would take about 27 months, so a paid tier or the API is the realistic route.
What is the API route for verifying 100,000 emails?
The article notes that Pro includes 100,000 API emails a month and that bulk requests accept up to 10,000 emails each. One full run would therefore be 10 requests. Check current vendor documentation for limits before you build the integration.
Why are some results marked Risky instead of Valid?
Catch-all domains accept mail for any address, so a positive response does not prove a specific mailbox exists. Verifiers typically label these as Risky rather than Valid, and the article recommends treating them that way to protect deliverability.
How can I estimate my own verification time?
Run a pilot of 1,000 to 2,000 addresses from your real list, time it, and calculate addresses per second. Divide 100,000 by that rate to get the processing time, then add roughly a working day for preparation and re-import.
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.