Article
What Happens During an SMTP Handshake Check? A Step-by-Step Guide
By Unlimited Verifier Team ·

Summary
An SMTP handshake check connects to a recipient's mail server on port 25, names the mailbox with RCPT TO, reads the reply code, and disconnects before any message is sent. A 250 reply usually means the mailbox was accepted, while a permanent 5xx reply with a 5.1.x enhanced code usually means it doesn't exist.What is an SMTP handshake check, and why does it matter?
An SMTP handshake check connects to a recipient domain's mail server on port 25, introduces a sender, names the mailbox with an RCPT TO command, reads the server's reply code, and disconnects before any message is sent. It is the mailbox-level step in how an email verifier checks if an address exists.
The handshake is one of the few common checks that asks the receiving server directly whether it would accept mail for an address. Syntax checks and MX record lookups can confirm that an address is well formed and that its domain accepts mail, but neither can say whether the mailbox exists. For list owners who need to lower bounces and meet email verification compliance and hygiene standards, that gap decides which addresses are safe to mail.
This guide walks through the conversation turn by turn, explains what each reply code means, and shows how to read results when the server gives a clear answer, a vague one, or none at all. For the wider context, start with our pillar guide on how email verification works.
Quick answer
- The handshake is a short SMTP conversation: connect on port 25, send
EHLO, setMAIL FROM, name the recipient withRCPT TO, read the reply, and sendQUIT. The message body (DATA) is never sent. - The reply to
RCPT TOis the verdict: a250means the server accepted the mailbox. A permanent550-series reply with a5.1.xenhanced code usually means the mailbox doesn't exist. - Sort by reply class, not pass/fail: a
4xxreply means retry, a5xxreply is a refusal, and silence is unknown. - In the illustrative 50,000-row example below, 10.4% of addresses were permanently rejected on the first pass, and 11.6% were Invalid after one retry round.
- Catch-all domains accept every address, so a handshake alone can't clear them. Hold them as Risky. Sign up to run these checks in bulk, with Valid, Risky and Invalid results and unlimited standard verification on every plan.
What happens step by step during an SMTP handshake check?
The verifier behaves like a sending mail server that only wants to know whether one mailbox exists. In the transcript below, S: lines come from the receiving server and C: lines come from the verifier.
S: 220 mx1.example.com ESMTP ready
C: EHLO verify.example-sender.com
S: 250-mx1.example.com Hello
S: 250-STARTTLS
S: 250 SIZE 35882577
C: MAIL FROM:<check@example-sender.com>
S: 250 2.1.0 Ok
C: RCPT TO:<jane.doe@example.com>
S: 250 2.1.5 Ok
C: QUIT
S: 221 2.0.0 Bye
- Connect. The verifier looks up the domain's MX records and picks the host with the lowest preference value, which is the highest priority. If a domain has no MX records, RFC 5321 lets the sender fall back to the domain's address record. The verifier opens a TCP connection on port 25, and the server answers with a
220banner. - Identify.
EHLO(or the olderHELO) introduces the verifier by hostname. The server replies with the extensions it supports.STARTTLS, defined in RFC 3207, encrypts the connection, and many verifiers use it when it's offered. - Set the sender.
MAIL FROMdeclares a return address. Most servers accept it at this stage, though some check the sender's domain and reputation before they answerRCPT TO. - Name the recipient.
RCPT TOis the step that matters. The reply here decides whether the mailbox is accepted or rejected. - Stop. The verifier sends
QUITwithoutDATA. No body, headers or attachments are transmitted, which is what separates this check from sending a real test email.
Two practical details shape results:
- Sender identity matters. Servers are more willing to answer probes from a sender whose domain resolves and whose IP has a reasonable reputation. A poorly configured sender gets throttled, while a well-configured one gets clean answers.
- Port 25 is the port that matters here. Port 587 is the submission port for mail clients, described in RFC 6409. Server-to-server delivery, which a handshake check imitates, runs on port 25.
Bottom line: The handshake is a five-command conversation whose purpose is to get a reply to RCPT TO. Everything before it is setup.
What do the server's reply codes actually tell you?
The reply to RCPT TO carries a three-digit SMTP code and usually an enhanced status code defined in RFC 3463, such as 5.1.1. The first digit gives the category, and the enhanced code gives the reason.
| Reply (example) | Class | Meaning | Typical verdict |
|---|---|---|---|
250 2.1.5 Ok |
2xx, accepted | Server would accept mail for this mailbox | Valid, unless the domain is catch-all |
450 4.7.1 / 451 4.7.1 |
4xx, temporary | Greylisted or throttled; try again later | Retry, then Risky if unresolved |
550 5.1.1 User unknown |
5xx, permanent | Mailbox does not exist | Invalid |
553 5.1.2 / 5.1.3 |
5xx, permanent | Bad destination host, or malformed address | Invalid |
552 5.2.2 Mailbox full |
5xx, permanent | Address exists but is over quota | Usually Risky, since the mailbox exists |
550 5.7.1 |
5xx, policy | Rejected by policy, often tied to sender reputation | Risky, because the cause may be your sending identity |
| Timeout or no reply | None | Connection dropped, blocked or stalled | Retry, then Risky if still unresolved |
The 4xx/5xx split matters most. A 4xx reply is a promise to try again, so treating it as a rejection discards good addresses. A 5xx reply is a refusal. In the enhanced code, 5.1.x concerns addresses, 5.2.x concerns mailbox state, and 5.7.x concerns policy. For how full mailboxes are handled, see what a mailbox-full result means.
Bottom line: Read the first digit for the category and the enhanced code for the reason. Don't collapse both into one "failed" label.
How does a verifier turn replies into Valid, Risky or Invalid?
A verifier converts each reply into one of three buckets, and the rules it applies decide how many addresses you keep. The mapping below is our recommended way to interpret replies. It is not a published standard, so check any tool's documentation for its exact rules.
- Valid: a
250atRCPT TOfrom a domain that doesn't accept everything. Use this bucket for your first sends after a cleanup. - Invalid: a permanent
5.1.xor5.2.xrejection. Suppress these permanently. - Risky: anything the server neither clearly accepted nor clearly rejected. That covers catch-all domains, unresolved timeouts, policy blocks and full mailboxes. Hold these back.
Risky is where most of the judgement lies. A list owner who treats "no answer" as "valid" inherits the bounces the handshake was meant to prevent. Our rule of thumb: if the server didn't say yes, the address isn't Valid.
Catch-all domains need their own test. A server that accepts everything returns 250 for mailboxes that don't exist, so the handshake can't separate real addresses from invented ones. The bounce-based catch-all method probes the domain with a random address to see whether it accepts everything. For more on these domains, read what accept-all means in an email verifier or see catch-all email verification.
Bottom line: Valid means the server said yes without qualification. Everything else is either a question to resolve or a reason to hold the address back.
Why do some handshakes come back with no clear answer?
Handshakes that don't resolve on the first attempt usually fail for one of five reasons, and each calls for a different response.
- Greylisting. Many servers reject a first connection from an unknown sender with a 4xx reply and expect a legitimate sender to retry. Retrying immediately fails, because the server is waiting for the sender to come back later. Greylisting intervals vary by server, from minutes to an hour, so no single wait is correct. We recommend 15 minutes as a starting point, then one or two retries per run.
- Rate limiting. Servers throttle rapid connections from one IP. A batch that checks thousands of addresses on one domain in a burst will see more 4xx replies. Spreading checks out and capping concurrency per domain reduces this.
- Blocked port 25. Many residential networks and cloud hosts block outbound port 25 by default. A script run from a laptop or a default cloud instance sees timeouts that look exactly like bad data. This is a common reason people who build their own checker conclude that "everything is invalid." The fix is to run checks from a host that can reach port 25 on the internet.
- Reputation filtering. Some large providers answer probes from low-reputation IPs with generic or throttled replies. Practitioners commonly report that the same address returns different results from different verification networks for this reason. Provider-specific behaviour is covered in whether email verification works for Yahoo and AOL addresses.
- Slow or unresponsive domains. Some mail servers respond slowly or hold connections open. They produce the long tail of a batch. See why verification is slow for some domains.
Here is the insight that matters most: the share of addresses a verifier can't resolve tells you more about risk than the share it rejects. A list where 10% fails permanently may be healthy if the rest resolve cleanly. A list where 8% stays unresolved after retries is harder to trust, even with no outright rejections, because those addresses are more likely to bounce or to sit behind a server that resists probing.
Our working guideline is to investigate any batch where unresolved results exceed about 3% of the list. This is a practitioner's threshold, not an industry standard, and it will vary with your sector and domain mix.
Bottom line: Unresolved results are information. Retry them once or twice with spacing, then treat what remains as Risky.
Does an SMTP handshake check send an email to the address?
No. The handshake stops at RCPT TO and never sends DATA, so no message reaches the recipient's inbox. The receiving server does log the connection and the RCPT TO attempt. Because repeated probes can look unusual, responsible verifiers space out checks and avoid hitting one domain in a burst.
This matters for consent. A handshake doesn't deliver content, doesn't create a subscriber, and doesn't show that the person wants your mail. It shows only that the mailbox accepted the probe at that moment. The FTC's CAN-SPAM compliance guide still governs the messages you send to any address you hold. For the full treatment, read does email verification send an email to the address.
Bottom line: The handshake proves existence, not permission. Keep those two questions separate.
Can you run an SMTP handshake check yourself?
Yes, in principle. Any language with an SMTP client can open a connection and issue these commands; Python's standard smtplib module is one example. The hard part is everything around the handshake: MX lookup with fallback, retries on 4xx replies, per-domain rate limits, catch-all detection, and interpreting codes consistently across thousands of domains. Port 25 access is the first obstacle, and most teams hit it before anything else.
Build your own checker if you want to learn the protocol or audit a vendor's logic. For a list you need to clean before a campaign, a tested pipeline usually saves more time than it costs. The open-source engine described in the comparison section below shows one way these checks are implemented.
Bottom line: A DIY handshake is easy to start and hard to run reliably at list scale.
Why do different verifiers return different results for the same list?
Verifiers disagree on the same address for four main reasons: the sending identity they present, their retry logic, how they classify catch-all and unresolved replies, and how receiving servers treat their infrastructure. Disagreement is most common on Risky addresses and rare on clear Valid or Invalid ones.
| Factor | What it changes | Question to ask a vendor |
|---|---|---|
| Retry policy | How many 4xx addresses resolve | Do you retry greylisted and timed-out addresses, and how many times? |
| Catch-all handling | Whether accept-all domains land in Valid or Risky | How are accept-all domains classified? |
| Network reach | Whether port 25 is reachable from the verifier | Do you run checks from hosts that can reach port 25 directly? |
| Concurrency control | Whether large domains throttle you | How do you limit checks per domain? |
| Result categories | How ambiguous replies are sorted | Do you separate Risky from Invalid, and do you explain why? |
To check a single address yourself, use the free email checker. Unlimited Verifier also publishes its open-source verification engine on GitHub, so you can inspect how the checks are implemented.
For a wider comparison, see the best email verification tools. For a buyer's checklist, read how to choose an email verifier.
Bottom line: Compare vendors on how they handle the Risky bucket, not on how many addresses they call Valid.
How many addresses would an SMTP check remove from a 50,000-row list?
The figures below are illustrative. They show the arithmetic, not a real dataset.
The setup: A B2B software company, which may fit email verification for ecommerce and SaaS workflows, has 50,000 contacts from signup forms, a trade-show import and a legacy CRM. It wants to clean the list before its next campaign.
Plan limits: The Free plan allows 25 lists of up to 150 emails a month, which can't hold 50,000 rows, so Pro is the realistic tier. Pro costs $29 a month, or $25 a month billed annually (email verification pricing varies by vendor, so compare the per-address cost). Each list holds up to 25,000 emails, so the file is split into two lists of 25,000. Standard verification is unlimited on every plan, so no per-email fees apply.
Pass 1 (all 50,000 addresses):
- 40,100 accepted with
250on domains that don't accept everything - 1,300 accepted with
250on catch-all domains - 5,200 permanently rejected with
5.1.xcodes - 1,900 deferred with
4xxreplies - 1,500 with no reply (timeouts or blocked connections)
Check: 40,100 + 1,300 + 5,200 + 1,900 + 1,500 = 50,000. ✓
Pass 2 (retry the 3,400 unresolved addresses, 1,900 deferred plus 1,500 unreplied, spaced at least 15 minutes apart):
- 1,650 now accepted
- 600 now permanently rejected
- 1,150 still unresolved
Check: 1,650 + 600 + 1,150 = 3,400. ✓
Final sort:
- Valid: 40,100 + 1,650 = 41,750 (83.5%)
- Risky: 1,300 catch-all + 1,150 unresolved = 2,450 (4.9%)
- Invalid: 5,200 + 600 = 5,800 (11.6%)
Check: 41,750 + 2,450 + 5,800 = 50,000. ✓
Cost: The 2,450 Risky addresses are 9.8% of the plan's 25,000 monthly deep verifications, so the company can use deep checks on the catch-all group and keep most of its allowance. The subscription works out to $1.16 per 1,000 deep verifications at monthly billing ($29 ÷ 25) or $1.00 at annual billing ($25 ÷ 25), assuming the full allowance is used. This company uses far less than that, so the effective cost per checked address is higher than the headline rate. Unlimited Verifier states 99.5% accuracy for its deep verification. That is the company's own figure, not an independent benchmark.
What the company does next: It suppresses the 5,800 Invalid addresses permanently. It sends its first campaign to the 41,750 Valid addresses. It holds back the 2,450 Risky addresses and tests the catch-all domains separately.
The lesson is in the unresolved count. The 1,150 addresses that never resolved are nearly as numerous as the catch-all group, and they are easy to mislabel as Valid if you only read the headline figures. For a full maintenance routine, see email list maintenance best practices.
Bottom line: Two passes and one retry round turned 50,000 unlabelled rows into 41,750 sendable addresses, and the Risky bucket kept the campaign safe.
How do I run and read a handshake check on my list?
This tutorial uses Unlimited Verifier, which runs the SMTP mailbox check as part of verifying each address.
- Export your list as a CSV. Include the email column and any engagement fields, such as last open or signup date, so you can segment later. Keep the file under the 10MB upload limit.
- Create an account. Set up a free account to pilot on a sample. The Free plan covers 25 lists a month of up to 150 emails each, so you can pilot on up to 3,750 addresses (25 × 150). Free results are kept for 24 hours, so export them the same day.
- Upload the file. Upload and verify a list. CSV and Excel files are accepted, and the email column is detected automatically. On Pro, lists hold up to 25,000 rows, so split larger files first.
- Run the verification. Each address gets syntax, domain, MX and SMTP mailbox checks. Catch-all domains, disposable addresses and role-based addresses are flagged.
- Read the three buckets. Valid addresses are safe for your first sends. Invalid addresses get suppressed permanently. Risky addresses, including catch-all, disposable and role accounts like
info@, are held back. If a role-based result looks wrong, check how verifiers detect role-based addresses. - Spot-check the surprises. If a high-value contact comes back Risky, run that one address through the free single-email checker described above before you decide.
- Export the results. Download CSV, Excel or JSON, and save the summary counts. They are your evidence of what you cleaned and why.
- Re-import and suppress. Re-import only Valid contacts as a new segment in your ESP or CRM, and add Invalid addresses to your suppression list. Unlimited Verifier has no native ESP, CRM or Zapier integrations, so this is a manual export and re-import, or an API workflow.
For developers: API access is included on Pro, with 100,000 emails a month. Single-email checks and bulk batches of up to 10,000 emails per request are supported. Generate an API key to start, and see email verification API and automation for patterns such as checking addresses at signup. For point-of-entry checks, read about real-time email validation. A 50,000-address list needs five batch requests at 10,000 per request.
Bottom line: Export, upload, read the three buckets, hold the Risky group, then re-import only Valid contacts.
What mistakes do people make when reading handshake results?
- Treating a timeout as Invalid. An unanswered connection is unknown, not dead. Retry it before you suppress anything.
- Running checks from a network that blocks port 25. Every address looks bad, and a healthy list gets deleted.
- Sending checks in one burst. Rapid-fire probes against one domain invite throttling and 4xx replies. Space them out.
- Treating
250as proof of consent. The handshake shows the mailbox exists. It does not show the person wants your mail. - Ignoring catch-all domains. Every address on an accept-all domain returns
250, so the handshake alone can't separate real from invented addresses. - Putting Risky addresses in the first send. They belong at the end of a re-entry ramp, not the start.
- Losing results to expiry. Free results are kept for 24 hours and Pro results for 30 days. Export as soon as a run finishes.
- Trusting one vendor's verdict as final. Disagreement is most common on Risky addresses, so test the ambiguous group before acting on it.
Bottom line: Most handshake mistakes come from treating "no answer" as an answer, and from trusting a single run without retries or a clean network.
How we compared (and limitations)
This guide is based on public documentation: the SMTP protocol in RFC 5321, the enhanced status codes in RFC 3463, the STARTTLS extension in RFC 3207, and the submission-port guidance in RFC 6409. The reply-code mapping, the 15-minute retry starting point and the 3% unresolved threshold are our practitioner recommendations, not published industry standards. We haven't run controlled tests against individual mail providers, and receiving-server behaviour changes without notice.
Unlimited Verifier's features, plan limits and the 99.5% deep-verification accuracy figure are the company's own published claims. The worked example uses hypothetical numbers to show the arithmetic.
To see handshake results for your own list, upload a sample to a free account and compare the Valid, Risky and Invalid counts with what your ESP reports after your next send.
Illustrative reply-code triage
| Reply | Meaning | Action |
|---|---|---|
| 250 2.1.5 | Mailbox accepted | Valid (check catch-all first) |
| 550 5.1.1 | Mailbox does not exist | Invalid, remove |
| 421 or 451 | Temporary failure | Retry later |
| Timeout or no reply | Unknown | Mark Risky, do not mail |
Frequently asked questions
Does an SMTP handshake check send an email?
No. The check stops after the RCPT TO reply and then sends QUIT. The DATA command, which carries the message body, is never sent, so no email is delivered to the mailbox.
What does a 250 reply to RCPT TO mean?
A 250 reply means the receiving server accepted the recipient address for delivery. It is a strong signal that the mailbox exists, though some servers accept every address, so it should be read alongside catch-all detection.
What does a 550 reply mean during a handshake?
A 550 reply is a permanent refusal. When it carries a 5.1.x enhanced code, such as 5.1.1, it usually means the mailbox does not exist. Treat these addresses as Invalid.
What does a 4xx reply mean?
A 4xx reply is a temporary failure, such as greylisting or rate limiting. The address should be retried later rather than marked Invalid, because the server may accept it on a later attempt.
Why do some handshake checks return no answer?
Silence can come from firewalls blocking port 25, timeouts, or servers that hide mailbox status. Results without a clear reply should be marked Unknown or Risky rather than Valid.
What is a catch-all domain in SMTP verification?
A catch-all domain is configured to accept mail for any address, real or not. A handshake will return 250 for every mailbox, so the result cannot confirm an individual address and should be held as Risky.
Why does STARTTLS appear during the handshake?
STARTTLS, defined in RFC 3207, lets the client upgrade the connection to encryption. Verifiers often use it when offered so the conversation is not sent in plain text.
Is an SMTP handshake check the same as an MX lookup?
No. An MX lookup checks which servers handle a domain's mail, while the handshake asks one of those servers whether a specific mailbox exists. The handshake is the step that tests the mailbox itself.
Why do verifiers pick the lowest MX preference value first?
Lower preference values mean higher priority. Connecting to that host first mirrors how real senders deliver mail, so the reply reflects the server that would actually receive the message.
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.