Why the 220 Code Matters for SMTP Handshake Success

You just connected to an SMTP server—no errors, no timeouts—but your email still didn’t send. It’s not always about authentication, content, or deliverability. Sometimes, the problem starts with a single code: 220.

The 220 response is the first signal a mail server sends after a TCP connection is successfully established. It means, “I’m ready. Proceed.” Without it, the SMTP handshake never starts. With it, you’re in the door.

Think of it like the front door of a secure facility. The lock clicks (TCP ready), but you need the guard to say “Come in” before you’re allowed to walk through. One missing “come in,” one delayed reply, or a fake code, and the whole process fails—fast, silently, and often without clear warning.

How to test if your mail server returns the correct 220 code on connection? That’s what this guide covers. You’ll learn how to detect issues early, avoid delivery failures before they happen, and keep your sending reputation intact.

Key takeaways

  • The 220 code is the first confirmation a mail server sends after a TCP connection is established—its absence or delay breaks the SMTP handshake.
  • A misconfigured or non-responsive server may not return 220 at all, leading to immediate connection refusal or misclassification as spam.
  • Proactively testing for 220 response timing and correctness prevents failed deliveries and helps maintain a strong sender reputation.

What Happens When a Mail Server Fails to Return 220 Promptly

If your mail server doesn’t return a 220 greeting within 60–120 seconds of connection, the sending client may time out and mark the message as a soft bounce. This delay can stem from intentional throttling to deter spam, but it also harms sender reputation if it becomes consistent. In some cases, misconfigured servers return 5xx errors instead, which are treated as permanent failures and lead to hard bounces, even when the mailbox is valid.

Timing and Connection Behavior

SMTP clients expect the 220 response within a standard window—usually under two minutes. If the server delays too long or disconnects before sending it, the client assumes the server is unresponsive or misconfigured. This is especially common in heavily throttled or poorly maintained systems. For senders relying on automation, such timeouts directly impact delivery success rates.

Some mail servers intentionally slow down the initial 220 response to limit spam scanning. While this may help filter illegitimate connections, it harms legitimate outreach when used excessively. A consistent delay of over 60 seconds risks triggering rate-limiting behavior in sending platforms, reducing your chances of inbox placement over time. According to RFC 5321, the SMTP protocol specifies that servers must respond promptly to maintain reliable communication—delays outside this guideline are not standard behavior.

Common Misconfigurations and Their Consequences

When a server doesn’t return 220 at all, it’s often because of a misconfigured service, a firewall drop, or incorrect DNS settings. In these cases, the client receives no valid response or is instead handed a 5xx error like 554 (Transaction failed). This falsely marks the recipient as invalid, even if the address is active and accepting messages.

For example, a server running an outdated MTA might reply with an error like 500 (Syntax error) or 502 (Command not implemented) instead of the expected 220. These errors are treated as hard failures regardless of the actual state of the mailbox. You might be losing valid connections due to these signals alone. This is why testing the initial handshake is a critical step in maintaining list health.

Use tools that simulate real SMTP connections to detect these issues early. Bulk verification with a service that checks the SMTP handshake phase—including 220 response times—can uncover hidden delivery risks before they impact your campaign results.

How to Test Mail Server Returns Correct 220 Code on Connection

You can test if a mail server returns the correct 220 response by manually connecting via telnet or OpenSSL on port 25 or 587. Wait 10–30 seconds after connection; a proper 220Service ready indicates the server is ready to accept mail. If you get a 5xx code instead, the server rejected the connection. Repeat from different networks or locations to rule out transient issues.

Run the Test with Command-Line Tools

  1. Open a terminal or command prompt. Use telnet or OpenSSL to connect to the target mail server on port 25 (SMTP) or 587 (submission). For example: telnet mail.example.com 25 or openssl s_client -connect mail.example.com:587. This simulates a real SMTP handshake.
  2. Wait for the server’s initial response. After connecting, wait up to 30 seconds. A valid mail server responds with 220 mail.example.com Service ready. This confirms the server is up and speaking the correct protocol.
  3. Check the response code. If you receive a 5xx code—like 550 (mailbox not found), 554 (rejected), or 500 (command unrecognized)—the server either blocked you or is misconfigured.
  4. Log the result. Note exact responses, timing, and source IP. Repeating from multiple locations helps determine if the behavior is consistent or due to network filters, blacklists, or local routing issues.
  5. Test across geographies. Use a tool like MxToolbox or a remote VPS to simulate connections from different regions. This rules out issues like local IP blocking or regional firewall rules that don't reflect the server’s true state.

