Article
Why Is Email Verification Slow for Some Domains?
By Unlimited Verifier Team ·

Summary
Email verification is slow for some domains because the receiving mail server controls the pace, through reply delays, greylisting, or rate limits meant to block address harvesting. Diagnosing the pattern in your results shows whether the cause is the server or your own network, and a well-structured job keeps one slow provider from holding up the rest of the list.Email verification is slow for some domains because the receiving mail server, not your software, controls the pace: it may delay replies by several seconds, greylist first attempts for about five minutes, or rate-limit connections to block address harvesting. For the mechanics of the existence check itself, see how an email verifier checks if an address exists.
This guide explains the mechanics behind each delay, how to tell whether slowness comes from your network or the receiving server, and how to structure a large job so one slow provider doesn't hold up everything else. For the wider process, start with how email verification works.
Quick answer
- The receiving server usually sets the pace. Large providers and many corporate gateways rate-limit, greylist or deliberately delay connections that resemble address harvesting.
- Greylisting adds a wait measured in minutes. The first attempt can receive a temporary rejection, so the verifier must come back later. Postgrey, a widely used open-source greylisting package, defaults to a 300-second delay.
- Your slowest domain sets your runtime. A list concentrated on one provider runs at that provider's pace, not the average speed.
- Pace and retry; don't stack parallel jobs. Several jobs against one provider multiply your connections and often increase deferrals.
- Starting settings: a 10-second connect timeout, a 30-second per-command timeout, and a retry for deferred addresses after 15 minutes. These are starting points, not published standards.
How long does one email verification check take?
A check is a short SMTP conversation. The verifier looks up the domain's MX records, connects to the highest-priority mail server, greets it, sets a sender, asks whether the recipient is accepted, and disconnects without sending a message. The RCPT TO step carries the mailbox answer. The MX lookup comes first, and every command after it is a round trip that the server controls.
On a responsive server, the exchange takes well under a second. Illustrative numbers show why this matters: five round trips at 300 ms each take 1.5 seconds. If the server pauses 8 seconds before each reply, the same exchange takes about 40 seconds. Checking 10,000 addresses on that domain one after another would take 400,000 seconds, roughly 111 hours. Parallel connections shorten that, but the arithmetic makes the point: the receiving server, more than list size, determines runtime.
RFC 5321 sets SMTP command timeouts on the scale of minutes. Those limits protect real mail delivery. A verification job that waited minutes for each reply would stall, so verifiers must choose much tighter limits. That trade-off between patience and throughput is what the rest of this guide covers.
Bottom line: On a healthy server a single check is quick. Delays come from how the receiving server answers, and your job is to wait just long enough without holding up the queue.
Why do some domains take longer than others?
Five mechanisms account for most slow domains. Each leaves a different pattern in your results, which is how you diagnose it.
| Mechanism | What the receiving server does | Pattern in your results | Why the server does it |
|---|---|---|---|
| Rate limiting | Caps connections or attempts per source IP per time window, replying with a 4xx deferral | Addresses on one domain fail in bursts, then succeed | Protects mailboxes from floods and harvesting |
| Greylisting | Temporarily rejects a first attempt from an unfamiliar sender, accepts a retry later | Consistent delay, then success on the second attempt | Cheap filter that spam senders often skip by not retrying |
| Tarpitting | Deliberately delays each reply by seconds | Each address takes tens of seconds; the job crawls | Makes bulk probing expensive |
| Catch-all acceptance | Accepts any recipient, so a single answer proves nothing | Slower results and more Risky outcomes | Stops attackers learning which mailboxes exist |
| Unresponsive or legacy hosts | Times out, drops port 25 traffic, or has no mail service behind its MX | Long waits ending in timeout | Dead, parked or misconfigured infrastructure |
Greylisting is the most misunderstood. The server answers the first attempt with a temporary 4xx code, which means "try again later", not "no such mailbox". Legitimate mail servers queue and retry. Many bulk spam tools don't. A verifier that gives up after the first reply records a valid address as unknown, which is why the retry logic matters more than the timeout.
Rate limiting is why some large consumer providers feel slow even for modest batches. Providers cap connections and attempts per source IP to protect their infrastructure. We could not find a verification-specific limit in public documentation from any major provider, so treat the limits as unknown and pace your requests.
Tarpitting works by making every reply slow. A job that spends 10 to 40 seconds per address slows to a crawl, which is the point: the server makes bulk probing expensive for whoever is doing it.
Catch-all acceptance is slow for a different reason. A server that accepts every recipient returns an answer that proves nothing about the mailbox, so the verifier must run additional probes. See how verifiers detect catch-all domains, how bounce-based catch-all verification works and what accept-all means in an email verifier.
Unresponsive hosts time out, filter port 25 or have no mail service behind their MX record. Parked and long-abandoned domains often look like this.
The reply code is the most useful diagnostic you have. Enhanced status codes follow the structure defined in RFC 3463, where the first digit separates temporary from permanent failure:
| Reply | Meaning | Correct handling |
|---|---|---|
| 2.x.x (accepted) | Server accepts the recipient | Valid, unless the domain is catch-all |
| 5.1.1 and other 5.x.x | Permanent failure, such as no such mailbox | Invalid; suppress permanently |
| 4.x.x, e.g. 4.7.0 | Temporary: throttling or greylisting | Deferred; retry later, never mark Invalid |
| No reply or timeout | Dead, filtered or tarpitted host | Retry once, then hold as uncertain, not Valid |
A full mailbox is a separate case with its own result; see what a mailbox-full result means.
Bottom line: Each slow domain follows one of five patterns, and the reply code tells you which. Read the code before you change any setting.
Is the slowness my network or the receiving domain?
Test before you change anything. Take 100 addresses from at least five domains and run them in one job, then read the pattern.
- Slow results cluster on one or two domains: the receiving server is the cause. Pace that domain and schedule a retry.
- Everything is slow: the problem is on your side. Check your concurrency setting, and check outbound port 25. Several major cloud providers block that port by default and may unblock it only on request.
- Slowness is random across domains: check DNS. Slow authoritative nameservers add time to every lookup. Timing a lookup with a tool such as
digshows whether that is the cause.
To isolate one suspect domain, test a handful of its addresses with the free email checker.
Bottom line: Clustering by domain points to the receiving server. Uniform slowness points to your setup. Random slowness points to DNS.
How do you speed up verification without getting blocked?
Speed comes from pacing and retries, not from more parallel connections. Mail servers track behaviour per connection source, and rate limits typically key on source IP. A few steady connections look like normal mail traffic. A flood of simultaneous connections to one provider looks like harvesting, and it earns more deferrals.
Use this seven-step framework:
- Group the list by domain. Count addresses per domain and identify the top ten. Those domains will determine your runtime.
- Cap concurrency for each large provider. One or two connections per provider is a sensible start.
- Allow higher concurrency for small domains. Thousands of unrelated small domains rarely interfere with each other.
- Set timeouts before you start. Without them, one dead host can hold a worker for minutes.
- Separate deferred from invalid. A 4xx reply means "try again", not "bad address".
- Run a second pass. Retry deferred addresses after 15 minutes, then once more after an hour.
- Sort the results before any slow probing. Clear Valid and Invalid results come first, and only uncertain addresses go through the slower checks.
Recommended starting settings (practitioner starting points, to be tuned against your own domains):
| Setting | Starting value | Reason |
|---|---|---|
| Connect timeout | 10 seconds | Long enough for a live host, short enough to skip a dead one |
| Per-command timeout | 30 seconds | Covers tarpitting without holding a worker for minutes |
| Per-address cap | 90 seconds | Stops one stubborn host from blocking the queue |
| Retry schedule for deferrals | 15 minutes, then 60 minutes | Clears most greylisting windows with margin |
| Connections per large provider | 1–2 | Avoids looking like a flood |
Sources disagree on the exact numbers. RFC 5321 allows minutes per command, which protects delivery but stalls bulk jobs. We recommend 30 seconds per command as the middle ground. The 15-minute first retry clears the 5-minute greylisting window that Postgrey uses by default, with room for servers that restart their timers.
Bottom line: Pace big providers, time out dead hosts, and retry deferrals on a schedule instead of rerunning the whole job.
How do you split and re-run a slow list?
This tutorial uses Unlimited Verifier and assumes you have already exported your list. If you don't have an account yet, you can sign up for a free account and rehearse the workflow on a small list first.
- Export your list as a CSV. Include the email column and any engagement fields you will need for segmenting later.
- Count addresses per domain. In a spreadsheet, pivot on the part of each address after the @ sign.
- Split by domain group, not by row count. Put each large provider in its own file, and all remaining domains in another. Row-count splits can scatter one provider across two files that run at the same time.
- Check the plan limits. On Pro, each list holds up to 25,000 emails. Files must be CSV or Excel and no larger than 10MB. On Free, each list holds up to 150 emails.
- Upload and verify a list. The email column is detected automatically.
- Read the three buckets. Valid results are safe to send. Invalid results are suppressed. Risky results often include catch-all, disposable and role addresses, so note which domains produce the most Risky results.
- Export immediately. Results are kept 24 hours on Free and 30 days on Pro. Export as CSV, Excel or JSON.
- Run the second pass. After at least 15 minutes, place deferred and uncertain addresses in a new file and run them again. Don't rerun the entire list.
- Automate if you need to. API access is on Pro, with bulk requests of up to 10,000 emails per request. Use the verification API with an API key and follow API-driven automation patterns for recurring jobs.
Before a large re-run, check email verification pricing for the plan you need. Standard verification is unlimited on every plan, so a second pass adds no per-email fee. Unlimited Verifier's public plan details don't describe per-provider pacing or timeout controls, so ask before a big job. Any vendor should answer three questions: how many connections it opens per provider, whether deferrals are retried automatically or only on resubmission, and how long results are kept.
Bottom line: Split by domain, export immediately, and treat deferrals as a second pass rather than as failures.
How long does a 31,000-contact list take to verify?
The figures below are illustrative assumptions, not measured results. The arithmetic is what matters.
The list: An ecommerce brand with 31,000 contacts: 11,000 Gmail, 5,000 Outlook and Hotmail, 3,000 Yahoo, and 12,000 spread across about 2,200 smaller domains. This is a typical ecommerce and SaaS list verification case.
Assumptions: The naive model runs at 10 checks per second across the whole list. The big-provider model paces Gmail at 2 checks per second. About 8% of Gmail addresses (880) are deferred on the first pass.
Naive estimate: 31,000 ÷ 10 = 3,100 seconds, about 52 minutes.
Gmail bottleneck:
- First pass: 11,000 ÷ 2 = 5,500 seconds, about 92 minutes
- Wait before retry: 15 minutes
- Retry pass: 880 ÷ 2 = 440 seconds, about 7 minutes
- Total: about 114 minutes, more than double the naive estimate
Why the split matters:
- Row-count split at 15,500: Gmail addresses land in both files. Both files then open Gmail connections at once, so you have four connections where you intended two, and more deferrals follow.
- Domain split: File A holds the 11,000 Gmail addresses, under the 25,000 cap. File B holds the other 20,000 (Outlook, Yahoo and the smaller domains), also under the cap. Within File B, Outlook (5,000 ÷ 2 = 2,500 seconds, about 42 minutes) and Yahoo (3,000 ÷ 2 = 1,500 seconds, about 25 minutes) each keep two connections, so File B finishes in roughly 42 minutes before retries.
Because the two files run in parallel, total wall-clock time is about 114 minutes, set by File A. The domain split doesn't make Gmail faster. It stops Gmail from spreading into a second job and keeps the other 20,000 addresses from waiting on it.
Cost: Pro is $29 for the month, or $25 a month billed annually, and it covers both files with standard verification unlimited. Free doesn't fit this job. At 150 emails per list, 31,000 contacts would need 207 lists, while Free allows 25 lists a month.
Bottom line: The slowest file sets your timing, not the total row count. Split by domain so the bottleneck runs alone at its paced rate.
What should you look for in a verifier for slow domains?
Judge a best email verification tool by how it handles slow domains, not only by its headline accuracy. These criteria matter most:
| Capability | Why it matters for slow domains | What to ask a vendor |
|---|---|---|
| Domain-aware pacing | Keeps big providers from throttling the whole job | How many connections does it open per provider? |
| Deferral handling | Greylisting and 4xx replies need a retry, not a fail | Does it retry deferrals, and when? |
| Configurable timeouts | Dead hosts and tarpits need different limits | Can I set timeouts per job? |
| Catch-all detection | Accept-all domains need extra probes | Are catch-all results kept out of Valid? |
| Result retention | You need time to export and re-run | How long are results kept? |
| Bulk input and API | Large lists need batching | What is the maximum batch size? |
Unlimited Verifier's public facts cover several of these criteria. It offers unlimited standard verification on every plan, so re-checks carry no per-email fee. It sorts results into Valid, Risky and Invalid, so uncertain results can be held back rather than treated as Valid. It detects catch-all domains, and its catch-all email verification page covers that check. On Pro, its API accepts bulk requests of up to 10,000 emails. Its public plan details don't describe per-provider pacing or timeout controls, so test those on your own domains before a large job. For checks at the point of signup, see real-time email validation. For a full checklist, read how to choose an email verifier.
Bottom line: Choose a verifier by how it paces, retries and times out, because those settings decide how long your slow domains take.
What mistakes make slow domains slower?
- Running several jobs at once against one provider. This multiplies your connections and invites more deferrals.
- Splitting by row count. It scatters one provider across files that run at the same time.
- Treating deferred addresses as invalid. A 4xx reply is a temporary answer, and many of those addresses are real mailboxes behind greylisting.
- Assuming slow means bad. Corporate domains with strict gateways are often slow and still valid. Review the Risky bucket before suppressing anything.
- Abandoning a job at the first timeout. Set per-address caps and let the rest of the queue keep moving.
- Verifying from a host that filters port 25. The results look like a domain problem when the cause is your network.
- Waiting too long to export. On Free, results are gone after 24 hours.
- Rerunning the entire list. Recheck only deferred and uncertain addresses.
- Ignoring provider quirks. Yahoo and AOL behave differently; see whether email verification works for Yahoo and AOL addresses.
- Confusing verification with consent. A valid mailbox is not an opted-in one. Build your process around email verification compliance and hygiene and email list maintenance best practices.
Bottom line: Most slow jobs are self-inflicted. Pace requests, split by domain, and keep deferrals separate from failures.
How we compared (and limitations)
This guide draws on public documentation and widely known open-source behaviour: RFC 5321 for SMTP command timeouts, RFC 3463 for enhanced status codes, Google's sender guidelines and Yahoo's sender requirements. Greylisting timing comes from the default setting of the open-source Postgrey package. These sources govern sending more than verification, so the verification-specific settings above are practitioner starting points. We have not run controlled benchmarks against any provider or verifier.
The worked-example speeds and domain counts are illustrative. Unlimited Verifier's 99.5% deep verification accuracy is the company's own stated figure, not an independent benchmark. Providers change limits without notice, so treat the timeouts above as starting points and measure your own domains. The verifier engine is open source, so you can read its SMTP logic yourself on GitHub.
Bottom line: Use these settings as a starting point, measure your own domains, and adjust.
Worked runtime example
Five SMTP round trips at 300 ms each take 1.5 seconds on a responsive server. If the receiving server pauses 8 seconds before each reply, the same exchange takes about 40 seconds. Checking 10,000 addresses on that domain one after another would take 400,000 seconds, roughly 111 hours. Parallel connections shorten this, but the receiving server's pace, not list size, drives runtime. (Illustrative numbers.)
Frequently asked questions
Why does email verification take so long for some providers?
Large providers and many corporate gateways rate-limit, greylist, or deliberately delay connections that resemble address harvesting. The verifier has to wait for each server reply, so the provider's pace sets the runtime for every address on that domain, regardless of how fast your software is.
What is greylisting and how does it slow verification?
Greylisting is a anti-spam technique where a server temporarily rejects the first connection from an unknown sender. Legitimate senders retry later and get through, so a verifier must return after a delay. Postgrey, a widely used open-source greylisting package, defaults to a 300-second delay, which is why first checks can take minutes.
How can I tell if slowness comes from my network or the receiving server?
Look at the pattern in your results. If slowness clusters on specific domains while others run quickly from the same machine, the receiving server is the likely cause. If every domain slows at once, check your own connection, DNS resolution, and outbound port availability before blaming the providers.
Should I run several verification jobs in parallel to go faster?
Usually not against a single provider. Parallel jobs multiply your connections to the same mail server, which can trigger more rate limiting and deferrals. It is generally better to pace connections per domain and spread work across many domains at once.
What timeout settings should I use for email verification?
Common starting points are a 10-second connect timeout, a 30-second per-command timeout, and a retry for deferred addresses after about 15 minutes. These are practical starting values rather than published standards, so tune them against your own results and your verifier's documentation.
Why does an address return a temporary error and then succeed later?
A temporary error, usually a 4xx SMTP code, means the server deferred the check instead of answering. Greylisting, rate limits, and temporary server load all produce this. The verifier should retry later, and a later successful answer reflects the mailbox's real status rather than a fault in the address.
Does a slow response mean the email address is invalid?
No. Slowness reflects the receiving server's behavior, not the mailbox's validity. A slow domain can host perfectly valid addresses. Judge an address by the final SMTP answer after retries, not by how long the reply took.
Why does one slow domain hold up my entire list?
Most jobs process addresses in sequence or in shared queues, so a domain with long delays blocks workers that could be checking other domains. Grouping work by domain and letting fast domains finish first keeps the overall runtime closer to the average speed instead of the slowest provider.
Is it safe to retry deferred addresses?
Yes, when retries are paced. Wait the interval the server or your verifier recommends, avoid rapid repeated connections to the same server, and cap the number of attempts. Excessive retries can look like harvesting and cause stricter limits for your future checks.
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.