Article
How Does an Email Verifier Check If an Address Exists?
By Unlimited Verifier Team ·

Summary
An email verifier checks an address in three layers: syntax validation, a DNS lookup for the domain's MX records, and an SMTP probe that asks the receiving server whether it will accept mail for that mailbox. A 250 reply means accepted and a 550 reply means rejected, and the verifier ends the session before any message content is sent.An email verifier checks whether an address exists in three layers: it validates the syntax, looks up the domain's MX records, then asks the receiving server over SMTP whether it will accept mail for that mailbox (250 means accepted, 550 means rejected). The verifier never delivers a message. It ends the conversation before any content is sent.
Quick answer
- Syntax: The address is checked against the message format rules in RFC 5322. Typos such as spaces or a missing
@fail here, at no network cost. - Domain and MX: A DNS lookup confirms the domain can receive mail. No MX record and no fallback address record means the address is Invalid.
- SMTP probe: The verifier sends
RCPT TO:for the mailbox. A250reply means accepted. A550 5.1.1reply means the mailbox does not exist. - The blind spot: On catch-all domains, every address gets a
250, so the reply proves nothing about one person. These belong in Risky. - Accuracy: Unlimited Verifier states 99.5% accuracy for its deep verification. That is the company's own figure. Test any verifier on known-good and known-bad addresses from your own list before you rely on it.
Why does checking whether an address exists matter?
Checking existence matters because bounces damage sender reputation, and reputation decides whether your next campaign reaches the inbox. Every hard bounce tells a mailbox provider that you are mailing addresses you have not maintained.
For bulk senders, the stakes are explicit. Google's sender guidelines set expectations for spam complaints, and they make clear that list quality feeds into how mail is treated. Bounces and complaints are separate signals, but they tend to rise together on neglected lists.
The problem is worst for email verification for ecommerce and SaaS businesses. Sign-up forms accept typos and throwaway addresses, and B2B contacts change jobs constantly. A list that was clean two years ago can be a bounce risk today.
Bottom line: Existence checks protect your sender reputation before you send, which is cheaper than repairing that reputation afterwards.
Why is it hard to confirm that an email address exists?
There is no public directory of mailboxes. SMTP was designed to deliver mail, not to report whether a mailbox exists. The protocol does include a VRFY command for asking a server directly, as RFC 5321 describes. In practice, many servers disable it or return a non-committal answer, because it can leak account information.
So a verifier has to infer existence indirectly. It asks each receiving server to commit to a decision at the recipient step, then reads the answer. That is why results come in grades (Valid, Risky, Invalid) rather than a simple yes or no.
Bottom line: Verification is inference from server responses, not a lookup in a database of people. It produces graded evidence, not proof.
How does syntax checking work?
Syntax checking tests whether the address follows the grammar of an internet message address. The local part (before the @) and the domain (after it) each have rules. RFC 5321 limits the local part to 64 octets and the domain to 255.
Syntax is the cheapest layer because it needs no network traffic. It catches:
- Spaces, double
@signs or a missing@. - Consecutive dots, or a leading or trailing dot in the local part.
- Domains with no dot, such as
jane@gmailcom. - Characters that cannot appear unquoted.
Here is a point many guides skip. RFC 5322 is far more permissive than real mail providers. It allows quoted local parts such as "john doe"@example.com, and most large providers will not deliver to them. A strict verifier therefore applies tighter rules than the RFC, because mailing an address the provider will never accept is pointless. Choosing how strict to be is a real trade-off. A verifier that is too lax passes addresses that will bounce. One that is too strict rejects unusual addresses that do work. For the full rule set, see what is RFC 5322 email syntax.
Syntax checks also cannot tell you that gmial.com is a typo. That string is syntactically valid, so the next layer has to catch it.
Bottom line: Syntax checks are fast and free, and they remove obvious junk, but they say nothing about whether the mailbox exists.
How do domain and MX lookups confirm a domain can receive mail?
A verifier queries DNS for the domain's MX records, which name the mail servers that accept mail for that domain. If no MX record exists, RFC 5321 allows a sender to fall back to the domain's address (A) record as an implicit mail server. If neither exists, the domain cannot receive mail, and the address is classified as Invalid.
This layer produces two useful side effects:
- Provider identification. The MX hostname shows which system hosts the mail. Google Workspace domains typically point at Google's
aspmxhosts, and Microsoft 365 domains typically point atmail.protection.outlook.com. Knowing the provider tells you which behaviour to expect in the next layer. - Caching. Business and consumer lists often concentrate on a fairly small number of domains. A well-built verifier caches MX results per domain, so a 50,000-row list does not trigger 50,000 separate DNS queries.
Dead or parked domains are common among typos and old sign-ups. Some have no MX record at all. Others have MX records that point at hosts that never answer. A lookup can succeed while the mail server stays silent, so the verifier treats those cases as failures at the SMTP layer.
For a deeper walkthrough, see what is an MX record lookup in email verification.
Bottom line: A domain with no working mail server makes every address on it Invalid, and the MX hostname tells you which provider's rules apply next.
What happens in the SMTP mailbox probe?
This is the step most people mean when they ask how verification "checks the address." The verifier opens a TCP connection to the MX host on port 25 and runs a short SMTP dialogue. Here is a simplified transcript, using the reserved example.com domain:
S: 220 mx.example.com ESMTP ready
C: EHLO verifier.example.net
S: 250 mx.example.com Hello
C: MAIL FROM:<probe@verifier.example.net>
S: 250 2.1.0 Sender OK
C: RCPT TO:<jane.doe@example.com>
S: 250 2.1.5 Recipient OK
C: RSET
S: 250 2.0.0 Reset
C: QUIT
S: 221 2.0.0 Bye
The commands do the following:
- EHLO introduces the verifier to the server.
- MAIL FROM names a sender. The server may check this sender's identity and reputation.
- RCPT TO asks whether this mailbox would be accepted. This is the decisive step.
- RSET and QUIT end the session. The verifier never sends
DATA, the command that starts the message body. That is why a probe delivers nothing.
The full sequence is explained in what happens during an SMTP handshake check. For the question of whether the server ever "sends" anything to the recipient, see does email verification send an email to the address.
Two details separate a reliable probe from a misleading one:
- The sender identity matters. Servers can refuse at
MAIL FROMif the connecting IP has no reverse DNS, or if the sender looks unlike a legitimate mail source. A badly configured verifier can make valid addresses look dead. This is one of the more common hidden causes of false negatives. - Port 25 must be open. Many residential connections and some cloud networks block outbound port 25. Running a probe from a laptop is unreliable at scale for this reason alone.
Bottom line: The RCPT TO reply is the verifier's evidence, and the probe is only as trustworthy as the sending identity and network behind it.
What do the server's response codes mean?
Every SMTP reply starts with a three-digit code. Many servers also send an enhanced status code such as 5.1.1, which gives the reason, as defined in RFC 3463. The first digit matters most: 2 is success, 4 is a temporary failure worth retrying, and 5 is a permanent failure.
Here is the classification a careful verifier should apply:
| Reply | Enhanced code | What it usually means | Correct classification |
|---|---|---|---|
250 |
2.1.5 |
Recipient accepted | Valid candidate, pending catch-all check |
550 |
5.1.1 |
Mailbox does not exist | Invalid |
552 |
5.2.2 |
Mailbox full (over quota) | Risky: the mailbox exists but may not take mail. See what a mailbox full result means |
450 / 451 |
4.x.x |
Temporary deferral, often greylisting or rate limiting | Retry later, never mark Invalid |
421 |
4.7.0 |
Server temporarily unavailable or throttling | Retry with backoff |
550 / 554 |
5.7.1 |
Policy refusal, often tied to sender reputation | Risky or inconclusive, not Invalid |
Practitioners learn one lesson quickly: parse the enhanced code, not the free-text message. The same 550 line can mean a nonexistent mailbox or a policy block, and the wording varies between providers. A verifier that matches on phrases like "user unknown" will misclassify replies from servers that word things differently.
The last row matters most. A refusal that cites sender reputation says something about the verifier's identity, not about the recipient. A verifier that reports these as Invalid will quietly remove good customers from your list.
Bottom line: Treat a permanent 5.1.1 as strong evidence. Treat temporary and policy replies as "unknown, retry or hold."
How does a verifier detect a catch-all domain?
A catch-all (accept-all) domain is one whose server accepts mail for any local part. The verifier detects this by probing a random address that cannot exist, such as zq8w2k-93f@example.com. If that also returns 250, the domain accepts everything. A 250 for any real address on that domain then tells you nothing about its mailbox.
Catch-all handling is one of the areas where verifiers differ most, so ask any vendor how they treat it. The consistent approach is to place these addresses in a separate Risky bucket. For the mechanics, see what does accept-all mean in an email verifier and how bounce-based catch-all verification works.
Unlimited Verifier includes catch-all email verification as part of its checks, so catch-all addresses are flagged rather than counted as valid.
Bottom line: A 250 on a catch-all domain is a weak signal, and the fair label for it is Risky.
Which checking method should you rely on?
Each layer answers a different question, and no single method answers all of them. The table below compares the common approaches.
| Method | What it proves | What it misses | Typical use |
|---|---|---|---|
| Syntax only | The string is well formed | Typos on real domains, dead mailboxes | Form pre-filter |
| Syntax + MX | The domain can receive mail | Whether the specific mailbox exists | Quick bulk cleanup |
| SMTP mailbox probe | The server accepted or refused this recipient | Catch-all masking, greylisting, policy blocks | Core verification |
| Catch-all overlay | Whether a 250 can be trusted |
Whether the individual mailbox is read | Separating Risky from Valid |
| Role and disposable flags | info@, sales@, throwaway domains |
Whether the person is real or reachable | Choosing who to mail |
| Campaign bounce data | What actually bounced for your list | Only addresses you have already mailed | Ongoing monitoring |
| Engagement history | Who has opened or clicked recently | Addresses you have never mailed | Prioritising sends |
Role-address handling is covered in how do verifiers detect role-based addresses. For checks at the point of sign-up, see real-time email validation.
The strongest approach combines the probe with the flags and engagement history. Verification says whether the mailbox can receive mail, and engagement says whether anyone wants it. For the wider process, see email list maintenance best practices.
Bottom line: Use the SMTP probe as your core check, and add catch-all, role and engagement signals before deciding who to mail.
Why doesn't a 250 reply guarantee an inbox?
A 250 at RCPT TO means the receiving server is willing to take the message. It does not mean the person will read it. Several things can happen after acceptance:
- Spam filtering can route the message to junk, or reject it after
DATA, which the verifier never reaches. - Mailboxes fill up after a probe, and a later message bounces with
552 5.2.2. - Disabled or abandoned accounts sometimes keep accepting mail for a while.
- Spam traps are addresses operated to catch senders who do not maintain their lists. A verifier cannot reliably see them, and a trap often looks like a healthy mailbox.
- Consent is outside what a verifier can check. A valid address is not the same as an opted-in one. The FTC's CAN-SPAM compliance guide sets out what US senders must do regardless of whether an address is real.
This is why verification belongs inside a wider programme. The email verification compliance and hygiene approach treats verification as a gate, not a guarantee.
Bottom line: Verification tells you the mailbox can receive mail. It cannot tell you the person wants it or that the message will reach the inbox.
Why are some domains slow or inconclusive?
Large providers defend against probing, so the same probe can return different answers for different domains. The usual causes are:
- Greylisting, where the server returns a
4xxon first contact and expects the sender to retry. A verifier that gives up after one attempt will mislabel good addresses. - Per-IP rate limiting, where repeated probes from one address trigger throttling.
- Policy refusals, where a provider rejects the probe itself.
Speed follows the same logic. Opening many parallel connections to one provider tends to get the verifier throttled, so good tools pace requests per domain. That is why some domains take longer than others. For the full explanation, see why is email verification slow for some domains. For provider-specific behaviour, see does email verification work for Yahoo and AOL addresses.
Bottom line: Inconclusive results usually reflect how a provider defends itself, so retries and per-domain pacing matter more than raw speed.
How do you verify a list step by step?
Start with a few known addresses, then verify the full file and read the three buckets. For a list of a few thousand rows, this takes about ten minutes, and the steps are the same at larger sizes.
- Test a few addresses first. Use the free email checker on three addresses you know: one real mailbox, one you know is dead, and one on a catch-all domain. Confirm each result matches what you expect before you process a whole list.
- Create an account if you need more than the free checker. Sign up to start. The Free plan covers 25 lists a month of up to 150 emails each, plus 750 deep verifications a month.
- Export your contacts as a CSV. Include the email column and any engagement field, such as last open date. Standard verification is unlimited on every plan, so the full pass carries no per-email fee.
- Upload the file. CSV and Excel files up to 10MB are accepted, and the email column is detected automatically. If a file exceeds your plan's per-list size, split it first.
- Read the three buckets. Valid addresses are ready to send. Invalid addresses should be suppressed. Risky addresses include catch-all domains, role accounts such as
info@, disposable domains and inconclusive results. Hold these back from your main send. - Export the results as CSV, Excel or JSON, and record the count for each bucket.
- Re-import the cleaned list. Unlimited Verifier has no native ESP, CRM or Zapier integrations, so the workflow is export, verify, then re-import. Teams that want automation can use the email verification API and automation pattern and call the email verification API from their own scripts. The API accepts single-email checks and batches of up to 10,000 emails per request.
Bottom line: Test a handful of known addresses, verify the full file, send only to Valid addresses, and hold back Risky ones until you have measured bounces.
What does verifying a 50,000-row list cost on Pro?
The figures below are illustrative. The plan limits and arithmetic are real.
Starting point: A list of 50,000 addresses, including 20,000 imported from an old sign-up form.
Step 1: Split for the list cap. Pro allows lists of up to 25,000 addresses each, so the file becomes two lists of 25,000. An email-only column that size is roughly 0.6MB (25,000 addresses at about 25 bytes each), well under the 10MB upload limit.
Step 2: Plan the deep budget. Standard verification is unlimited on every plan, so all 50,000 addresses get a full pass. Deep verifications are capped at 25,000 a month, so:
50,000 ÷ 25,000 = 2 months of deep verification for the whole list
Month one covers the 20,000 old sign-ups plus 5,000 of the newest addresses. Month two covers the remaining 25,000.
Step 3: Cost. Pro is $29 a month, or $25 a month billed annually. Running two months of deep verification on monthly billing costs:
2 × $29 = $58
On the annual plan, the equivalent monthly rate is $25, so two months comes to $50. At full use, the monthly plan works out to $29 ÷ 25,000 × 1,000 = $1.16 per 1,000 deep verifications. That is simple arithmetic from the plan figures. It is not a comparison with other vendors, and it is not a general email verification pricing benchmark.
Step 4: Hypothetical results.
| Bucket | Count | Share |
|---|---|---|
| Valid | 41,150 | 82.3% |
| Risky | 6,100 | 12.2% |
| Invalid | 2,750 | 5.5% |
Within Invalid, the breakdown might be 1,900 with no MX record, 500 with a 550 5.1.1 reply, and 350 that failed syntax. Within Risky, it might be 3,400 catch-all, 1,100 role-based, 700 disposable and 900 inconclusive. You can tally these counts directly from the exported file.
Step 5: Act on the buckets. Send the 41,150 Valid addresses in your normal campaigns. Suppress the 2,750 Invalid addresses permanently. Hold the 6,100 Risky addresses back, and mail only the catch-all subset after you have measured bounces on the Valid list.
Bottom line: A 50,000-row list fits the Pro plan as two uploads and two months of deep verification, and the buckets show exactly what to suppress.
How do you check a verifier's accuracy yourself?
Vendor accuracy figures are useful starting points, but they are measured on the vendor's data. You can test accuracy on your own list with this method:
- Build a known-good set of 100 addresses. Use staff accounts across several providers, plus customers whose addresses you have confirmed. Group them by provider so patterns are visible.
- Build a known-bad set of 100 addresses. Include syntax errors, non-existent mailboxes on real domains, and addresses on dead domains.
- Run both sets through the verifier and record each result.
- Calculate two error rates. A false positive is a bad address marked Valid. A false negative is a good address marked Invalid. Illustratively, if 94 of 100 known-good addresses come back Valid, 4 Risky and 2 Invalid, the verifier wrongly rejects 2% of real mailboxes in that sample.
- Read the errors by provider. If false negatives cluster on one domain, the cause is probably provider-side defence or your sending setup, not your list.
Bottom line: A verifier is trustworthy when its errors are small and explainable on your own data, not only when a vendor quotes a high figure.
What mistakes make verification results wrong?
- Treating a
250as proof of an inbox. Acceptance is only the first gate. Filtering or a full mailbox can still defeat delivery. - Marking greylisted or
4xxreplies as Invalid. These are temporary, and a retry often resolves them. - Running probes from a poorly configured server. Missing reverse DNS or blocked port 25 turns good addresses into false negatives.
- Ignoring catch-all domains in B2B lists. Mailing them as if they were Valid raises bounce risk.
- "Fixing" addresses automatically. Stripping a
+tagor changing the local part tests a different mailbox, so flag suspect addresses rather than rewriting them. - Re-verifying the same list every day. Results do not change that fast, and repeated probing wastes quota and invites throttling. Monthly or quarterly is a more sensible cadence.
- Trusting one vendor's score without testing it. Run the accuracy method above on your own data first.
Bottom line: Most verification errors come from misreading the server's reply or from the sender's own setup, not from the mailbox itself.
How we compared (and limitations)
This article is based on public documentation: RFC 5321 for SMTP, RFC 5322 for message syntax, RFC 3463 for enhanced status codes, the DNS specifications (RFC 1035) for MX lookups, the FTC's CAN-SPAM guide, and Google's sender guidelines. We have not run controlled tests against any provider's mail servers or any vendor's accuracy. Provider behaviour changes without notice, and response codes vary between servers.
Unlimited Verifier's 99.5% accuracy figure is the company's own statement for deep verification, not an independent benchmark. Plan limits and prices are the verified figures for this product. The percentages and counts in the worked example are illustrative.
The verification engine's open-source version is on GitHub if you want to inspect how the checks are implemented. For a wider comparison, see best email verification tools and how to choose an email verifier. For the broader picture, read how email verification works.
Bottom line: Use the RFCs and provider guidance as the authority on mechanics, and test any vendor's accuracy on your own addresses before relying on it.
Three-layer check and what each result means
| Layer | What is tested | Typical result |
|---|---|---|
| 1. Syntax | Format per RFC 5322 (local part, @, domain) | Fails on typos, marked Invalid |
| 2. DNS / MX | Domain has a mail server or fallback record | No record, marked Invalid |
| 3. SMTP RCPT TO | Server reply to the recipient step | 250 = Valid, 550 5.1.1 = Invalid, catch-all = Risky |
Worked example: jane@exmple.com fails at layer 2 because the domain has no MX record, so the verifier stops there. jane@acme.com passes layers 1 and 2, returns 250 at layer 3, and is graded Valid unless acme.com is a catch-all domain.
Frequently asked questions
Does an email verifier send an actual email?
No. A verifier opens an SMTP session with the receiving server, announces the sender and recipient, and reads the server's reply to the recipient step. It then closes the connection before the DATA command, so no message body or content is transmitted. The check never delivers mail to the inbox.
What does a 250 response mean during verification?
A 250 reply to the RCPT TO command means the receiving server accepted the recipient. On a normal domain, that usually indicates the mailbox exists. On a catch-all domain, the server returns 250 for almost any address, so the reply alone does not confirm that one specific person exists.
What does a 550 5.1.1 response mean?
A 550 5.1.1 reply is a permanent failure that means the recipient mailbox does not exist. The server is rejecting that address at the recipient step. Verifiers typically mark such addresses as Invalid, since sending to them would produce a hard bounce.
Why do some verifiers return a 450 or 451 code?
Codes in the 4xx range are temporary failures. The server may be busy, rate-limiting the connection, or using greylisting, which asks the sender to retry later. Good verifiers retry these cases instead of marking the address invalid, since the mailbox may well exist.
Can an email verifier confirm that a person still uses an address?
Not with certainty. Verification shows whether a server will accept mail for an address at the moment of checking. It cannot see whether a person reads that mailbox, whether it is actively monitored, or whether the employee has left. Results are graded evidence rather than proof.
Why is the VRFY command not used for this?
VRFY is defined in RFC 5321 for asking a server to verify a mailbox, but many servers disable it or return deliberately vague answers to avoid leaking account information. Because it is unreliable, verifiers rely on the RCPT TO step, which servers must answer to accept or reject mail.
What is a catch-all domain and why is it risky?
A catch-all domain is configured to accept mail for every address at that domain, whether or not a mailbox exists. Because the SMTP probe returns 250 for everything, a verifier cannot tell real mailboxes from invented ones. Such addresses are usually graded Risky rather than Valid.
Why do verifiers check the MX record before probing?
The MX record tells the verifier which mail server handles the domain. Without an MX record or a fallback address record, no server is set up to receive mail, so the address can be marked Invalid without opening an SMTP connection. This keeps the process faster and avoids unnecessary network traffic.
Does syntax checking catch every bad address?
No. Syntax checking catches format errors such as missing @ symbols, spaces, or illegal characters. It cannot detect a correctly formatted address that belongs to a nonexistent mailbox, which is why the MX lookup and SMTP probe are needed as later layers.
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.