Why the 220 Code Matters

The 220 response is the foundational handshake in SMTP. A server that fails to send it is not properly handling incoming connections, which impacts deliverability. According to RFC 5321, Section 4.2.1, mail servers must send a 220 greeting upon connection to begin a session. Deviations—like no response, timeouts, or 5xx codes—signal underlying problems.

Run the Test with Command-Line ToolsThe 5 steps described in “Run the Test with Command-Line Tools”, in order.1Open a terminal or command prompt. Use telnet or OpenSSL to connect tothe target mail server on port 25 (SMTP) or 587 (submission). Forexample: telnet mail.example.com 25 or openssl s_client -connectmail.example.com:587. This simulates a real SMTP handshake.2Wait for the server’s initial response. After connecting, wait up to 30seconds. A valid mail server responds with 220 mail.example.com Serviceready. This confirms the server is up and speaking the correct protocol.3Check the response code. If you receive a 5xx code—like 550 (mailbox notfound), 554 (rejected), or 500 (command unrecognized)—the server eitherblocked you or is misconfigured.4Log the result. Note exact responses, timing, and source IP. Repeatingfrom multiple locations helps determine if the behavior is consistent ordue to network filters, blacklists, or local routing issues.5Test across geographies. Use a tool like MxToolbox or a remote VPS tosimulate connections from different regions. This rules out issues likelocal IP blocking or regional firewall rules that don't reflect theserver’s true state.
The 5 steps described in “Run the Test with Command-Line Tools”, in order.

If you're regularly seeing 220 issues with specific domains, it's worth checking DNS records, SPF, or reputation. Tools like bulk verification can catch these at scale. They validate email addresses and detect server-side delivery risks before you send.

Common Causes of Missing or Incorrect 220 Response

When your mail server doesn’t return a proper 220 greeting code on connection, it’s usually due to a misconfigured SMTP daemon, temporary rejection via greylisting, rate-limiting policies, or firewall rules dropping traffic before it reaches the service. Let’s break down each one so you can troubleshoot with precision.

SMTP Service Issues

  • Check that the SMTP daemon (like Postfix or Exim) is actually running. A failed service won’t respond at all — no 220, no connection.
  • Verify the service binds to the correct port (usually 25, 587, or 465) and isn’t blocked by system-level firewalls like iptables or firewalld.
  • Old or outdated mail server software may not handle modern handshakes correctly — update to a maintained version to avoid silent failures.

Temporary Rejection & Rate Limiting

  • Greylisting may delay or block your connection on first attempt. Senders unfamiliar to the recipient’s server will often see a temporary 421 or 451 response instead of 220 — it’s by design and common in enterprise environments.
  • IP reputation filters and rate limiting can drop incoming TCP handshakes before the SMTP service responds. If your IP is on a blocklist, even a correct 220 may not be sent.
  • Too many connection attempts in a short window trigger defensive filters. This isn’t a protocol error — it’s a security measure. Use bulk verification tools to clean sender lists and avoid overloading recipients’ servers.

Network Layer Interference

  • Firewall rules, especially on cloud providers like AWS or Google Cloud, may drop connections before they reach the mail server. Check ingress rules and security groups.
  • Reverse proxy or load balancer misconfiguration can intercept TCP handshake attempts without forwarding them properly.
  • Some networks drop SMTP traffic entirely unless it’s encrypted (TLS), which can block unencrypted test connections. Use tools like inbox placement testing to simulate real-world delivery attempts.
Don’t assume a missing 220 means your server is down — it could be a deliberate, temporary block. The 220 code is only the first step in a complex handshake, and many gateways intervene before it even appears.

Diagnostic Practices

  • Use telnet or OpenSSL to manually test the connection: telnet yourserver.com 25 or openssl s_client -connect yourserver.com:587 -starttls smtp. The first response should be 220.
  • Check DNS MX records are correct — a misconfigured mail routing setup can prevent the SMTP port from being reached at all.
  • Refer to RFC 5321 (SMTP) for official specifications on the 220 response code and expected behavior during connection setup. The full standard is available at IETF's RFC 5321.

How Emaillistchecker.io Verifies SMTP Readiness Beyond the 220 Code

You don’t just check if a mail server returns a 220 greeting — you validate whether it responds in a timely, correct, and reliable way during a real SMTP handshake. Our system tests actual connections, measuring response time, handling of 5xx errors, and server behavior under real conditions, not just passive pings.

Real SMTP Handshakes, Not Just Pings

