Why a 250 at RCPT TO Is Not Proof of a Mailbox

Why a 250 at RCPT TO Is Not Proof of a Mailbox

autor: admin | Post 12/10/2026

A 250 response to RCPT TO feels like a green light. The server said OK, so the mailbox exists, right? Not necessarily. Anyone who has run an email verifier against a real list has seen addresses come back clean at the SMTP stage and then bounce days later, and the reason sits in how the SMTP conversation is structured. The RCPT TO reply is issued before a single byte of message content is transmitted, which means it can only speak to the recipient command itself, not to whether a human reads mail at that address.

The confusion gets worse on catch-all domains. A catch-all server answers 250 OK to RCPT TO for every local part you throw at it, real or invented. Run a probe against sales@, zzq9x@ and nobody-home@ on the same domain and all three come back accepted. That is the catch-all meaning in plain terms: the receiving server accepts mail for every address on the domain. Verification tools label this accept-all email status, and it is the single largest source of false positives in list cleaning, because the probe result says nothing about the individual mailbox.

This piece walks through the SMTP handshake command by command, pins down exactly what a 250 at RCPT stage proves, and shows where catch-all email verification diverges from real deliverability. It also covers how verification logic should separate RCPT-stage acceptance from post-DATA outcomes, and why an accept-all result belongs in an “unknown” bucket rather than a “valid” one. The stakes are concrete: a list marked 95 percent valid that bounces at 15 percent will burn sender reputation on every send.

Inside the SMTP Conversation: Where RCPT TO Sits in the Handshake

Most people who quote SMTP reply codes have never read a session log. The 250 they cite as proof of a live mailbox is one line in a short, mechanical exchange, and it arrives before the sending server has transmitted any part of the message body. Understanding why that matters starts with the order of commands.

An SMTP session follows the sequence in RFC 5321. The client opens a TCP connection to port 25 on the recipient’s mail server and waits for a 220 greeting. It then sends EHLO with its own hostname, and the server replies with a 250 and a list of extensions it supports: STARTTLS, SIZE, PIPELINING, 8BITMIME, and sometimes VRFY. The client picks a MAIL FROM address, which becomes the envelope sender used for bounces. Only after MAIL FROM is accepted does the client issue RCPT TO with the address it wants to test.

That RCPT TO line is the pivot point. The server answers it immediately, before DATA, before headers, before a single byte of message content. A 250 at that stage means one narrow thing: the server has agreed to consider this recipient for this transaction. It does not mean a human reads that inbox, that the mailbox was ever provisioned, or that a message sent now will land anywhere.

What the server checks, and what it skips

When a mail server evaluates RCPT TO, it typically runs a short list of checks. Is the domain one it handles? Is the local part syntactically plausible? Does a routing rule, alias, or distribution list match? Is the address on a blocklist for this sender? Many servers also apply recipient validation against a user directory, which is why a genuinely unknown address on a strict server returns 550, the code RFC 5321 specifies for undeliverable recipients.

But the check is not mandatory in the way people assume. A server can accept the command and defer the decision. It can accept and then, after the client sends DATA and the full message, generate a bounce. That pattern, an accept-then-bounce server, is common in filtering appliances that scan content before deciding. A bounce message sent hours later tells you the address failed, but your verification run already recorded a 250.

The VRFY command looks like a shortcut, and it is not one. RFC 5321 allows administrators to disable VRFY, and most large providers do, returning 252 (“cannot VRFY user, but will accept message”) or 502. That 252 is itself a reminder that the protocol’s designers knew recipient verification was unreliable and built in an escape hatch.

Two more details shape what a 250 can mean. First, the reply is per-transaction: the same address can return 250 during one session and 450 (temporary failure) during the next if greylisting or rate limiting kicks in. Second, the reply reflects the envelope, not the mailbox. A well-formed address that maps to a shared alias returns 250 even if no individual owns it.

The practical takeaway is structural. RCPT TO is answered inside the handshake, so its reply describes the server’s willingness to continue the conversation, not the state of a mailbox. Any verification logic that treats a 250 as a deliverable address is reading a signal the protocol never promised to send. The next question is what that 250 does prove, and where the boundary sits between accepting a command and accepting a message.

What a 250 at RCPT Stage Actually Proves

