Article
What Checks Does an Email Verifier Run? A Layer-by-Layer Guide
By Unlimited Verifier Team ·

Summary
An email verifier runs layered checks, starting with syntax, then domain and MX routing, an SMTP mailbox probe, and finally flags for catch-all, disposable and role-based addresses. Each address is labelled Valid, Risky or Invalid based on which layers pass. Understanding what each layer tests helps you decide which addresses to mail, hold back, or suppress.An email verifier runs its checks in layers, starting with the cheapest: syntax, domain and MX routing, an SMTP mailbox probe, then flags for catch-all, disposable and role-based addresses. Each address ends up labelled Valid, Risky or Invalid.
For the broader workflow, read our full guide to how email verification works. This article goes a level deeper: what each check tests, how it runs, where it fails, and what to do with the result.
Quick answer
- Syntax: Confirms the address is well formed under RFC 5321 and RFC 5322. The local part is capped at 64 characters, and the full address at 254.
- Domain and MX: Confirms the domain exists in DNS and can receive mail, through an MX record or the A-record fallback.
- SMTP mailbox probe: Asks the receiving server whether the mailbox accepts mail, without sending a message. It is the only layer that tests the individual address.
- Flags: Catch-all domains, disposable providers and role accounts such as info@ are flagged separately, because each one weakens a plain "Valid" label.
- Sorting: Send to Valid addresses first, hold Risky ones back, and suppress Invalid ones.
What does each check in an email verifier actually test?
Each layer answers a different question. A perfectly formed address can belong to a domain that doesn't exist, and a real domain can still hide a mailbox closed years ago. A pass at one layer tells you nothing about the others.
| Layer | Question it answers | How it runs | Typical failure |
|---|---|---|---|
| Syntax | Is this a well-formed address? | Grammar and length rules from RFC 5321 and RFC 5322 | Missing @, double dots, spaces |
| Domain | Does the domain exist? | DNS lookup for the domain | Non-existent domain, typo domain |
| MX / routing | Can mail reach this domain? | MX lookup, A-record fallback, null-MX check | No mail server, or a null MX |
| SMTP mailbox | Does this mailbox accept mail now? | Handshake that stops before any message body | Server rejects the recipient as unknown |
| Catch-all | Does the domain accept any address? | Probe a random address on the same domain | Every probe accepted, so no mailbox can be confirmed |
| Disposable | Is this a throwaway provider? | Match against curated lists of temporary-mail domains | Known throwaway domain |
| Role-based | Is this a shared inbox? | Match the local part against role names | info@, sales@, support@, admin@ |
The first four layers answer whether mail can be delivered. The last three answer how much an address is worth mailing. Verifiers that stop at the first four return lists that look clean but still contain shared inboxes and accept-all domains.
Bottom line: Treat each layer as a separate test. A "Valid" label is only as strong as the layers that actually ran on that address.
How does the syntax check work, and what does it miss?
The syntax check tests whether an address follows the grammar in RFC 5321 and RFC 5322. It rejects missing or repeated @ signs, leading, trailing or consecutive dots, spaces, and illegal characters. Our explainer on syntax validation covers the grammar rules in detail.
Two details trip up homemade checkers:
- Plus-addressing is valid.
jane.doe+newsletter@example.comis legal. A verifier that rejects it is enforcing a policy you didn't ask for. - The RFC allows more than most lists contain. Quoted local parts such as
"john doe"@example.comare legal under RFC 5322. Rejecting them is a deliberate choice. For marketing lists it is usually safe, but you should know which choice your tool makes.
Syntax is the cheapest layer because it needs no network access. It also misses the most common real-world error. jane@gmial.com is perfectly well formed, so it passes syntax and has to be caught by the domain layer or a typo flag.
Bottom line: Syntax removes obvious junk at no network cost, but it cannot tell you whether an address receives mail. Most teams find the expensive failures are the ones that look correct on the page.
How do DNS and MX checks decide whether a domain can receive mail?
The domain check asks DNS whether the domain exists. A "non-existent domain" response is a firm failure, so the address goes to Invalid. The MX check then asks which servers accept mail for the domain. An MX record names those hosts, each with a preference value.
Three nuances matter:
- The A-record fallback. RFC 5321 says that if a domain has no MX record but does have an A record, mail should be delivered to the host at that A record. A verifier that marks every domain without MX as Invalid will produce false Invalids. Well-built checks follow the fallback.
- Null MX. RFC 7505 defines a null MX record, which states explicitly that a domain accepts no mail. Here Invalid is correct, and it is one of the few DNS results you can treat as a firm answer.
- Timeouts are not failures. A lookup that times out says nothing about the domain. The correct label is Risky, retried later, not Invalid.
Bottom line: DNS and MX results are fast and reliable when they give a clear answer. Errors come from reading silence or an unusual record setup as a rejection.
How does the SMTP mailbox check work, and what do the reply codes mean?
The SMTP probe is the only layer that tests a specific address, and it is the check most people mean by "email verification." The verifier connects to the domain's highest-priority mail server on port 25 and runs a short conversation:
- Connect to the mail server.
- Send EHLO to introduce itself.
- Send MAIL FROM with a sender address.
- Send RCPT TO with the address under test. This is the step explained in what RCPT TO means in verification, and the wider logic is covered in how an email verifier checks whether an address exists.
- Read the reply code.
- Send QUIT before any DATA command, so no message body is transmitted.
The reply code carries the verdict. The enhanced status codes below come from RFC 3463.
| Reply | Meaning | Recommended label |
|---|---|---|
| 250 (2.1.5) | Recipient accepted | Valid, unless the domain is catch-all |
| 550 (5.1.1) | Mailbox does not exist | Invalid |
| 550 (5.1.2) | Bad destination host | Invalid |
| 452 or 552 (4.2.2 / 5.2.2) | Mailbox full | Risky, see mailbox full results |
| 421 or 451 (4.x.x) | Temporary deferral, often greylisting | Risky, retry later |
| 554 or 5.7.x | Policy or security refusal | Risky |
| Timeout or no connection | No usable answer | Risky, retry |
Three points matter in practice:
- A 4xx reply is a deferral, not a rejection. Greylisting is an anti-spam technique that returns a temporary failure on first contact. A verifier that counts that as Invalid removes real customers. Retry instead.
- A 250 is not always proof. Many domains accept every recipient at the SMTP stage and sort out delivery afterwards. That is why the catch-all layer exists.
- Probing is rate-sensitive. Servers throttle hosts that open many connections in a short period. Good verifiers spread probes across domains and retry deferrals. This is also why some domains are slower to check, which we cover in why some domains verify slowly.
Bottom line: The mailbox probe gives the strongest evidence about an individual address, but it is a snapshot shaped by how the receiving server behaves. Read the reply code, not just pass or fail.
How do catch-all, disposable and role-based flags work?
These flags don't prove an address is bad. They tell you how far to trust the label.
Catch-all domains. A catch-all domain accepts mail to any local part. To detect one, the verifier probes a random, non-existent address on the same domain. If that address is accepted, every acceptance on the domain is meaningless. A sound verifier labels these addresses Risky. The method is explained in how verifiers detect catch-all domains, and the alternative approach is in how bounce-based catch-all verification works. Unlimited Verifier detects catch-all domains; see catch-all email verification for how they are handled.
Disposable domains. Throwaway providers are identified by matching the domain against curated lists. Those lists go stale, so a new disposable domain can pass until someone adds it. Treat the flag as strong evidence, not a complete record. Our guide to how disposable domains are spotted covers the matching in more detail.
Role-based addresses. Local parts such as info, sales, support, admin, postmaster and noreply usually route to a shared inbox. The mailbox is real, but no individual asked for your email. For marketing lists, role addresses are normally held back rather than deleted.
Typos. Many verifiers compare domains against common providers, so a domain such as gmial.com can be suggested as gmail.com. A suggested correction should be reviewed rather than applied automatically, because a wrong fix sends mail to a stranger.
Bottom line: These flags change the label, not the underlying fact. Use them to decide sending order and suppression, not as proof an address is dead.
What can an email verifier not tell you?
Vendor summaries rarely cover this section, but it determines how much weight a clean report deserves.
- Consent. Verification cannot prove someone opted in. A live mailbox can still be a purchased or scraped address. The consent side of list hygiene is covered in email verification compliance and hygiene.
- Engagement. A verifier can't tell whether anyone reads the mail, so an active mailbox can still be a poor target.
- Spam traps. Recycled traps are addresses providers repurpose to catch senders who don't clean their lists. A trap can accept mail at the SMTP stage, so a Valid label does not rule one out.
- Inbox placement. A mailbox that accepts a message may still file it in spam.
- Hidden mailboxes. Some providers reveal less about whether a mailbox exists, which limits what the probe can prove for those domains. Yahoo and AOL are commonly cited examples, covered in whether email verification works for Yahoo and AOL addresses.
On accuracy, Unlimited Verifier states 99.5% accuracy for deep verification. That is the company's own figure, not an independent benchmark, and it describes classification, not the inbox outcome of every send.
Bottom line: Verification answers "can this address receive mail right now," not "does this person want it." Pair it with consent records and engagement data.
What do Valid, Risky and Invalid mean for your sends?
The labels are a policy, and the policy matters more than the names. The mapping below is our recommendation, and it sets the action each label should trigger.
| Label | Typical triggers | Action |
|---|---|---|
| Valid | Syntax, domain and MX pass; mailbox accepted; not catch-all, disposable or role-based | Send first, starting with the most engaged segment |
| Risky | Catch-all, disposable, role-based, mailbox full, temporary deferral, unresolved timeout | Hold back; send last, in small segments, or don't mail |
| Invalid | Syntax failure, non-existent domain, null MX, mailbox rejected as unknown | Suppress permanently, and don't re-import |
Unlimited Verifier sorts every address into Valid, Risky or Invalid, and raises the flags described above on each address. Use those flags to decide what happens next, not just the bucket totals.
Bottom line: Valid is for sending, Risky is for holding back, and Invalid is for removing. Don't let Risky addresses slip into the first send because they look Valid.
How do you run these checks on your own list?
Follow these steps to verify a list end to end. No native ESP or CRM integration is required: you export a CSV, verify it, and re-import the results, or call the API from your own scripts.
- Export a CSV from your ESP or CRM, with the email column and any engagement fields such as last open or signup date.
- Sign up for a free account. The Free plan covers 25 lists a month of up to 150 emails each, with 750 deep verifications a month. Start with a sample file to check the output format.
- Upload and verify a list. CSV and Excel files up to 10MB are accepted, and the email column is detected automatically. Confirm the detected column before you run the job.
- Run standard verification on the full list. Standard verification is unlimited on every plan, with no per-email fee.
- Deep-verify the segments that matter most. The Free plan includes 750 deep verifications a month and Pro includes 25,000. Spend them on dormant, imported or high-value contacts first.
- Work through the Risky bucket by flag. Catch-all, role and disposable addresses each need a different decision.
- Spot-check edge cases with the free email checker, especially a VIP contact that came back Risky.
- Export the results as CSV, Excel or JSON before the retention window closes. Results are kept for 24 hours on the Free plan and 30 days on Pro.
- Re-import only the Valid contacts into your ESP as a new segment, and suppress the Invalid ones.
For automation, the email verification API supports 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; the Free plan has no API access. Teams that want to verify at the point of signup can follow our guide to real-time email validation. For the wider automation patterns, see email verification API and automation.
Bottom line: Export, verify, work the Risky bucket by flag, re-import only Valid contacts, and export results before they expire.
Worked example: verifying a 60,000-row list on Pro
This example is illustrative. The plan limits and arithmetic are real; the outcome counts are hypothetical.
Scenario. A B2B company has 60,000 contacts. About 18,000 came from a trade-show import and haven't been mailed in two years. The team needs a clean list before re-engaging.
Splitting the file. Pro allows lists of up to 25,000 emails each, so the file splits into three:
25,000 + 25,000 + 10,000 = 60,000 contacts across three lists
Standard verification. All 60,000 contacts run at standard level. There is no per-email fee, so this step costs only the plan price.
Deep verification. Pro includes 25,000 deep verifications a month. The team spends them on the riskiest contacts:
18,000 (imported leads) + 7,000 (re-checks and spot-checks) = 25,000, exactly the monthly allowance
Cost. Pro is $29 a month, or $25 a month billed annually. Spread across the full 25,000 deep-verification allowance, that is $1.16 per 1,000 deep verifications on monthly billing, or $1.00 per 1,000 on the annual plan. For how verification pricing is structured across vendors, see email verification pricing.
Illustrative results:
| Label | Count | Share of 60,000 |
|---|---|---|
| Valid | 51,300 | 85.5% |
| Risky | 5,400 | 9.0% |
| Invalid | 3,300 | 5.5% |
| Total | 60,000 | 100% |
Inside the buckets (the team's own tally by cause):
- Invalid (3,300): 410 failed syntax, 620 had a non-existent domain or no mail route, and 2,270 were rejected as unknown mailboxes.
- Risky (5,400): 3,100 were catch-all, 1,250 role-based, 380 disposable and 670 mailbox-full or temporary deferrals.
What the team does next. The 51,300 Valid contacts form the re-entry list, sent in engagement order. The 2,270 unknown-mailbox addresses are suppressed, since that is where most dead addresses sit. The 3,100 catch-all addresses are the largest Risky group, so the team tests them in a small segment and logs the results rather than including them in the first send.
Free-plan comparison. A 150-row list fills the Free plan's per-list limit. The 750 monthly deep verifications cover five full lists of that size (5 × 150 = 750). The monthly upload ceiling is 25 lists × 150 emails, or 3,750 emails.
Bottom line: Splitting within the 25,000-per-list cap and spending the deep allowance on the imported segment turns a 60,000-row list into a labelled, auditable result for $29.
What should you ask a verifier about its checks?
When you compare tools, the layers above give you specific questions to put to each vendor. Our guides to the best email verification tools and how to choose an email verifier go deeper on comparison.
- Does it separate catch-all results from genuine acceptances, or does every 250 count as Valid?
- Does it flag disposable, role-based and catch-all addresses individually, so you can act on each one?
- How does it handle 4xx deferrals and timeouts? Does it retry, or mark them as failures?
- How long are results kept, and in which formats can you export them?
- Can you inspect the implementation? Unlimited Verifier publishes its verification engine as open source on GitHub, so you can read the approach directly. Ask whether the hosted service runs the same checks.
Bottom line: Ask how each check is handled, what gets retried, and how long results are kept, not just for an accuracy headline.
What are the most common mistakes?
- Treating syntax-valid as deliverable.
jane@gmial.compasses syntax, and an old mailbox can still reject mail. - Counting a 250 on a catch-all domain as Valid. The probe proves little when the domain accepts everything.
- Marking 4xx responses and timeouts as Invalid. These are deferrals, and they often remove real customers.
- Sending Risky addresses in the first wave. They belong at the end of the ramp.
- Ignoring domain-level patterns. If one domain is catch-all across hundreds of addresses, treat the whole domain as a segment.
- Spending deep verifications on the wrong contacts. A customer who opened last week rarely needs a deep check. Put the allowance on dormant and imported contacts.
- Missing the retention window. Export results before the 24-hour (Free) or 30-day (Pro) limit passes.
- Assuming a clean report rules out spam traps or consent gaps. Verification can do neither.
- Verifying once and never again. Lists decay as people change jobs or abandon addresses, which is why list maintenance best practices recommend a regular schedule.
Bottom line: Most errors come from reading the label without reading the reason behind it.
How we compared (and limitations)
This article is based on public documentation: the address and SMTP rules in RFC 5321, RFC 5322 and RFC 3463, the null-MX definition in RFC 7505, and Unlimited Verifier's published plan facts. We have not benchmarked any verifier against a controlled sample, and we make no claims about how other vendors' checks perform. The M3AAWG industry association is a useful reference for broader sender practices.
Limitations to keep in mind:
- SMTP behaviour varies by provider and changes over time, so the mailbox layer is a snapshot, not a guarantee.
- The 99.5% deep-verification accuracy is Unlimited Verifier's stated figure, not an independent result.
- The worked-example counts are hypothetical. The plan limits and arithmetic are real.
Bottom line: Use these layers as a framework for judging any verifier, and test one on a sample of your own list before you commit a full database.
Sorting verified addresses into send, hold and suppress
- Valid (all layers pass, no flags): Send in normal campaigns.
- Risky (catch-all, role-based, or unknown): Hold back. Send only to recent engaged contacts, or test with a small batch first.
- Invalid (syntax, domain, MX or mailbox rejected): Suppress. Remove from future sends to protect sender reputation.
- Disposable: Suppress unless you have a specific reason to keep the contact.
Re-verify the Risky group periodically, since mailbox status changes over time.
Frequently asked questions
Does an email verifier send an email to the address?
No. A verifier opens an SMTP handshake with the receiving mail server, checks whether it accepts the recipient, and disconnects before any message body is sent. No email is delivered to the mailbox during this probe.
What is a catch-all domain?
A catch-all domain is one whose mail server accepts mail for any address, real or not. Because every probe returns accepted, a verifier cannot confirm whether a specific mailbox exists, so these addresses are usually labelled Risky.
Why does a verifier flag disposable email addresses?
Disposable providers offer temporary inboxes that expire, so an address can pass every technical check and still be worthless for long-term contact. Verifiers match domains against curated lists of known throwaway providers to flag them.
What are role-based email addresses?
Role-based addresses such as info@, sales@, support@ and admin@ belong to a team or function rather than one person. They often deliver, but they are shared and may have low engagement, so verifiers flag them separately.
Can a valid-looking address still bounce?
Yes. A mailbox can be closed after a verification, a domain can change mail providers, or the server may block probes. This is why verification results are a snapshot in time rather than a permanent guarantee.
What does an MX record check tell you?
An MX check confirms that a domain has mail servers listed in DNS and can receive mail. If no MX record exists, the verifier may fall back to the domain's A record. A null MX record signals that the domain does not accept email.
Does syntax validation reject plus signs in addresses?
No. Plus-addressing such as jane+newsletter@example.com is valid under the standards. A checker that rejects it is applying an overly strict rule and may discard real customers.
What should I do with Risky addresses?
Hold them back from regular campaigns rather than deleting them. Risky addresses include catch-all and some role-based results, so you can review engagement history, send a low-volume re-engagement message, or suppress them if they stay inactive.
Why do some verifiers return Unknown results?
Unknown usually means the receiving server did not give a clear answer, for example because it rate-limits probes, greylists the connection, or blocks verification attempts. The result reflects the server's behaviour, not a verdict on the mailbox.
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.