Many tools check if a server is up by pinging the IP or testing DNS records — that’s not enough. Let’s be clear: a server can be reachable but still fail to send mail. Emaillistchecker.io initiates full SMTP handshakes to see if the server returns a 220 code within 30 seconds — the industry-standard expectation.

If the server takes longer than 30 seconds or returns a 5xx error code instead of 220, we flag it. These delays often indicate intentional anti-spam measures, such as greylisting or rate limiting, which aren’t caught by passive checks.

Layered Verification for Real-World Readiness

We don’t stop at the 220 code. We combine SMTP handshake results with up-to-date MX record validation, DNS lookup checks, and detection of role-based addresses (like admin@ or support@) that may not accept mail even if the server is responsive.

This layered approach helps distinguish between technically reachable servers and those that are intentionally slowing down or blocking incoming mail. For example, a server may reply with 220 but then delay processing for 60 seconds — a signal that it’s using anti-spam mechanisms. Our system captures that behavior and logs it as a risk.

Our 98.9% accuracy rate reflects this depth. It’s not just about whether the server says “220” — it’s about whether it performs reliably enough to deliver your message. This level of detail matters when you’re sending thousands of emails and want to avoid bounces and inbox placement issues.

You can test your list with our bulk verification tool or use our real-time API for automated checks during onboarding or campaign prep. The result? Fewer hard bounces, better sender reputation, and higher deliverability.

For deeper insight, tools like RFC 5321 define the SMTP protocol behavior, including the 220 response code and expected timing. We follow those standards closely to ensure your mail server checks are precise, not just convenient.

What the 220 Code Means in Practice: A Real-World Example

When you connect to an SMTP server like smtp.example.com on port 25, a valid mail server should respond within 20 seconds with a 220 code—specifically, 220 smtp.example.com ESMTP Service ready. This confirms the server is online, accepting connections, and ready to process email. If it doesn’t respond at all, or replies with a 554 or 421 code, the server is either down, rate-limiting, or misconfigured. These signals are logged and analyzed across thousands of tests to assess a domain’s reliability in real-world delivery.

How to Test the 220 Response in Practice

Let’s walk through a real test. Open your terminal and type telnet smtp.example.com 25. If the server is responsive, within 20 seconds you’ll see 220 smtp.example.com ESMTP Service ready. That’s your green light—connection is valid, and the server is ready to accept email. If the connection hangs past 20 seconds, or drops with no response, the server may be offline, blocked, or intentionally delayed to prevent spam.

If you get a 554 Message rejected: access denied instead, that’s a hard reject. It tells you the server is up but actively blocking your connection, possibly due to IP reputation, lack of proper DNS records, or internal filtering. A silent timeout is often worse—it suggests the server is unreachable, which could be due to firewalls, misrouting, or a broken MX record.

What This Tells You About Deliverability

These responses aren’t just technical curiosities—they’re early warnings about deliverability. A consistent 220 response with no delays means the server is ready and likely well-maintained. Repeated 554 or timeout errors mean the domain’s mail setup is unstable. Organizations use real-time SMTP connection testing across large sets of domains to spot trends: if 30% of domains in a list fail to return a 220 within 20 seconds, that’s a red flag for poor inbox placement.

Services like inbox-placement testing use this same principle at scale, simulating real sending to gauge whether domains accept mail in practice—not just in theory. This goes beyond DNS checks or simple syntax validation, catching issues like greylisting, IP reputation bans, or strict filtering policies.

The SMTP protocol’s RFC 5321 specifies the 220 code as the standard greeting for a service-ready server. You can read the full specification at ietf.org/rfc5321. While the code itself is simple, what it reveals about a server’s state is anything but trivial—especially when aggregated across thousands of tests.

Why Manual Testing Isn’t Enough for Production Email Flows

Manual telnet testing gives you a snapshot of a single server's 220 response, but it can’t scale across thousands of recipients, catch intermittent issues like greylisting, or integrate with real-time sender reputation or domain deliverability risks. You’ll miss 220-related failures until they break your campaign.

Scaling the Test is Impossible by Hand

Imagine trying to test 10,000 email addresses one by one with telnet. It’s impractical. Every connection takes time, and you’re limited to what you can run locally. Even if you script it, you still can’t track results across multiple domains, time zones, or network conditions.

Hidden Failures Don’t Show Up in Manual Checks

Greylisting, for example, doesn’t block the initial 220 response—it delays it. A manual test connects, gets the 220, and assumes success. But the real system may reject the message after 10 minutes, only to accept it later. This delay is invisible in static testing, but it kills deliverability for new sender IPs.