The 250 reply to RCPT TO is one of the most overread codes in email. It means one thing: the server handling the current SMTP transaction has agreed to take the recipient command and will accept message data for it. It is a statement about the transaction in progress. It is not a statement about the mailbox.

Read the code in context. RCPT TO arrives after EHLO and MAIL FROM and before DATA. Per RFC 5321, the server can answer with 250 (accepted), 251 (user not local, will forward), or 550 (no such user) among others. A 250 says the recipient was accepted for this one message. It says nothing about who owns the address, whether a human reads it, whether the mailbox has storage left, or whether the message will survive the next ten minutes.

A mail server can return 250 for reasons that have nothing to do with a real mailbox:

  • Greylisting and tarpits. Some servers accept every recipient command and only decide later, after DATA, whether to keep the message. The 250 is a deferral in disguise.
  • Anti-spam acceptance. A growing number of gateways answer 250 to every RCPT TO and silently drop the message after the body arrives. Rejecting at RCPT gives spammers a probing oracle, so operators close it.
  • Aliases and forwarding. A 251 or 250 can point to a forwarding address that dead-ends somewhere else. The command was accepted; the destination is still unknown.
  • Disabled VRFY. RFC 5321 lets administrators disable the VRFY command entirely, and most do. RCPT TO probing is the workaround, but it was never designed as a lookup tool.

The distinction matters because a 250 is a per-transaction promise, not a directory lookup. The server has agreed to continue the SMTP conversation. It has not agreed that the local part exists, that the domain will keep accepting mail next week, or that the address will not bounce. Those are separate questions answered by different mechanisms at different times.

Compare the alternatives. A 550 at RCPT TO is a strong negative signal: the server is telling you, in the RFC 5321 vocabulary, that the recipient is undeliverable. A 450 or 451 is a temporary failure and tells you nothing durable. A 250 sits in the middle and is the weakest of the three as evidence of mailbox existence, because acceptance is cheap and rejection is expensive for the receiving operator.

There is also the post-DATA outcome to consider. An accept-then-bounce server sends its bounce message after receiving the message text, which means the RCPT-stage 250 and the eventual bounce can both be true. The address was accepted at RCPT and rejected at delivery. A verification result that reports only the first event will call that address valid and be wrong. The same pattern shows up with temporary email providers and with domains whose MX records point to a service that accepts everything and filters later.

What a 250 does prove is narrower and still useful: the domain resolves, the MX host is reachable, the server speaks SMTP, and the syntax of the address passed the server’s parser. That is a well-formed address reaching a live mail server. It is the floor of verification, not the ceiling. Treating it as proof of a mailbox is the single most common way a verification report produces false positives, and it is the reason accept-all results need their own label rather than a green check.

A 250 at RCPT TO means the server said yes to the command. It does not mean anyone said yes to the address.

Catch-All Domains: Why Every Recipient Returns 250

The cleanest way to see why a 250 at RCPT TO means almost nothing is to point it at a domain configured to accept everything. On such a server, the reply is 250 OK no matter what you put in front of the @. Send “RCPT TO:<thisaddressdoesnotexist-9f3a@example.com>” and the server answers 250. Send a random string of consonants, a misspelled employee name, a local part that was deleted years ago: 250, 250, 250. The reply is not a lookup result. It is a policy statement from the receiving side.

This is the catch-all meaning in one sentence: the receiving server accepts mail for every address on the domain. The domain owner has set a rule that any local part not matching an explicit mailbox should still be routed somewhere, usually a shared inbox or a filter. what catch-all means in email verification covers this in more depth. From the SMTP conversation’s point of view, every recipient is a valid recipient. The catch-all server answers 250 OK to RCPT TO for every local part, which is exactly why the command cannot be used to confirm that a specific person exists.

Catch-all email verification is the practice of detecting this configuration and separating it from a genuine mailbox hit. Verifiers detect catch-all using a control test with an invented address. The sequence looks like this:

  • The verifier connects to the domain’s mail server and opens the transaction with EHLO and a well-formed MAIL FROM address.
  • It issues an RCPT TO command for a deliberately impossible local part, something like “zz-control-7c1b9e@the-domain.com”, a string no human would own.
  • If the server returns 250 for that invented address, the domain is flagged as catch-all. Any later 250 for a real-looking address is treated as uninformative.
  • If the server returns 550 for the invented address but 250 for the target, that pattern is a much stronger signal that the target mailbox exists.
  • The verifier issues RSET or QUIT and closes the connection without ever sending DATA.

