Article
How Verifiers Handle Temporary SMTP Errors: Retries, 4xx Codes, and Risky Status
By Unlimited Verifier Team ·

Summary
A verifier treats a temporary SMTP error (any 4xx reply) as unresolved, not as a verdict. It retries on a spaced schedule for up to 72 hours and marks the address Risky if the mailbox still can't be confirmed. Permanent 5xx codes are handled differently, and 5.7.x blocks should never make an address look Invalid.A verifier treats a temporary SMTP error, any 4xx reply code, as an unresolved result rather than a verdict: it retries on a spaced schedule for up to 72 hours, then labels the address Risky if it still can't confirm the mailbox.
That one decision separates a trustworthy list from one that quietly deletes real customers or ships bounces. This guide explains the reply codes, the retry logic, the mistakes that cost senders money, and how to test a verifier before you trust its output. For the wider mechanics, see how email verification works.
Quick answer
- A 4xx reply means "try again later," and a 5xx reply means the rejection is permanent. A verifier must handle them differently.
- Retry on a spaced schedule: 15 minutes, 1 hour, 4 hours and 24 hours after the first attempt, with a final attempt at 72 hours.
- An address still unresolved after the window should land in Risky, never Valid or Invalid.
- You can test any verifier's handling of 4xx replies with a 40-row file, which fits inside the Free plan's 150-email list limit.
What is a temporary SMTP error?
A temporary SMTP error is a reply code in the 400–499 range. It tells the connecting server that the requested action didn't happen now but may succeed later. RFC 5321 defines the first digit: 4 is a transient negative completion, and 5 is a permanent one. RFC 3463 adds enhanced status codes, so 4.7.1 signals a temporary policy or security decision, while 5.1.1 means the destination mailbox doesn't exist.
Here is how common replies map to verifier behaviour:
| Reply | Typical meaning | Temporary? | Correct verifier action |
|---|---|---|---|
| 421 | Service unavailable; server closing the connection | Yes | Reconnect later and retry |
| 450 | Mailbox busy or temporarily refused, often greylisting | Yes | Retry with spacing; never conclude |
| 451 | Local processing error on the server | Yes | Retry |
| 452 | Insufficient storage or too many recipients in one session | Yes | Retry; reduce recipients per session |
| 4.4.x | Connection timeout or dropped session | Yes | Retry from a fresh connection |
| 550 5.1.1 | Mailbox does not exist | No | Mark Invalid |
| 550 5.7.x | Sender or IP blocked by policy or reputation | Permanent code, but about the verifier's connection | Do not mark the address Invalid; flag the block and retry later |
The last row is where many tools go wrong. A permanent-looking 5xx can say nothing about the recipient. If the receiving server has blocked the IP the verifier connects from, every address on that domain can look dead at once. Good verifiers read the enhanced code and separate 5.1.1 (an address-level failure) from 5.7.x (a sender-level decision).
Bottom line: A 4xx is a "not yet" answer, and a 5.7.x is a "not from you" answer. Neither one proves the address is bad.
Why do verifiers hit temporary errors so often?
Verifiers hit temporary errors more often than ordinary senders because of what their traffic looks like. A verifier opens a connection, runs an RCPT TO probe on each address without sending a message, and moves on. What RCPT TO means in email verification covers that probe in detail. Many connections and many recipient checks, with no actual mail, is a pattern receiving servers are built to slow down.
Two causes account for most deferrals:
- Throttling. Mailbox providers limit how quickly a single IP can open connections or ask about recipients. Exceeding the limit produces a 421 or 4.7.x deferral. Consumer providers often throttle harder than business domains, which is why our Yahoo and AOL verification guide covers pacing separately.
- Greylisting. Many mail servers reject first contact from an unknown sender with a temporary code. A legitimate server retries after a delay and gets through. Many bulk-mail bots never retry. RFC 6647 is the IETF's applicability statement on greylisting. Delays are commonly a few minutes but can be longer, which is why a single retry is often not enough.
Greylisting is the trap for verifiers. A verifier that gives up after one attempt will label a good address as undeliverable. The fix is patience, which is why retry logic matters as much as the probe itself.
Bottom line: Most deferrals come from how a verifier's traffic looks, or from greylisting that one probe can't get past.
How does a verifier decide what a temporary error means?
A verifier classifies each reply and routes the address to an outcome. The decision flow works like this:
- Connect and run the
RCPT TOprobe for the address. How an email verifier checks if an address exists walks through this step. - If the server returns 250 (accepted), the address becomes a Valid candidate. Next, test whether the domain accepts everything, using catch-all detection. A 250 on a catch-all domain proves little, so it moves to Risky.
- If the server returns 550 5.1.1, the address is Invalid.
- If the server returns any 4xx, the address is queued for retry.
- If the server returns 5.7.x or a blocklist message, the verifier treats the connection as the problem. It slows down or changes route, and it does not judge the address.
- If the address is still unresolved after the retry window, it is labelled Risky.
Step 4 is where the real engineering happens. The question is not whether to retry but how to space the attempts and when to stop.
Bottom line: Retry is the default for 4xx replies. The verifier's job is to schedule retries well and stop with an honest label.
Which handling strategy should a verifier use?
Five strategies are common in practice. Each one produces a predictable class of error.
| Strategy | Risk of false Valid | Risk of false Invalid | Assessment |
|---|---|---|---|
| Treat 4xx as Invalid | Low | High: deletes greylisted real customers | Don't use. It removes your most responsive contacts. |
| Treat 4xx as Valid | High: passes dead addresses through | Low | Don't use. It causes the bounce spikes you're trying to avoid. |
| Single immediate retry | Medium | Medium | Misses greylisting that outlasts one retry. |
| Backoff retries to about 72 hours, then Risky | Low | Low | Recommended for list cleaning. Adds hours of wait time. |
| Backoff retries, then a second full run days later | Lowest | Low | Best for large or high-stakes lists. Costs a second pass. |
Each strategy trades speed for certainty. If a campaign must go out tomorrow, the backoff approach still works, provided you send only Valid addresses and hold the Risky segment.
Bottom line: Treating 4xx replies as either Valid or Invalid is wrong, because each choice guarantees a class of error.
How long should a verifier retry a temporary error?
Retry for about 72 hours in total, using spaced attempts, and then stop with a Risky label. RFC 5321 describes sending servers retrying over a period of days, not minutes, before returning mail as undeliverable. That guidance was written for message delivery, not list verification, so a verifier can use a shorter window. The 72-hour figure is our recommendation, not a published standard.
Here is the schedule we recommend, with times measured from the first attempt:
- Attempt 1: immediately.
- Attempt 2: at 15 minutes. This clears most short greylisting delays.
- Attempt 3: at 1 hour.
- Attempt 4: at 4 hours.
- Attempt 5: at 24 hours.
- Final attempt: at 72 hours. If it still returns 4xx, label the address Risky.
Two forces drive this spacing. Retrying too soon, or in bursts, invites more throttling, and each new 4xx makes the next attempt harder. Stopping too early, however, misclassifies greylisted addresses. The 72-hour cap is a trade-off. A list's results are only useful while they're fresh, and holding a 50,000-row file open for a week rarely serves a campaign calendar.
Also cap concurrency per receiving domain and spread probes across time. The right limits depend on the provider and change over time, so treat them as tuning decisions. Start conservatively, watch the 4xx rate, and loosen only if deferrals stay low.
Bottom line: Space retries across hours, stop at about 72 hours, and remember that speed can cause the very deferrals you're retrying.
What should happen to addresses that stay Risky?
An address that stays Risky after retries is neither proven good nor proven bad. It is held. Keeping it out of campaigns is part of sound email verification compliance and hygiene, because sending to unconfirmed addresses is how bounces and complaints start.
Work the Risky segment in this order:
- Re-verify after a few days. Greylisting and throttling problems often clear on their own, so a second look can resolve many of them.
- Check recent engagement. An address that opened or clicked in the last 90 days has a stronger case than one dormant for years.
- Decide by segment. Recent engagers can get a small test send after re-verification. Dormant addresses should be suppressed.
Deep verification versus standard verification explains how the two tiers differ, which matters when you choose what to re-check. For what "deliverable" actually promises, see what deliverable means in email verification.
Bottom line: Risky means "not yet proven." Hold it, re-check it, and let engagement decide what happens next.
How do you tell a temporary block from a permanent one?
A temporary block affects your verifier's connection, not the addresses on the list. Three signals help you tell them apart:
- Failures concentrated on one domain. If every address at one provider returns 4xx or 5.7.x for days, the cause is almost certainly your IP or pacing, not the addresses.
- Normal results elsewhere. If other providers resolve normally, the block is domain-specific, and the fix is slower pacing for that domain.
- Blocklist listings. Check your sending domain and IP against public blocklists. Unlimited Verifier's free domain blacklist checker covers the domain side of that check.
When a block is confirmed, slow the probe rate, pause that domain, and retry later. Do not start deleting addresses.
Bottom line: Failures concentrated on one domain point to your connection. Failures spread across the whole list point to the list.
How do you test a verifier's handling of temporary errors?
You can test how any verifier handles 4xx replies in about 30 minutes, using the Free plan. Run this before you commit to one of the best email verification tools, so you're judging behaviour rather than marketing.
- Build a 40-row CSV with three groups:
- 15 addresses you know are real, such as your own team's inboxes.
- 10 addresses on a made-up domain or with a made-up user. These should come back Invalid.
- 15 addresses at a server you control with greylisting enabled. If you don't run one, use a domain you know throttles, and expect inconsistent or Risky results.
- Sign up free. The Free plan allows 25 lists a month of up to 150 emails each, so 40 rows fits in one list.
- Upload your file. The email column is detected automatically. CSV and Excel files up to 10MB are accepted.
- Run the verification and read the Valid, Risky and Invalid buckets.
- Score the results:
- Real addresses should be Valid, or Risky if they sit on a catch-all domain.
- Fake addresses should be Invalid.
- Greylisted addresses should be Valid or Risky, never Invalid.
- Export immediately. Free plan results are kept for 24 hours, so save the CSV before any retry pass.
- Re-run the greylisted group an hour later and compare the outcomes.
Any real address labelled Invalid, or any fake address labelled Valid, is a red flag. Log the results in a simple table to rank tools. For more questions to ask, use the buyer's checklist for choosing an email verifier.
Bottom line: A 40-row file with known-good and known-bad addresses reveals a verifier's handling of 4xx replies faster than any spec sheet.
How do you clean a real list that returned temporary errors?
Export, verify, hold the Risky segment, re-check it, and re-import only what is confirmed. Teams doing email verification for ecommerce and SaaS usually follow this pattern.
- Export your contacts from your ESP or CRM as a CSV. Include the email column and engagement fields such as last open or last purchase.
- Split files over 25,000 rows. Pro lists are capped at 25,000 emails each.
- Upload each file and run verification.
- Export the results as CSV, Excel or JSON. On Pro, results are kept for 30 days, which covers a 72-hour retry window with room to spare.
- Separate the Risky segment and hold it out of campaigns.
- Re-check the Risky segment after a few days. For automation, the email verification API provides single-email checks, and bulk batches of up to 10,000 emails per request. API access is included on Pro, which covers 100,000 emails a month. Email verification API and automation patterns show how to schedule these checks.
- Re-import only Valid contacts into your ESP, and add Invalid addresses to its suppression list. Unlimited Verifier has no native ESP, CRM or Zapier integrations, so this step is a CSV re-import or an API call from your own code.
For a broader routine, see email list maintenance best practices.
Bottom line: Verify the whole list, hold what's unresolved, re-check it on a schedule, and re-import only what is confirmed.
What does a 3.2% temporary-error rate cost you?
The arithmetic below is illustrative: the 3.2% rate and the resolution rate are hypothetical, while the plan limits and prices are real.
Setup. A SaaS company holds 50,000 contacts. The Pro list cap is 25,000 emails, so the file splits into two uploads of 25,000. On the Free plan the same list is impossible in one month. Twenty-five lists of 150 emails cap out at 3,750 addresses.
First pass:
- 50,000 contacts verified.
- 3.2% returned temporary errors: 50,000 × 0.032 = 1,600 deferred addresses.
Retry pass: After the backoff schedule, 1,120 of the 1,600 resolve, a 70% resolution rate.
- Resolved to Valid: 1,050.
- Resolved to Invalid: 70.
- Still unresolved, labelled Risky: 1,600 − 1,120 = 480.
Why the handling matters:
- If you delete all 1,600 deferred addresses, you lose 1,050 real contacts. That is 1,050 ÷ 50,000 = 2.1% of the list, removed for no reason.
- If you treat all 1,600 as Valid, the dead addresses become bounces. The worst case is 70 + 480 = 550 bounces, or 550 ÷ 50,000 = 1.1%. That is already more than half of the 2% ceiling most senders should plan around.
- If you hold the 480 Risky addresses, your send list starts with confirmed addresses only.
Cost. Standard verification is unlimited on every plan, so the first pass and any re-check carry no per-email fee. Pro costs $29 a month, or $25 a month billed annually, and includes 25,000 deep verifications. If you used the full deep allowance, that works out to $29 ÷ 25 = $1.16 per 1,000 deep checks on monthly billing, or $1.00 per 1,000 on annual billing. These are effective costs of the allowance, not per-email fees. For how pricing models compare, see email verification pricing.
Timing. Pro results are kept for 30 days, so the 72-hour retry window fits comfortably. On Free, you would need to export after each run.
Bottom line: A 3.2% deferral rate looks small, but how you handle those 1,600 addresses decides whether you lose 2.1% of real contacts or ship up to 1.1% in bounces.
What mistakes do people make with temporary SMTP errors?
Most damage comes from two shortcuts: classifying 4xx replies as either verdict, or retrying too fast.
- Treating a 4xx as Invalid. This deletes greylisted customers, often your most engaged contacts, because engaged contacts' mail servers are the ones most likely to be configured with greylisting and quick follow-up.
- Treating a 4xx as Valid. This sends unverified addresses into campaigns, and the bounces accumulate.
- Retrying in tight bursts. Each burst invites more throttling, so the next run returns more 4xx replies.
- Confusing a 5.7.x block with a 5.1.1 address failure. A decision about your IP is not evidence about a recipient.
- Running one pass and calling the list clean. A single pass always leaves a deferred segment behind, and that segment is where the risk sits.
- Ignoring result expiry. Free results last 24 hours, so a retry scheduled for the next day finds nothing to re-check.
- Sending to Risky addresses first. Hold them until the Valid segment has shown stable results.
- Treating a catch-all acceptance as proof. A 250 on a catch-all domain doesn't confirm the mailbox. Bounce-based catch-all verification explains how that gets tested, and catch-all email verification covers how Unlimited Verifier flags these domains.
Bottom line: Don't let a temporary code decide an address's fate, and don't let a single pass declare a list clean.
How we compared (and limitations)
This guide draws on public standards and documentation: RFC 5321 for reply-code classes and retry guidance, RFC 3463 for enhanced status codes, RFC 6647 for greylisting, and the Wikipedia greylisting page for a general overview. We have not run controlled tests against any provider's servers, and provider-specific throttling thresholds change without notice.
The retry schedule and the 72-hour stop are our recommendations, not published standards. The worked example uses hypothetical percentages.
Unlimited Verifier states 99.5% accuracy for deep verification. That is the company's own figure, not an independent benchmark. We have not seen a published description of how any vendor, including Unlimited Verifier, schedules retries for 4xx replies, so ask every vendor to document it. Then run the 40-row test above before you rely on the results.
Bottom line: Standards define the codes, but retry policy is a vendor decision, so verify it with your own test.
SMTP reply handling for verifiers
| Reply | Temporary? | Correct verifier action |
|---|---|---|
| 421 | Yes | Reconnect later and retry |
| 450 | Yes | Retry with spacing; never conclude |
| 451 | Yes | Retry |
| 452 | Yes | Retry; reduce recipients per session |
| 4.4.x | Yes | Retry from a fresh connection |
| 550 5.1.1 | No | Mark Invalid |
| 550 5.7.x | Sender/IP block | Do not mark Invalid; flag and retry later |
Frequently asked questions
What is a temporary SMTP error?
A temporary SMTP error is a reply code in the 400-499 range. It means the requested action did not happen now but may succeed later. RFC 5321 defines the first digit as a transient negative completion, and RFC 3463 enhanced codes such as 4.7.1 add detail.
What is the difference between a 4xx and a 5xx SMTP error?
A 4xx reply is temporary and suggests retrying later. A 5xx reply is permanent. A verifier should retry 4xx replies and should not mark an address Invalid based on a 5xx reply that concerns the sender or IP rather than the mailbox.
How long should a verifier retry a temporary error?
A common approach is a spaced schedule, such as 15 minutes, 1 hour, 4 hours, and 24 hours, with a final attempt around 72 hours. If the address still cannot be confirmed, it should be labelled Risky rather than Valid or Invalid.
Why does a verifier get greylisted?
Greylisting is a anti-spam technique where a receiving server temporarily rejects first-time connections, often with a 450 reply. Verifiers make many connections and recipient probes without sending mail, a pattern that receiving servers often slow down.
What does a 5.7.x error mean during verification?
A 5.7.x enhanced code usually reflects a policy or reputation decision, such as blocking the sender or IP. It is about the verifier's connection, so it does not prove the recipient address is invalid. Good verifiers flag these and retry later.
Should Risky addresses be sent to?
Risky addresses are unconfirmed, so they carry more bounce and complaint risk than Valid ones. Most senders suppress them or send only low-volume re-engagement mail, and they should not be treated as confirmed deliverable.
Can I test how a verifier handles 4xx errors?
Yes. Build a small test file with known good, known bad, and suspected greylisted or busy domains, then compare results and retry behaviour across runs. Check that 4xx results land in Risky rather than Invalid.
Why do 421 and 452 errors appear during verification?
421 usually means the server is closing the connection due to load, and 452 can mean insufficient storage or too many recipients in one session. Verifiers that send many probes per connection are more likely to see them, so reducing recipients per session helps.
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.