Similarly, catch-all servers always return 220, even for non-existent addresses. Manual testing sees a positive response and marks the address valid, while automated systems spot the inconsistency and flag it as risky. RFC 5321 defines the 220 status as "service ready," but not all servers follow it correctly—or intentionally.

You also can’t correlate the 220 response with broader signals like domain reputation, DNS records, or historical bounce rates. A server returning 220 doesn't mean the email will be delivered. It just means the door is open.

Automation Detects the Real Risks

Automated verification tools don’t just check the 220 code—they simulate the full SMTP transaction, analyze server behavior, and flag inconsistencies early. They catch greylisting patterns in real time, identify role accounts, detect disposable domains, and assess sender reputation—all before your campaign sends.

With a tool like bulk email verification, you can process 10,000 addresses in minutes, not days. The system evaluates each address for validity, risk, and deliverability, giving you actionable results instead of isolated 220 responses.

When you're sending at scale, the difference between success and failure isn’t whether you see a 220—it’s whether the entire delivery path works. Automation is the only way to verify that.

How Inbox Placement Testing Confirms SMTP Readiness

Testing if your mail server returns the correct 220 code on connection is just the first step. Inbox placement testing goes further by simulating real email delivery from verified sender IPs to see if messages actually land in inboxes—not spam folders or blacklists. It confirms both the SMTP handshake and real-world deliverability success.

The 220 Code Is Necessary, But Not Sufficient

The 220 response means your mail server is ready to accept connections, which is required for any SMTP transaction. But just because you're responding with 220 doesn’t mean your emails will be delivered. Spammers often pass the 220 check but fail the real inbox test due to poor sender reputation, misconfigured authentication, or blocked IPs.

Real inbox placement tests check if your setup survives the full flow: connection, TLS negotiation, authentication (like SPF/DKIM), and final inbox sorting. These steps are monitored by email providers using systems that evolve daily. If your server fails at any point—especially beyond 220—your email won’t reach the inbox.

How Emaillistchecker.io Validates Real Delivery

With inbox placement testing, Emaillistchecker.io sends actual test emails from verified IPs to real inboxes across 12+ major email providers, including Gmail, Outlook, Yahoo, and Apple Mail. These tests mimic real delivery patterns—not just protocol-level checks.

Each test runs through the same filters and reputation systems used by providers. If your server returns 220 but the message ends up in spam or is blocked, the test fails. That’s why a success at the 220 stage is not enough. The test reveals whether your domain, IP, and email content are trusted by real systems.

The results are actionable. You can see exactly which provider rejected your email, why (e.g., SPF failure, blacklisting), and how to fix it. This includes identifying issues like missing or invalid DKIM signatures, non-existent MX records, or poor sender reputation—problems that a simple 220 check never exposes.

Learn how to run inbox placement tests from your current email provider, or explore the full verification process: test inbox placement across major providers with real inboxes.

Email deliverability isn’t just about protocol compliance—it’s about being seen as trustworthy. Standards like those defined in RFC 5321 govern SMTP handshakes, but email providers decide what gets through based on behavior, reputation, and alignment with best practices. Monitoring delivery outcomes, not just syntax, is how you stay in the inbox.

Using Emaillistchecker.io’s API to Test SMTP Readiness at Scale

You can test if a mail server returns the correct 220 response code during connection by using Emaillistchecker.io’s real-time verification API, which performs a full SMTP handshake and validates the initial 220 greeting. This ensures the server is properly configured and responsive before any sending occurs. The API returns specific verdicts—valid, invalid, catch-all, risky, or connection failure—based on actual SMTP behavior, not just syntax.

How the API Validates SMTP Readiness

Let’s walk through what happens behind the scenes: every email address is checked via a direct SMTP connection. The API starts the handshake, listens for the server’s response, and confirms whether it returns the expected 220 code. This is the same standard used in email delivery protocols and defined in RFC 5321. If the server doesn’t reply with 220, or doesn’t respond at all, the result is marked as connection failure—no guesswork.

Unlike tools that only check email syntax or domain existence, Emaillistchecker.io checks the live behavior of the mail server. A server that says "220" is a baseline requirement for accepting mail. If it doesn’t, the email will never be delivered, regardless of how valid the address appears.

Automate and Scale Verification Before Sending

You can integrate the API into your workflow to automatically test every address before launching a campaign. This prevents resources from being wasted on addresses tied to inactive servers, blocked domains, or misconfigured systems—common causes of hard bounces and ISP blocklists.

Sending to addresses on servers that never return 220 is like sending letters to a non-existent post office. You won’t know until days later the mail never arrived. The API catches this in real time, with a 98.9% accuracy rate on verified responses. No more blind sends, no more wasted credits.

