Article
How Do Verifiers Check If a Domain Accepts Mail?
By Unlimited Verifier Team ·

Summary
A verifier checks whether a domain accepts mail by looking up its MX records in DNS, then opening an SMTP connection on port 25 to the highest-priority server and looking for a 220 greeting and a 250 reply to EHLO. This domain-level check classifies every address at that domain at once, but it does not confirm that a specific mailbox exists.A verifier checks whether a domain accepts mail by looking up its MX records in DNS, then opening an SMTP connection on port 25 to the highest-priority mail server. A healthy server answers with a 220 greeting and a 250 reply to EHLO. This domain-level check is the cheapest, earliest gate in how email verification works. It answers a narrower question than most people assume: is there a mail system here that will take messages at all? It does not confirm that a specific mailbox exists, and much of the confusion about verifier results comes from mixing those two questions up.
Quick answer
- DNS comes first. The verifier queries the domain's MX records. If none exist, RFC 5321 falls back to the A record.
- SMTP comes second. It opens port 25 and looks for a
220greeting and a250reply toEHLO. - A null MX ends the check. A domain that publishes a null MX (RFC 7505) has declared that it accepts no mail.
- Patience matters. RFC 5321 recommends waiting up to five minutes for the greeting. A verifier that gives up much sooner will misclassify slow but healthy servers.
- A pass is not a mailbox. Domain acceptance says nothing about whether a specific address exists. That takes the
RCPT TOstage, which catch-all servers can distort.
What does it mean for a domain to "accept mail"?
A domain accepts mail when DNS points to at least one SMTP server willing to take messages for it. That is a property of the domain's infrastructure, not of any person behind it.
Domains fall into three states, and verifiers treat each one differently:
- Live mail service. The domain has MX records, and those hosts answer SMTP.
- Exists, but no mail service. The domain has no MX record and no usable A record, or it publishes a null MX.
- Does not exist. DNS returns NXDOMAIN, meaning the name isn't registered or isn't delegated.
Each state has a different cause. A former company domain that has stopped doing email usually lands in state 2. A mistyped name such as "gmial.com" usually lands in state 3, unless someone registered it and pointed its MX at a server, in which case it lands in state 1. That last case matters later.
The practical value is that one domain result covers every address at that domain. A single lookup can reclassify hundreds of rows, which is why domain checks run before mailbox checks.
Bottom line: Domain acceptance classifies whole groups of addresses at once, before any individual mailbox is tested.
How does a verifier find a domain's mail servers?
A verifier reads the domain's MX records. As RFC 1035 defines them, each MX record holds a host name and a preference number, and senders try the lowest number first. The verifier sorts the records by preference, then resolves each host to an address through its A (IPv4) or AAAA (IPv6) records.
Three edge cases decide most disputed results:
- No MX, but an A record exists. RFC 5321 (section 5.1) tells senders to treat the A record's host as the mail exchanger. Verifiers disagree on how to score this. Some pass it as deliverable. We recommend Risky, because a domain with a web server and no MX is often not set up for mail at all.
- A null MX. RFC 7505 defines an MX with preference 0 and target
.to mean "this domain accepts no mail." The verifier should stop here and mark the domain Invalid. Sending to it only produces bounces. - No MX and no A record. There is no delivery route, so the domain is Invalid at the domain stage.
Verifiers also cache results per domain, because DNS answers are valid for their time to live (TTL). TTL values vary by zone and can range from minutes to days. A list whose 48,850 addresses share 6,000 domains needs about 6,000 lookups, not 48,850. The mechanics of how an email verifier checks if an address exists build on this same lookup.
Bottom line: MX records decide where mail goes. A missing MX, a null MX and an A-record-only setup each mean something different and deserve different verdicts.
How does the SMTP handshake prove a domain accepts mail?
Once the verifier has the server's IP, it opens a TCP connection to port 25 and runs a short conversation:
- The server sends a
220greeting, confirming the service is ready. - The verifier sends
EHLOwith a host name. - The server replies
250and lists its capabilities. - The verifier sends
MAIL FROM:with a sender address. - The verifier sends
RCPT TO:with the target address. This is where mailbox-level answers come from. - The verifier sends
QUIT. It never sendsDATA, so no message body is transmitted.
A domain-level check needs only steps 1 to 3. A 220 and a 250 prove that a live SMTP server answers for that host. They do not prove that the server will accept a particular recipient. What RCPT TO means in email verification covers that stage in depth.
Two operational realities matter:
- Port 25 is often blocked on the verifier's side. Many residential ISPs and several major cloud providers restrict outbound port 25. A verifier on such a network sees timeouts that look exactly like a dead domain. The fault is in the network, not the domain.
- Probes are visible to the server. High volumes from one source can trigger rate limits. Responsible verifiers pace connections per host, which is one reason some domains are slow to verify.
Bottom line: A 250 to EHLO proves the server speaks SMTP. It does not prove the server will accept your recipient.
What do SMTP reply codes tell a verifier?
Reply codes are the verdict vocabulary. The first digit gives the outcome class: 2xx success, 4xx temporary failure, 5xx permanent failure. The enhanced status codes in RFC 3463 add detail. This table maps each reply to a verdict at the domain stage and at the mailbox stage.
| Reply | Meaning | Verdict | Why it matters |
|---|---|---|---|
220 |
Service ready (greeting) | Server is live | Expected first reply |
250 |
Requested action okay (EHLO accepted) | Accepts mail | Proves SMTP, not any mailbox |
421 |
Service unavailable, closing | Retry later | Often rate limiting, not a dead domain |
450 / 451 |
Temporary mailbox or local error | Retry later | Greylisting commonly uses these codes |
550 + 5.1.1 |
Bad destination mailbox | Invalid for that address | Permanent "no such mailbox" result |
550 + 5.7.1 |
Delivery refused by policy | Risky | Usually reputation or policy, not a missing address |
552 + 5.2.2 |
Mailbox full | Risky | The address exists but cannot take mail right now; see mailbox full results |
252 |
Cannot verify user, will accept | Risky | The server declined to confirm the address |
Two details trip up many tools. First, a 550 is not always a dead address. A 5.7.1 refusal usually reflects policy or reputation, so marking it Invalid removes real customers. Second, greylisting deliberately defers first contact from an unknown sender with a 4xx reply. A verifier that gives up on the first temporary reply marks healthy domains as failures. Retry the check later instead of deleting the address. Greylisting delays are often a few minutes, so a single retry after an hour is usually enough to tell the two cases apart.
Bottom line: Read the enhanced code, not just the first digit. A 550 5.1.1 is a permanent no-such-mailbox result, while a 550 5.7.1 is usually a policy decision.
Why does a domain pass while the address still fails?
Domain acceptance proves that a server exists. The mailbox check asks it about one name, and three situations break the link between the two:
- Catch-all servers. A server configured to accept every recipient returns
250for invented addresses too. The domain passes, but the address result is uncertain. How verifiers detect catch-all domains explains the identification, what accept-all means in an email verifier covers the verdict, and bounce-based catch-all verification shows one way to test it further. Catch-all email verification in Unlimited Verifier flags these domains so you can hold them back. - Parked typo domains. Some misspelled versions of major providers are registered and point their MX at a parking service. The MX lookup succeeds and the server answers, but no person receives mail there. A domain check alone can't separate a parked domain from a working one.
- Providers that limit confirmation. Some large providers respond generically to slow address harvesting, so a
RCPT TOanswer may not be definitive. Email verification for Yahoo and AOL addresses explains how this affects those domains.
Bottom line: A passing domain check is a necessary condition for a valid address, not a sufficient one.
Which domain check should you use?
Use the cheapest check that answers your question, then escalate only where needed. The table compares the four approaches you'll encounter.
| Method | What it proves | What it misses | Relative speed | Best use |
|---|---|---|---|---|
| DNS only (syntax, MX, A, null MX) | The domain has a mail route | Whether any server answers | Fastest, about one lookup per domain | Screening a whole list |
| DNS plus SMTP greeting/EHLO | A live SMTP server answers on port 25 | Any particular address | Moderate, one connection per host | Separating dead servers from live ones |
| Full RCPT TO probe | How the server answers one address | Catch-all behaviour, greylisting, blocks | Slowest, one per address | Mailbox-level verdicts |
| Blacklist (DNSBL) lookup | Whether a domain or IP is listed | Whether mail is accepted | Fast | Deliverability diagnosis |
The blacklist row is the one most often confused with acceptance. A listed domain can still accept mail, and an unlisted domain can have no mail service at all. Unlimited Verifier's free domain blacklist checker answers the blacklist question, and the verification run answers the acceptance question.
When you compare best email verification tools, ask each vendor whether it reports domain-stage reasons separately, treats timeouts as unknown rather than Invalid, and labels catch-all domains. The buyer's checklist for choosing a verifier covers those questions in more detail.
Bottom line: Screen with DNS first, confirm live servers with SMTP second, and probe individual addresses only for domains that pass.
How do you check domain acceptance, step by step?
This is the order a well-built verifier follows, and the order to expect from any tool:
- Check syntax first. Confirm one
@, valid characters and a plausible domain format. Syntax validation removes malformed rows without a network call. - Extract unique domains. Group addresses by domain so each domain is checked once.
- Query MX records and sort by preference. If there is no MX, apply the RFC 5321 A-record fallback. A null MX marks the domain Invalid.
- Stop on NXDOMAIN. A domain that doesn't exist cannot accept mail.
- Connect to the best MX on port 25. On a timeout, try the next MX host. If every host times out, record the domain as unknown, not Invalid. Retest it after at least an hour before you decide.
- Confirm the
EHLOreply. A250means a live server. - Flag special cases. Catch-all, parked and disposable domains each need their own signal. Disposable domain detection covers one of them.
- Probe individual addresses last. Run
RCPT TOonly for addresses on domains that passed steps 1 to 6.
The order is driven by cost. Each cheap step removes groups of addresses before the expensive per-address probes run.
Bottom line: Cheap checks eliminate most addresses first, so expensive probes run only where they can change the answer.
Worked example: how many lookups and rejections does a 50,000-row list produce?
The figures below are illustrative, not measured results. The arithmetic and plan limits are real.
A SaaS company exports 50,000 rows from its CRM. The list has grown through trade shows and old imports, the kind of data that email verification for ecommerce and SaaS teams deal with constantly.
Stage 1: Syntax. 1,150 rows fail. That leaves 48,850.
Stage 2: Unique domains. The 48,850 addresses share 6,000 domains. That means 6,000 DNS lookups instead of 48,850, about 8.1 times fewer.
Stage 3: Domain verdicts.
- NXDOMAIN: 310 domains, covering 1,840 addresses.
- No MX and no A record: 85 domains, covering 420 addresses.
- Null MX: 12 domains, covering 96 addresses.
Check: 1,840 + 420 + 96 = 2,356 addresses removed, and 48,850 − 2,356 = 46,494 continue. The domain stage removes 4.7% of the original 50,000 rows. The domains that remain number 6,000 − 310 − 85 − 12 = 5,593.
Stage 4: SMTP reachability. Of the 5,593 remaining domains, 4,383 answered on the first attempt. The other 1,210 timed out. Of those, 1,050 answered on an alternate MX, and 160 stayed unreachable and were held as unknown. Check: 4,383 + 1,050 + 160 = 5,593.
Plan fit with Unlimited Verifier:
- Pro plan ($29/month, or $25/month billed annually): Lists are capped at 25,000 emails each, so the 50,000 rows split into two lists of 25,000. Standard verification is unlimited, so no per-email charge applies.
- Free plan ($0): Lists are capped at 150 emails and the plan allows 25 lists a month. 50,000 ÷ 150 = 333.3, rounded up to 334 lists, and 25 lists cap the month at 3,750 emails. Free cannot process this file in one month.
- API route on Pro: Bulk requests accept up to 10,000 emails each, so 50,000 emails need 5 requests. That uses half of Pro's 100,000 API emails a month. Using the full allowance works out to $0.29 per 1,000 emails at the monthly price, or $0.25 billed annually. When you compare email verification pricing, calculate cost per 1,000 emails on the same basis.
Bottom line: Domain screening removed 2,356 addresses (4.7%) and cut DNS lookups by about 8 times before any mailbox was probed.
How do you check domain acceptance in Unlimited Verifier?
Follow these steps to run a domain-aware verification on your own list.
- Export your contacts as a CSV from your ESP or CRM, with the email column included. Excel files also work.
- Sign up for a free account. The Free plan is enough to test a small file.
- Upload and verify a list. CSV and Excel files up to 10MB are accepted, and the email column is detected automatically. On Pro, split any file over 25,000 rows first.
- Run the verification. Each address goes through syntax, domain, MX and SMTP mailbox checks. Catch-all domains are detected, and disposable and role-based addresses are flagged. Unlimited Verifier's verification engine is open source on GitHub, so you can read how it handles the A-record fallback and null MX before you rely on it.
- Read the three buckets. Valid addresses can go to your next send. Invalid addresses should be removed and suppressed. Risky addresses, including catch-all domains, should be held back. The buckets show the verdict, not the DNS reason, so if you need the reason, check it yourself. Run
dig MX yourdomain.com +shortand read the result: a null MX returns0 ., and an NXDOMAIN status means the domain doesn't exist. - Spot-check edge cases with the free email checker, for example a single address on a domain you suspect is parked.
- Export your results as CSV, Excel or JSON. Results are kept for 24 hours on Free and 30 days on Pro, so export the same day if you're on Free.
- Re-import only Valid contacts into your ESP. There are no native ESP, CRM or Zapier integrations, so the workflow is export, verify, re-import.
For automation, the Email verification API handles single checks and bulk batches of up to 10,000 emails per request. API access is included on Pro, not Free. Teams building checks into signup or import flows can read about email verification API and automation and real-time email validation.
Bottom line: Export, verify, read the three buckets, and keep the results file so you can show exactly why each address was removed.
What mistakes do people make when checking domains?
- Treating a
250toEHLOas proof of a valid address. The greeting shows only that the server speaks SMTP. - Marking timeouts as Invalid. Timeouts often come from blocked port 25, rate limits or greylisting. Treat them as unknown and retest.
- Verifying from a network that blocks port 25, then blaming the domains for the failures.
- Reading every
550as a dead mailbox. A5.7.1refusal is usually a policy decision, and a5.2.2mailbox-full result means the address exists. - Ignoring null MX and no-MX domains. These are the cheapest removals on the list, and keeping them guarantees bounces.
- Hammering the same domain. Without per-domain caching you hit rate limits, and results degrade.
- Trusting a domain that merely resolves. Parked and typo domains often pass the MX check.
- Assuming A-record-only domains accept mail. The RFC allows the fallback, but the domain deserves a Risky flag.
- Mixing up blacklist status with acceptance. A listed domain can still accept mail, and an unlisted one can have no mail service.
- Treating a one-time check as ongoing hygiene. Domains change owners and stop accepting mail. Scheduled re-checks are part of email list maintenance and email verification compliance and hygiene.
Bottom line: Most errors come from treating a network or policy signal as a verdict about the address.
How we compared (and limitations)
This article is based on public documentation: RFC 1035 (DNS), RFC 5321 (SMTP, including the implicit MX rule in section 5.1 and the timeout guidance in section 4.5.3.2), RFC 7505 (null MX) and RFC 3463 (enhanced status codes). We have not run controlled tests against any mail provider's servers. Provider behaviour, rate limits and timeout thresholds change without notice.
The worked example uses hypothetical figures. Plan limits, pricing and API batch size are Unlimited Verifier's published facts. The company states 99.5% accuracy for deep verification. That is its own figure, not an independent benchmark. Its verification engine is open source, so the logic can be inspected directly.
Where sources disagree, such as whether an A-record-only domain accepts mail or how long to wait before retesting a timeout, we say so and recommend a conservative verdict.
Bottom line: Use the RFCs for protocol rules, and run a sample of your own data before you rely on any threshold.
Domain acceptance check steps
- Query MX records for the domain.
- If no MX exists, check for an A record (RFC 5321, section 5.1).
- If the MX is null (preference 0, target '.'), stop: the domain accepts no mail.
- Sort MX hosts by preference and resolve each to an IP address.
- Open SMTP on port 25 and wait for a 220 greeting (allow up to five minutes).
- Send EHLO and expect a 250 reply.
- Classify: live mail service, exists without mail service, or does not exist (NXDOMAIN).
Frequently asked questions
What is an MX record?
An MX record is a DNS entry that names the mail server for a domain and gives it a preference number. Senders try the lowest preference number first. Verifiers read MX records to find which server should receive mail for a domain.
What does a 220 SMTP response mean?
A 220 response is the greeting a mail server sends when it accepts a connection and is ready for SMTP. Verifiers treat it as the first sign that a server is live. The check continues only if the server then replies to EHLO with 250.
What is a null MX record?
A null MX is an MX record with preference 0 and target '.', defined in RFC 7505. It tells senders that the domain accepts no mail. Verifiers treat a domain with a null MX as non-accepting and stop the check there.
Why does a domain with an A record but no MX sometimes pass?
RFC 5321 says senders may fall back to the domain's A record when no MX exists. Some verifiers count this as deliverable. Many treat it as Risky, since a domain with only a web server is often not set up to receive mail.
How long should a verifier wait for an SMTP server?
RFC 5321 recommends waiting up to five minutes for the initial greeting. Verifiers that time out much sooner can mark slow but healthy servers as undeliverable, so timeout settings matter for accuracy.
Does a domain passing the check mean the email address is valid?
No. A passing domain check only shows that the domain has a working mail system. It does not confirm that a particular mailbox exists. Mailbox validity requires the RCPT TO stage, which catch-all servers can distort.
What does NXDOMAIN mean for email verification?
NXDOMAIN means DNS cannot find the domain, so the name is not registered or not delegated. Verifiers classify these addresses as non-existent domains and usually mark them undeliverable without opening an SMTP connection.
Why does port 25 matter for verification?
Port 25 is the standard port for server-to-server SMTP. Verifiers need it to reach the receiving server. Some networks block outbound port 25, which can make a verifier report healthy domains as unreachable.
What is a catch-all domain?
A catch-all domain is one whose mail server accepts mail for any address at that domain, real or not. Because it answers RCPT TO with 250 for everything, the domain check cannot separate valid from invalid mailboxes.
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.