The control test is the whole trick, and it depends on the RFC 5321 behavior that a properly configured server returns a 550-class response for undeliverable recipients. A catch-all domain breaks that assumption on purpose. The email verifier connects to the domain’s mail server, issues the RCPT TO command, and gets the same answer for a real employee and for gibberish. The verification results for that domain should therefore read as accept_all, or as an unknown status, never as valid.

Now the part most checkers gloss over. Many catch-all servers do not simply swallow mail. They are accept-then-bounce servers: they return 250 at RCPT TO, take the message body during DATA, return a final 250 for the message, and then send a bounce after receiving message text, sometimes hours later. The bounce message arrives at the envelope sender, not at the SMTP client, and by then the sending system has already recorded a successful handshake. That is the core information gap. RCPT-stage acceptance describes one command in one transaction. Post-DATA delivery describes whether a message actually reached a mailbox, and on accept-all domains the two routinely disagree.

One more wrinkle: some domains run catch-all on a temporary email provider or a forwarding service that accepts everything and discards most of it. These show the same 250 pattern and the same silent loss. For a sender, an accept-all result is not a reason to delete an address and not a reason to trust it. It is a label that says the SMTP probe ran out of signal, and the only honest way to report it is as unverified.

Separating RCPT-Stage Acceptance from Post-DATA Delivery in Verification Logic

The 250 reply from RCPT TO and the outcome after DATA live in two different layers, and a verifier that merges them will produce reports nobody can trust. An email verifier connects to the domain’s mail server, issues EHLO, MAIL FROM and RCPT TO, reads the reply, and then hangs up. It never sends the message body. The reply it captured says the server accepted the recipient command for this transaction. It says nothing about what would have happened after the dot that ends DATA. Keeping those two facts apart is the whole job of the verification logic.

What a verifier can and cannot learn from SMTP

Start with what the probe actually covers. RFC 5321 specifies a 550 response for undeliverable recipients, and most mail servers do answer RCPT TO honestly for a single-recipient domain. That is the signal worth having. The probe cannot see quota states, greylisting rules that trigger later, spam filters that score after content arrives, or an accept-then-bounce server that sends a bounce after receiving message text. Some servers answer 250 to everything during the handshake and only decide at DATA. Others disable VRFY entirely, which RFC 5321 allows, so the verifier falls back to RCPT TO and gets an even thinner signal.

Then there are the addresses no probe can resolve. An unknown status is the honest label when the server times out, rate-limits, greylists, or returns a soft 4xx that says nothing about the mailbox. Treating a timeout as valid or invalid is fabrication. The verifier should record the raw SMTP conversation, the exact response code, and the timestamp, so a reviewer can see what was actually observed.

Catch-all detection needs its own step. Verifiers detect catch-all using a control test with an invented address: a well-formed address on the same domain, with a random local part that almost certainly does not exist. If the catch-all server answers 250 OK to RCPT TO for every local part, including the invented one, the domain is flagged as catch-all and the real address inherits the accept_all status. The control test is what separates “this mailbox exists” from “this server says yes to everything.” Without it, every catch-all domain result looks like a clean pass.

Post-DATA outcomes arrive too late for the probe but not too late for the pipeline. A bounce message that lands hours or days after sending is the only definitive proof that a mailbox is gone. Feed those bounces back into the record, downgrade the address, and add it to known-bad lists when the code is a hard 550. That loop is what keeps verification results from drifting out of date. Temporary email provider domains deserve the same treatment: flag them at probe time so sending never starts.

The limits are worth stating plainly. SMTP probing is one signal among several, and a single 250 at RCPT stage is the weakest of them. Cross-check against syntax rules for the well-formed address, domain reputation, known-bad lists, and historical bounce data before an address is called a deliverable address. A catch-all result is not a reason to delete an address, and it is not a reason to mail it either. It is a reason to label it unverified and decide by policy.

Practical Implications for Email Verifier Design and List Hygiene

The temptation with an accept-all result is to round it to “valid” and move on, because the alternative is an awkward third state that nobody wants to explain to a client. Resist it. A catch-all result is not a reason to delete an address, and it is equally not a reason to call it verified. The honest label is “unknown” or “accept-all,” stored as its own status alongside valid, invalid, and disposable, so that downstream systems can treat it with the caution it deserves.