It integrates directly with Mailchimp, SendGrid, HubSpot, and Klaviyo. You can set up pre-send validation with minimal code changes. The real-time API also includes support for bulk processing, so you can validate entire lists in minutes. For more detail, see the full API documentation.

For campaigns where deliverability is critical, testing SMTP readiness isn’t optional. It’s a baseline. Emaillistchecker.io doesn’t just verify syntax—your mail server must respond as expected. The 220 code is the first checkpoint. The API confirms it. You avoid the fallout.

Best Practices for Ensuring Consistent 220 Handshake Performance

You ensure consistent 220 responses by testing server responses across multiple regions, maintaining a clean IP reputation, avoiding rapid connection bursts, and using dedicated IPs for high-volume sends. These steps directly reduce handshake failures and improve mail server reliability at scale.

Test Your 220 Response Across Geographies

  • Use tools like bulk verification to simulate connections from different networks and regions, catching location-specific delays or rejections.
  • Monitor response time consistently — a 220 code that appears after 10+ seconds may signal server load, firewall interference, or greylisting.
  • Compare results over time to detect regressions in server performance or DNS propagation issues.

Maintain IP Health to Avoid Rejection Chains

  • Keep your sender IP portfolio clean — avoid shared IPs with poor reputations that trigger greylisting or early 5xx errors.
  • Use inbox placement testing to validate not just delivery, but how your mail server behaves during the initial handshake under real inbox filtering conditions.
  • Limit connection attempts from a single IP: more than 10–15 connections per minute can trigger temporary blocks by mail providers.
  • For high-volume sends, assign dedicated IPs to isolate your reputation from other senders’ actions. This reduces the risk of being penalized for others’ poor practices.
  • Check your IP against known blocklists via Spamhaus or MXToolbox regularly to catch reputational issues early.
When the 220 handshake is delayed or fails, the issue often lies not in the email content, but in infrastructure or reputation. Fixing the foundation reduces bounces before they happen.

SMTP is explicit: a server must return 220 within a reasonable time to continue the session. If your mail server consistently fails to do so under load or from certain regions, investigate delivery infrastructure — not the copy. Let the network confirm your readiness, not guesswork.

Conclusion: The 220 Code Is the First, But Not the Last, Step

A correct 220 response is a necessary baseline for SMTP handshake success. It indicates the mail server is listening and ready to receive connections. Without it, no further communication can occur.

However, a valid 220 response does not guarantee inbox placement. Email may still be blocked due to sender reputation, content filtering, authentication failures, or recipient policies. The 220 test is only the first diagnostic step.

Automated tools like Emaillistchecker.io can validate 220 readiness across large lists and provide ongoing monitoring of deliverability health. This helps catch misconfigurations early and supports consistent sending performance.

Keep reading

Ready to put this into practice? Emaillistchecker.io verifies emails with 98.9% accuracy — start with 100 free verifications.

Frequently asked questions

What does the 220 code mean in SMTP?

The 220 code means 'Service ready' — the mail server has accepted the TCP connection and is prepared to receive SMTP commands.

How long should a mail server take to respond with 220?

A response should come within 20–30 seconds. Delays beyond 60 seconds suggest misconfiguration, greylisting, or network issues.

Can a server return a 220 code and still block email delivery?

Yes. A 220 code only confirms the handshake; the server may still reject the email due to spam filtering, sender reputation, or content issues.

How do I test the 220 code manually?

Use telnet or openssl to connect to the mail server on port 25 or 587. Wait for the server to respond with '220 domain Service ready'.

Does a missing 220 code mean the server is down?

Not necessarily. The server may be configured to delay or reject connections for anti-spam reasons. A missing 220 often indicates deliberate blocking.

Can Emaillistchecker.io verify the 220 code for any domain?

Yes. Our real-time API checks the SMTP handshake, including the 220 response, for any domain. We support bulk testing and API integration.

Do I need to test only outbound connections?

No. Testing inbound server readiness helps diagnose issues when you receive bouncebacks from your own mail server.

Why doesn’t my email send if the 220 code is correct?

A correct 220 code only confirms the connection. Email may still be blocked by filters, rate limits, or content rules after the handshake.

How accurate is Emaillistchecker.io at detecting SMTP issues?

Our platform reports a 98.9% accuracy rate based on real-world SMTP handshakes and domain-level behavior across global networks.

Can I test 220 codes for multiple domains at once?

Yes. Use the bulk verification feature to test hundreds or thousands of domains for correct 220 responses and overall deliverability.