How to Interpret SMTP 220 vs 250 Codes in Server Setup 2026
Understand what SMTP 220 and 250 codes mean during email server session setup. Learn how to diagnose delivery issues, avoid bounces, and improve inbox.
What Do SMTP 220 and 250 Codes Actually Mean?
You just hit send on your first email after setting up a new server—yet the logs show a 220, not a 250. Did it work? What do those numbers even mean?
SMTP codes like 220 and 250 aren’t just random numbers. They’re signals from the server, telling you exactly where in the connection process you are. Confusing them leads to missed bounces, failed deliveries, or false alarms about server health.
Understanding how to interpret SMTP 220 vs 250 codes in email server session setup 2026 isn’t about memorizing a list—it’s about knowing when the server is ready versus when it actually completed your request. This clarity prevents misdiagnosing delivery issues and keeps your mail flow predictable.
Key takeaways
- SMTP 220 means the server is ready and awaiting your first command—this is the beginning of the session, not a success signal.
- SMTP 250 means a command was successfully processed; it confirms the server acted on your request, not just that it’s listening.
- Mistaking 220 for a transaction success leads to incorrect assumptions about email delivery status and can delay troubleshooting real issues.
Why Do SMTP 220 and 250 Codes Matter for Email Verification?
SMTP 220 and 250 codes are critical checkpoints in email verification: 220 confirms the server is online and ready to accept commands, while 250 verifies that a specific mail transaction—like recipient acceptance—was successfully acknowledged. Relying on both ensures you're not just testing a server’s presence but its actual ability to handle and deliver messages. This distinction separates real email readiness from false signals like temporary downtime or misconfigured servers.
220: The Server’s Welcome Signal
The 220 code is the first response a mail client receives when connecting to an SMTP server. It means the server is up, responding, and ready to handle email transactions. While this seems like a basic check, it's foundational—no 220 means no connection, no verification, no delivery. Tools that skip this step risk assuming availability without confirmation.
But 220 alone isn’t enough. A server can reply 220 even if it’s misconfigured, rate-limited, or configured to reject all messages. That’s why you can’t trust 220 as proof of deliverability—it only confirms the server is awake, not that it will accept your email.
250: Confirmation of Transaction Success
The 250 code is the real indicator of success. When a server responds with 250 after an RCPT TO command, it means the recipient address was accepted for delivery. This is the moment a verification tool confirms the email is valid and the server is willing to accept mail for it.
Think of 220 as “Hello, I’m here.” Think of 250 as “I’ll accept this message.” Only when both are present—220 followed by 250—can you be confident you're dealing with a fully operational and responsive mail endpoint.
SMTP specification, defined in RFC 5321, outlines these codes as part of the standard transaction flow. The protocol exists to prevent wasted effort and unreliable data. Tools that fail to validate both stages risk returning false positives, especially on servers with catch-all configurations or greylisting policies.
For example, a server might respond 220 and then ignore a sender or recipient command entirely—returning a 550 or 500 later. A proper verifier doesn’t stop at 220; it waits for 250 to confirm acceptance. The difference is stark: one is a handshake, the other is an actual delivery promise.
Advanced verification services like bulk email verification use this process to filter out inactive, malformed, or intentionally misleading addresses. They follow the full SMTP transaction path, validating each step—not just the initial response.
Without validating both codes, your list may include addresses that respond briefly but never deliver. That’s why relying solely on 220 is a common source of high bounce rates, sender reputation damage, and low inbox placement. True verification requires the full picture.
SMTP Session Flow: Where 220 and 250 Appear in Real Time
During an SMTP session, the server greets you with code 220 to signal it’s ready to accept commands. After you identify yourself with HELO or EHLO, it replies with 250 to confirm the handshake is accepted. Every subsequent command—MAIL FROM, RCPT TO, DATA—triggers a 250 response if the server processes it successfully. These codes are the backbone of reliable email transmission, verified in real time via standard protocol layers.
Step-by-Step SMTP Flow: What Each Code Actually Means
- Client connects → Server responds with 220 (READY) When you connect to the SMTP server, it immediately sends a 220 code. This means the server is operational and ready to accept commands. It's not a confirmation of anything specific yet—just an opening handshake. You’ll see this in logs from tools like IANA’s SMTP code registry.
- HELO/EHLO sent → Server replies with 250 (OK, accepted) You send HELO or EHLO with your domain name. The server replies 250 to confirm it recognizes your identity and will proceed. This step validates the sender’s claimed domain. Without it, your request won’t move forward.
- MAIL FROM sent → Server responds with 250 (OK, sender accepted) You send the sender address. A 250 response means the server accepts the return path. It checks for format validity, domain reachability, and basic reputation signals. If the email fails here, delivery never starts.
- RCPT TO sent → Server replies with 250 (OK, recipient accepted) You define the recipient. A 250 here means the server accepts that user as a valid destination. If this fails, you’ll get a bounce later—possibly with a 550 or 551 error. But 250 confirms the address is valid at the server level.
- DATA sent → Server responds with 250 (OK, message queued) The full message body, headers, and all data follow. Upon receipt, the server replies 250 to confirm it has queued the message for delivery. This is the final success signal. The message is now in the outbound pipeline.
Why This Matters for Deliverability and List Quality
Understanding this flow shows you where verification efforts should focus. A valid email might still fail if the server rejects it later due to policy filters, greylisting, or sender reputation. But catching these early—before sending—minimizes bounces and protects your sender score.
Use a tool like bulk email verification to test lists against real SMTP servers before sending. It checks for syntax, domain reachability, and response patterns, including 220 and 250 signals, to flag risky addresses before they impact deliverability.
For automation, the real-time API provides instant validation during user signup or onboarding, reducing the risk of invalid or disposable emails entering your system.
Common Mistakes When Misreading 220 and 250 Codes
Confusing SMTP 220 with delivery confirmation or treating 250 as a guarantee of inbox placement is how most teams misread server responses. A 220 only means the server is listening. A 250 means the recipient address was accepted for routing—but not necessarily delivered. These codes reflect the handshake, not the outcome. For accurate inbox placement, you need more than a server’s promise.
What the Codes Actually Mean
- 220 means the server is available—not that the email will reach an inbox. It's like hearing “Hello” when you call a business. No guarantee you’ll speak to the right person.
- 250 means the server accepted the recipient address, but not that it was delivered. Many systems accept a message only to filter it later—especially if sender reputation is poor or content is flagged.
- Not all 250 responses indicate successful delivery. You could get a 250 from a catch-all inbox, greylisted server, or a mailbox that routes messages to spam. Acceptance ≠ inbox placement.
Practical Fixes for Teams Using SMTP Logs
- Don’t treat a 220 as a green light. It’s only part of the handshake. Use tools that test actual inbox placement—like inbox placement testing—to verify delivery accuracy.
- Don’t assume 250 means successful delivery. Check for late bounces, spam folder placement, or DNS-level filters that intercept messages after acceptance.
- Validate sender reputation and content before sending. Even a 250 response can fail later if the server blocks your IP, domain, or message content. Use bulk verification to clean lists before sending.
Remember: SMTP codes are system-level acknowledgments. They don’t reflect mail client behavior or filtering rules. A 220 is not a delivery promise. A 250 is not a receipt. Real success requires testing where the email actually ends up—not just what the server says in the first few seconds.
“The SMTP handshake is the doorbell. The mailbox is the office. You may get a ‘hello’—but that doesn’t mean you were admitted.”
For teams building reliable email workflows, real-time verification via SMTP API checks can surface risks like catch-alls, role accounts, or disposable domains before sending. It’s not about trusting the server’s first reply—it’s about understanding where the email truly lands. And that starts with measuring the outcome, not just the signal.
How Catch-All Domains and Greylisting Affect SMTP Code Behavior
SMTP 250 responses can be misleading when a server has a catch-all policy, accepting all addresses regardless of validity. Greylisting may delay acceptance with temporary 4xx errors, making a clean 220 then 250 sequence inconsistent. You must account for these behaviors to avoid false positives in email verification.
Catch-All Domains Don’t Mean Valid Email Addresses
When a domain uses a catch-all policy, it returns a 250 "OK" response for any recipient—even non-existent ones. This inflates success rates and gives a false sense of deliverability. A 250 code here doesn't confirm a real inbox; it just means the server is willing to receive mail.
Let’s be clear: a 250 after RCPT TO in such cases signals acceptance by the server, not a valid user. It’s a red flag you should filter out during list hygiene. Tools like EmailListChecker’s bulk verification identify these patterns by analyzing response behavior and correlation with known catch-all signatures.
The real test isn’t the code—it’s whether the mail eventually reaches an inbox. Catch-alls are a common way to reduce bounce rates in lists, but they hurt engagement and sender reputation over time.
Greylisting Can Disrupt the Expected SMTP Flow
Greylisting intentionally delays responses with 4xx codes (e.g., 451, 421) to filter out poorly configured senders. A server might respond 220, then issue a 4xx for the first message to a new sender—causing confusion when scanning for clean 250s.
That initial 220 says the server is ready. But a subsequent 4xx doesn’t mean failure—it means the server requires a retry after a delay. If your system checks for 250 too early, it may wrongly mark a valid address as invalid.
For accurate verification, you need to handle retry logic. The SMTP RFC 6531 (which governs modern email transport) allows for temporary failures, but many tools don’t simulate retries. Reliable verification services account for this. You can see how email deliverability tests simulate real-world conditions, including greylisting delays.
Understanding these behaviors isn’t just theory. It’s how you avoid wasting sends on unresponsive or non-deliverable addresses. Tools that only check for immediate success rates miss the long game.
What Email Verification Tools Like Emaillistchecker.io Do With These Codes
When an email verification tool connects to a mail server, it uses SMTP codes like 220 and 250 to confirm server readiness and message acceptance. A 220 response means the server is online and ready to accept a connection—this is the first step in validating an email’s infrastructure. A 250 response during message submission indicates the server accepted the recipient address, suggesting it’s valid. Tools use this sequence not just as a signal, but as part of a larger validation pipeline that checks MX records, domain reputation, and delivery behavior.
How 220 and 250 Confirm Server Reachability and Acceptance
Let’s break it down: when you send an email, your server first greets the recipient’s mail server with a 220 code. This means “I’m here, go ahead.” The real-time verification API on platforms like Emaillistchecker.io uses this to confirm the domain’s mail server is active before even attempting to deliver a test message. If the server doesn’t respond with 220 within a reasonable timeout, the address is flagged as unreachable—no further checks needed.
Once the handshake is complete, the tool sends a simulated message. If the server responds with a 250 code—“Your message has been accepted”—it means the address is likely valid. But here’s where it gets precise: tools don’t rely on this alone. Instead, they cross-check the 250 response with data from DNS records (especially MX and SPF), domain blacklists, and known patterns of invalid or fake domains.
Preventing False Positives Through Multi-Layered Validation
Not every 250 response means the email is usable. Some systems return 250 for any address—this is a catch-all setup. Tools like Emaillistchecker.io avoid false positives by analyzing the full sequence: they look at DNS behavior, whether a domain is commonly associated with disposable email providers, and whether the sender’s IP has a history of spam. A 250 with a known catch-all domain is tagged as “risky,” not “valid.”
This multi-layered approach is why bulk list verification isn’t just a series of SMTP checks. It combines code responses with real-time behavior testing, reputation databases like those from Spamhaus, and historical delivery patterns. For example, if a domain has a long-standing reputation for bouncing or being reported as spam, even a 250 is treated cautiously.
For teams needing to verify large lists at scale, this layering ensures higher deliverability. The system doesn’t assume validity based on one code; it evaluates the entire context. You can test this in action with bulk verification or integrate real-time checks via our verification API. Both rely on this same foundation: SMTP codes as signals, not guarantees. For deeper insight into how email delivery works, see the official SMTP RFC (Request for Comments 5321).
How 220 vs 250 Codes Help Detect Role and Disposable Email Addresses
SMTP 220 signals a server is ready, while 250 confirms a command was accepted. Role emails like admin@ or support@ often reply 220 but reject mail later, showing a 220-to-250 pattern that looks valid but isn’t. Disposable domains commonly send 220 and 250 during initial setup but fail on RCPT TO, revealing they’re not usable for delivery. Tools like Emaillistchecker.io detect these inconsistencies to flag risky or invalid addresses early.
Role Addresses Hide Behind 220, But Fail Later
Role emails are designed to collect messages, not to be deliverable. They often respond with 220 and accept the initial HELO, but then reject MAIL FROM or RCPT TO with a 5xx error. Their 250 responses can be misleading because they’re sent during setup, not delivery validation. You might see a 220, followed by a 250 for MAIL FROM, then a 550 from RCPT TO — a clear sign the address isn’t functional.
Real servers do not accept mail for role addresses unless explicitly configured to do so. You can’t send to [email protected] expecting delivery, even if it passes early SMTP checks. This is where automated verification tools step in — they simulate the full transaction, spotting these silent failures.
Disposable Domains Use Fake 220/250 to Pass Checks
Disposable email providers use short-lived domains to avoid detection. They typically reply 220 and 250 during greeting and HELO, making the address seem legitimate. However, when you send RCPT TO, they reject it with a 550 or 553, often because the account is blocked or expired. This behavior reveals their true nature: valid on setup, but not for real delivery.
These domains often lack proper SPF records or send from unverified IPs, making them unreliable for marketing campaigns or user onboarding. By analyzing the full SMTP session — not just the initial codes — services like Emaillistchecker.io can detect this pattern. You’re not just checking syntax; you’re testing actual deliverability.
Understanding what 220 and 250 really mean helps you see through surface-level validation. The real issue isn’t whether an address replies with 220 or 250 — it’s whether the server will accept mail at the end of the conversation. For teams sending at scale, this difference means less bounce rate, better sender reputation, and higher inbox placement.
For deeper analysis, you can run bulk list verification with real-time SMTP checks using Emaillistchecker.io's bulk verification to see how addresses behave across multiple SMTP states — from connection to final acceptance. The goal isn’t just to catch invalid syntax, but to expose non-deliverable patterns your list might otherwise miss.
A Real-World Example: Debugging a Failed SMTP Session
You can interpret SMTP 220 as "server is ready" and 250 as "command was accepted," but the real insight comes when a 250 response is followed by a 550 later—meaning the server is up and accepting connections, but the recipient address doesn’t exist. This is a key signal: the mail transfer setup succeeded, but the destination email is invalid or unreachable. Use this pattern to distinguish between server issues and invalid addresses.
The SMTP Session in Action
- Client connects to the server. The server responds with
220. This confirms the server is running and listening on the correct port—typically 25 or 587. A 220 response alone doesn’t mean the email will deliver, but it does mean the server is operational. According to RFC 5321, this is the standard start of an SMTP session. - Client sends HELO or EHLO. The server replies
250if it accepts the domain. This indicates the handshake is acknowledged—your identity is recognized, and the session continues. This is when you know the server isn't rejecting you on protocol grounds. - Client issues MAIL FROM. The server replies
250if it accepts the sender address. This is a formal acceptance of the return path. A 250 here means the server has no issue with your sending identity—no sender policy violations detected. - Client sends RCPT TO. The server replies
550with a message like "User unknown." This signals that the receiving server has confirmed it does not host the specified email address. A 550 is not a server-level error—it's a recipient-specific rejection, meaning the address does not exist, is misspelled, or is blocked.
Why This Matters for Deliverability
You may see 220 and 250 responses, and assume everything is fine. But the 550 at RCPT TO stage clearly shows the address is invalid. This is the key difference between server availability and address validity. You can verify this reliably using tools like bulk email verification, which tests real delivery paths without sending actual messages.
Even with a 250 response to MAIL FROM, a 550 at RCPT TO proves the recipient address is invalid. This is often missed by manual checks but caught by real-time verification services.
Understanding this sequence helps you avoid sending to non-existent addresses. It also explains why some email lists bounce even though the servers appear to accept connections. For teams managing large campaigns, catching these cases early means better sender reputation and higher inbox placement. Tools like the real-time API automate this validation across thousands of addresses without sending real messages.
Why Relying on 250 Alone Can Break Your Email Strategy
Seeing a 250 response from an SMTP server doesn’t mean your email landed in the inbox. It only means the server accepted the message for routing. Many emails get a 250 reply but end up in spam, quarantined, or silently dropped—especially if sender reputation, content, or authentication is weak. Relying solely on 250 to validate deliverability gives a false sense of security, leading to wasted sends and poor list hygiene.
Distinguishing Acceptance from Delivery
SMTP 250 indicates the server accepted your message, but it doesn’t confirm delivery to the recipient’s inbox. The server may route it to a spam folder, trigger a rejection based on reputation, or apply greylisting that delays delivery. Even with a 250, some messages never reach the end user—particularly if the sender is untrusted or the content triggers filtering rules.
Think of it like a shipping carrier saying “we’ve taken the package” but not guaranteeing it arrives on time—or at all. A 250 is the server’s promise to try, not a guarantee of success. Let’s be honest: if your list has outdated or invalid addresses, even a 250 won’t help. That’s why high 250 counts don’t equate to high inbox placement.
The Hidden Risk of False Positives
Many email tools still treat a 250 as a success metric. This inflates success rates and masks problems. You might think your campaign is doing well, but in reality, you’re sending to addresses that never see the email. That damages sender reputation over time and increases the risk of being blocked by ISPs like Gmail or Outlook.
According to industry data from Return Path (now Validity), emails to non-existent or invalid addresses contribute to sender reputation decay—even if the SMTP server initially accepts them. And while not all 250s are false positives, the lack of deeper validation means you’re guessing about deliverability. That’s how strategies fail quietly.
Even if your sender policies are strong, a list with too many risky or disposable emails can still degrade performance. For example, catch-all domains or role accounts (like admin@ or support@) often get a 250 but rarely deliver meaningfully to real people. A 250 doesn’t verify the address is real—or that it’s a real, engaged user.
To avoid this, you need a tool that goes beyond SMTP responses. Real-time verification checks not just MX records and syntax, but also if an address exists, is disposable, or is on a blocklist. That’s why Emaillistchecker.io’s bulk verification gives you a true picture of your list’s health. Unlike tools that rely on 250 alone, it identifies invalid, risky, or dormant emails before you send.
Check your list’s true deliverability with our bulk verification tool. You’ll see exactly which addresses are worth sending to, and which ones will hurt your reputation.
How Emaillistchecker.io Uses SMTP Code Behavior to Improve Accuracy
When you verify an email list at scale, we use the initial 220 greeting from mail servers to confirm basic reachability across thousands of domains. Then, we analyze 250 responses not just as “success,” but in context—checking whether a "valid" reply matches known catch-all behavior, sender reputation, and domain patterns. This layered logic, combined with real-time reputation data, is why our system achieves 98.9% accuracy in detecting invalid or risky addresses.
220: Confirming Server Reachability Before Any Send
Every email verification starts with a 220 response—the server’s welcome message. We use this signal across millions of domains to filter out unreachable or misconfigured servers early. If the server doesn’t reply with 220, the address won’t receive mail anyway, so we mark it as unreachable. This avoids wasted sends and prevents poor sender reputation from being tainted by dead endpoints.
That check is fast and reliable—220 is part of the SMTP RFC 5321 standard, the foundation for modern email delivery. It means the server is listening, even if the specific address is invalid. You might get a 220 from a catch-all or a locked-down domain, but missing it means the server isn’t responding at all—so we don’t waste time on it.
250: Reading Between the Lines of Success Responses
Once we trigger a 250 response—the standard “OK” from a server—we don’t just treat it as “valid.” That’s where the real work begins. A 250 doesn’t tell us if the mailbox exists; it only confirms the server accepted the command. We check for red flags: if a domain consistently returns 250 on every test, it may be a catch-all. So we cross-reference the result with historical patterns, domain age, and IP reputation.
For example, a high-volume B2B sender will see more 250s from a catch-all domain than an individual. Our algorithm uses this context—alongside data from tools like Spamhaus and MxToolbox—to flag such addresses as risky. This stops you from sending to a mailbox that’s not actually a person, reducing your bounce rate and protecting your sender reputation. You can test this in real time with our inbox placement tool, which simulates delivery and measures where your emails land.
Final Takeaways: What SMTP 220 and 250 Really Tell You
An SMTP 220 response means the server is active and ready to accept connections. It confirms service availability but says nothing about the email address’s validity or deliverability.
An SMTP 250 response means a step in the transaction completed successfully — such as accepting the sender or recipient address. It does not guarantee inbox delivery, as content filtering, reputation, or spam scoring may still block the message.
Never rely solely on 220 or 250 codes. They are signals within a larger system. Combine them with DNS checks, MX validation, sender reputation analysis, and address-level verification for accurate results.
Tools like Emaillistchecker.io automate this layered validation. They interpret code sequences in context, reducing bounces and improving sender trust without requiring deep technical expertise.
Keep reading
- Engineering guides: frameworks, pipelines and data imports (complete guide)
- SMTP 511 Response Code Troubleshooting for Resource-Constrained Nodes
- How to Fix SMTP 554 Error from Null MX Record
- How to Verify Email Server Responsiveness on IPv4 and IPv6
- SMTP 530 Error No Realm in SASL for Node.js Email Verification
Ready to put this into practice? Emaillistchecker.io verifies emails with 98.9% accuracy — start with 100 free verifications.
Frequently asked questions
Does a 220 response mean the email address is valid?
No. A 220 only confirms the server is available. It does not verify the recipient address. Use follow-up checks to confirm validity.
Can a 250 response be a false positive for deliverability?
Yes. A 250 may indicate server acceptance but not inbox placement. The message could still be filtered or rejected later.
How do catch-all domains affect SMTP 220 and 250 responses?
They often return 250 for any address, making it hard to determine if a specific email is valid. This requires additional verification.
Why does my email tool show 250 but my messages aren’t delivered?
A 250 only means the server accepted the transaction. Later filters, spam scoring, or greylisting may block delivery after the handshake.
Can SMTP codes detect disposable email addresses?
Not directly, but inconsistent code patterns — like 220/250 for HELO but 5xx for RCPT TO — can signal disposable domains.
What’s the role of 220 in email verification APIs?
It confirms the mail server is reachable and operational before testing individual addresses. It’s a first-level check.
How does Emaillistchecker.io use SMTP codes in bulk verification?
It uses 220 to test server readiness and sequences of 250 responses across multiple steps to validate address legitimacy.
Is 220 always sent at the start of an SMTP session?
Yes. The server must respond with 220 immediately after a TCP connection is established, before any command is sent.
Can delayed responses affect how 220 and 250 are interpreted?
Yes. Greylisting or high load can delay responses, making a 220 or 250 seem unreliable. Tools factor in timing and retry behavior.
Should I trust a 250 if the server is not listed on a blocklist?
Not necessarily. A clean blocklist doesn't guarantee delivery. Sender reputation, message content, and ISP policies also matter.
How can I test SMTP code behavior on my own?
Use telnet or openssl to connect to an SMTP port, then manually send HELO, MAIL FROM, and RCPT TO. Observe the response codes.
Why are 220 and 250 more important than other SMTP codes?
They mark the beginning and progression of server interaction. Without 220, the session can’t start; without 250, no transaction is confirmed.