Verification reports that collapse catch-all into valid inflate your deliverable rate and hide the risk. If 12 percent of a list sits on catch-all domains and your report shows a 96 percent valid rate, the number is arithmetically true and operationally misleading. Segment the report: confirmed deliverable, confirmed invalid, accept-all, unknown, and risky (role addresses, temporary email provider domains, known-bad lists). Anyone who reads the report should be able to see how much of the “good” portion rests on a 250 that only proves the command was accepted.

Designing the Verifier So the Output Matches the Evidence

A verifier’s job is to report what it observed, not to infer more than the SMTP conversation supports. That means a few concrete engineering choices.

  • Run the control test on every domain. Verifiers detect catch-all using a control test with an invented address at the same domain. If the invented local part returns 250, the domain is accept-all and every other 250 from that domain carries no mailbox-level information. The result for all real addresses on that domain should be downgraded to accept_all or unknown, never valid.
  • Keep RCPT-stage and post-DATA outcomes separate in the data model. A 250 at RCPT TO and a later bounce are different events with different confidence. Store the RCPT response code, the control-test result, and any bounce received afterward as distinct fields. When a bounce arrives for an address previously marked valid, the system should be able to reconcile it rather than treat it as an anomaly.
  • Do not infer deliverability from a well-formed address. Syntax checks catch typos and malformed local parts, nothing more. A well-formed address on a catch-all domain is still unverified.
  • Handle the accept-then-bounce server explicitly. Some servers answer 250 to every recipient and send a bounce after receiving message text. For these, only real sending with bounce capture produces ground truth, so the verifier should flag the domain pattern and route those addresses to a suppression or probation list rather than the main send stream.
  • Respect the limits of probing. RFC 5321 allows administrators to disable VRFY, and many do. Recipient validation by SMTP is a courtesy the receiving mail server can withdraw at any time. Rate-limit probes, rotate sending IPs responsibly, and treat connection refusals as unknown, not invalid.

On the list hygiene side, the operational rule is simple: send to accept-all addresses only after engagement evidence exists. Put them in a separate cohort, throttle volume, watch complaint and bounce rates per cohort, and let real interaction promote an address to confirmed. If a catch-all address never opens, never clicks, and never replies over several campaigns, the cost of keeping it exceeds the value. That decision is made on behavioral data, not on a 250 from RCPT TO.

Document the policy in your verification results and in the reports you hand to stakeholders. When a client asks why an address they know exists shows as unknown, the answer is that the domain accepts mail for every local part, so the server’s 250 told us nothing about that specific mailbox. That is a defensible, accurate answer. Calling it valid is not.

The practical takeaway is simple: a 250 at RCPT TO is a statement about the SMTP transaction, not about the mailbox. Treat it that way in your reports. Label catch-all domain addresses as accept-all or unknown status rather than valid, keep them in a separate segment, and never let them into a campaign that requires a clean deliverable address list. Before you trust any email verifier’s output, run a control test: feed it an address on a known catch-all domain with an invented local part and confirm the tool reports something other than “valid.” If it returns a plain 250 as a pass, the tool is reporting SMTP acceptance, not mailbox existence, and its results need that caveat applied everywhere.

Two operational habits carry most of the value. First, track post-DATA outcomes. A recipient that answered 250 at RCPT TO and then bounced after message text is the clearest evidence that RCPT-stage acceptance meant nothing, and those bounce messages should flow back into your suppression logic within the same sending cycle. Second, match your sending pattern to the risk tier. Send catch-all addresses at reduced volume from a warmed subdomain, watch engagement and bounce rates by segment, and remove addresses that go quiet or bounce. For unknown status results, prefer a confirmation path, such as a signup form double opt-in or a re-engagement message with a clear action, over a hard classification. A catch-all result is not a reason to delete an address, and it is not a reason to send to it blindly either; it is a reason to verify the mailbox through behavior rather than through an SMTP reply.

Finally, document the distinction in your own process notes so it survives staff changes and vendor switches. Write down which verification statuses map to which sending rules, record how your verifier handles catch-all domains, and revisit the mapping whenever a provider changes its SMTP behavior. For teams that want a reference point on how these statuses are defined and published, AllMail publishes blog content about email verification, including guidance on reading accept_all, unknown, and catch-all results. Use it to sanity-check your labels, then test the behavior yourself against real domains, because the only proof of a mailbox is a message that arrives and a recipient who responds.