How to Verify That a Mail Server Sends Correct 220 Message in 2026
Learn how to verify that a mail server sends the correct 220 greeting message—essential for SMTP reliability and deliverability.
Why does the 220 SMTP response matter for deliverability?
You send an email. It hits the recipient's mail server. The connection fails—but not because of spam filters, content, or authentication. The real problem started before any message was sent: the server didn’t reply with the correct 220 greeting.
The 220 response is the mail server’s first official signal in an SMTP handshake—“I’m ready, go ahead.” If it’s missing, wrong, or delayed by even a few seconds, the sending server gives up. This isn’t rare. Misconfigured mail servers fail this check daily, causing outbound delivery to fail silently.
Verifying that a mail server sends the correct 220 message isn’t just technical housekeeping. It’s a foundational check for deliverability. Without a proper 220 response, your emails never make it past the first handshake.
Key takeaways
- A missing, incorrect, or delayed 220 response breaks the SMTP handshake and causes immediate connection rejection.
- Even a valid email address and proper authentication won’t help if the mail server doesn’t respond with the correct 220 greeting during the SMTP connection.
- Testing the 220 response is a critical part of diagnosing outbound email delivery failures, especially for systems with unverified or misconfigured mail servers.
What should a correct 220 message look like in practice?
When a mail server responds with a 220 message, it should say 220 mail.example.com ESMTP Service ready—the domain in the greeting must match the server’s actual hostname, usually in the format mail.domain.com. It must appear within 10 seconds of a TCP connection being established. Delays beyond that window often trigger timeouts, especially in automated systems. Firewalls, rate-limiting, or greylisting that block or delay this initial response will break SMTP handshakes, even if the server is otherwise correct.
The standard 220 format
- The response must start with
220, the official SMTP code for "Service ready." - It must include the server’s fully qualified domain name, such as
mail.yourcompany.com, not justyourcompany.com. - It must include a protocol identifier, such as
ESMTP(Extended SMTP) orSMTP, to signal the version and support level. - The message must be sent immediately after the TCP handshake completes, ideally within 1 second. Anything slower risks connection timeouts.
- Firewalls, rate-limiting rules, or greylisting mechanisms should not interfere with the initial 220 response—those delays typically occur after the handshake.
- To verify this behavior, you can use tools like inbox placement testing to simulate real-world send conditions and catch timing or routing issues early.
Common issues behind failed 220 responses
Even if your server is configured correctly, network-level issues can mask the problem. For example, a rate-limiter that blocks connections from certain IPs after a few attempts can prevent proper SMTP handshakes, regardless of server config. Similarly, greylisting may delay or block the 220 response if not properly configured to permit immediate replies.
It’s also common for misconfigured reverse DNS (PTR) records to cause receivers to reject the 220 message outright. The domain in the 220 response should match the one in the PTR record—this is widely expected by modern email services.
For deep verification, especially when sending at scale, tools like bulk verification can reveal how many addresses are affected by delayed or missing 220 responses across real sender-receiver interactions.
These responses are defined in RFC 5321, the foundational SMTP specification. The initial 220 greeting is one of the most basic yet critical steps in the email delivery process.
How to test if your mail server sends the correct 220 message?
You can verify your mail server sends the correct 220 response by using the telnet command to connect to port 25 (or 587 for submission). If the server responds with a line starting with 220 followed by its domain and a clear service-ready message, it’s properly configured. A missing response or error means the server is unreachable, blocked, or misconfigured — a red flag for deliverability.
Step-by-step verification process
- Open a terminal or command prompt and run
telnet mail.example.com 25. Replacemail.example.comwith your actual mail server hostname. This establishes a direct connection to the SMTP service. - Wait for the server’s initial response. The first line must start with
220, indicating the server is ready to accept commands. For example:220 mail.example.com ESMTP service ready. - Confirm the full message includes your domain and a valid status. The response should include your server’s domain name and a clear "service ready" message. This confirms the server announces itself correctly to clients.
- Check for expected behavior. If the connection fails, times out, or returns an error like
Connection refusedorConnection closed by foreign host, the server isn’t accessible or isn’t running on port 25 as expected. - Test with port 587 if using submission. Many modern setups use port 587 instead of 25 for mail submission. Run
telnet mail.example.com 587to verify the service responds with220when used properly.
Why this matters
SMTP servers must send a 220 response to comply with RFC 5321, the foundational standard for email transport. A missing or incorrect response typically means misconfiguration, firewall blocking, or a service outage — all of which prevent outbound email delivery.
If your server doesn’t respond with 220, it may be behind a firewall, running on a custom port, or misconfigured. You can use tools like RFC 5321 as a reference for expected behavior. Network issues, spam filters, or DNS problems can also disrupt this handshake.
For ongoing deliverability health, combine this manual test with automation. Use email verification services that check server readiness and domain reputation as part of bulk validation. Bulk verification tools like EmailListChecker.io help catch issues early by testing large lists for server-level problems, including invalid or unreachable domains.
Common causes of incorrect or missing 220 responses
When a mail server fails to send a proper 220 greeting during SMTP startup, it usually means the server isn’t initializing correctly. Common culprits include misconfigured daemons, throttling firewalls, temporary rejections from greylisting, or overloaded systems that can’t respond in time. If you're troubleshooting delivery, a missing or malformed 220 message is a red flag — it stops the handshake before any email can be sent.
Misconfigured mail servers
Many 220 issues stem from a poorly configured SMTP daemon. If Postfix, Exim, or Sendmail isn’t set up to bind to the correct port or responds with a malformed banner, clients will reject the connection. You might see errors like "SMTP server not responding" or "Unexpected response" in logs. Double-check your server’s configuration file — especially settings for the SMTP port (usually 25, 587, or 465) and the RFC 5321 compliance of the greeting message. A quick way to test is using command-line tools like telnet or openssl s_client.
Firewalls and network interference
Firewalls often block or delay SMTP traffic, especially on non-standard ports. Some configurations drop the initial 220 response if the connection appears suspicious or if rate limits are triggered. You can check if this is the case by testing from outside your network or using a tool like MxToolbox to diagnose open ports. If a firewall is throttling the first exchange, you’ll see timeouts or connection resets before the 220 message even appears.
Greylisting and temporary rejections
Greylisting services delay or temporarily reject new connections from unfamiliar IPs to reduce spam. The initial SMTP handshake may not complete with a 220 if the server is still in a "pending" state. This isn’t a failure — it’s a deliberate delay. But some clients time out before the retry, giving the impression that the server is broken. You can verify if greylisting is involved by monitoring response times and retry patterns. Letting a send sequence retry after 10–30 minutes often resolves this.
Server overload or resource limits
When a server is under heavy load, it might not respond to new SMTP connections within the standard 30–60 second window. The result? A timeout or no response at all. This often appears as missing 220 messages even though the server is technically online. Watch for high CPU, memory, or connection queue usage. Tools like NetData can help diagnose capacity limits in real time.
If you’re verifying mail server readiness, a bulk check via bulk verification can reveal systemic issues across multiple domains. Use it to test whether the problem is isolated or widespread. Fixing the 220 response is the first step to reliable email delivery.
How Emaillistchecker.io tests SMTP server responses like 220
You can verify that a mail server sends the correct 220 message by simulating a real SMTP client connection, capturing the full handshake sequence, and checking that the 220 response includes the correct domain name, is properly formatted, and arrives within 10 seconds. If the server delays, fails to respond, or returns a malformed message, Emaillistchecker.io detects it and reports the exact error code.
Simulating Real Client Behavior
Our verification system doesn’t just look for a 220 reply—it emulates how a real email client connects to a server. This includes sending the initial HELO or EHLO command, then waiting for a response. The full handshake is recorded, so you see exactly what the server sent and when.
SMTP servers must respond to a connection with a 220 status code within a reasonable time—typically under 10 seconds. If a server takes longer, or never responds, it can fail to deliver emails or trigger timeouts. We track this timing precisely and flag delays that might affect deliverability.
What We Check in the 220 Response
The 220 message must include the server’s domain name and follow a standard format: 220 example.com ESMTP (or similar). If the domain is missing, mismatched, or the response is malformed, we flag it as invalid.
We also detect common failures like connection resets, invalid syntax in the response, or server timeouts. Each failure is returned with a specific error code—like SMTP_220_TIMEOUT or SMTP_220_INVALID_FMT—so you can quickly identify misconfigurations in your mail setup, such as incorrect DNS records or misrouted mail servers.
These checks are based on the RFC 5321 specification, which defines the SMTP protocol. You can review the official specification at RFC 5321 for context on server behavior during connection.
For teams managing email campaigns, verifying these responses early reduces delivery risk. Use our real-time API to test individual domains or integrate verification into your onboarding workflow. It’s not just about catching bad addresses—it’s about ensuring your mail server behaves properly from the first connection.
How to use the Emaillistchecker.io API to verify 220 behavior
You can verify that a mail server sends the correct 220 greeting response by sending a POST request to the Emaillistchecker.io API with the domain or mail server hostname and the smtp_test parameter. The API will establish an SMTP connection, capture the full handshake, and return the exact server response—including whether the 220 line appears correctly, along with a verdict and raw log. This helps confirm the server is behaving as expected during SMTP initiation.
Step-by-step verification process
- Send a POST request to the API endpoint: Use
https://api.emaillistchecker.io/v1/verifywith thesmtp_testparameter set totrue. This tells the system to perform a live SMTP handshake instead of just validating syntax. - Include the domain or hostname in the request payload: Pass the mail server’s hostname (e.g.,
mail.example.com) or the domain (e.g.,example.com) as thedomainfield. The API will resolve the MX records and connect to the actual server. - Wait for the API to establish an SMTP connection: The system will initiate a TCP connection, run the standard SMTP handshake, and capture every response from the server—including the initial 220 line. This includes timing, code, and message content.
- Review the response: The API returns a verdict (e.g.,
success,timeout,malformed, ordelayed), plus a raw log of the entire SMTP exchange. This lets you see exactly if the 220 line was sent promptly and correctly. - Inspect the 220 response: Look for the server’s first reply. A valid response should be
220 mail.example.com ESMTPor similar. Any deviation—like missing code, wrong message, or no response—indicates misconfiguration or a firewall blocking access.
Why this matters in real-world delivery
The 220 response is the first signal that a server is ready to receive mail. If it's missing, delayed, or malformed, mail clients may time out or reject the connection outright. According to RFC 5321 (the SMTP standard), the 220 reply is mandatory for servers to accept incoming connections. This test confirms that your server or third-party sending infrastructure meets that baseline.
Use this as part of regular monitoring—you can run this check via automation in your pipeline or during onboarding. If you're integrating with SendGrid, Mailchimp, or HubSpot, testing the 220 response ensures your outbound mail flows smoothly. For deeper delivery insights, combine this with inbox placement testing here.
What the 220 message reveals about sender reputation
When your mail server responds with a timely, consistent 220 greeting, it signals reliability — a stable, well-configured system that spam filters trust. A delayed, missing, or inconsistent response raises red flags, often triggering filters at Gmail, Microsoft, and Yahoo, which penalize infrastructure that can’t respond predictably. This is not just a technicality — it’s part of the foundation of sender reputation, influencing whether your messages land in inboxes or get blocked outright.
How timing and consistency build trust
Your mail server’s 220 response is the first handshake of a delivery attempt. If it takes more than 10 seconds, or if responses vary wildly, it suggests instability — like a server under load, misconfigured, or even compromised. Spam systems, especially those from major providers, treat these inconsistencies as signs of poor maintenance. For example, a 2022 report from Return Path (now Validity) found that emails from infrastructures with high connection latency had significantly lower inbox placement rates. A clean 220 response, sent within a second or two every time, shows you’re not just sending mail — you’re managing your delivery infrastructure with care.
Why poor responses lead to blacklisting
Spam filters don’t just look at content — they analyze behavior. If your server is slow to respond, or fails to respond at all during testing, it gets flagged as unreliable. Systems like Spamhaus and MXToolbox track such behavior across networks and may list entire IP ranges or domains if they consistently fail basic SMTP checks. Once blacklisted, even legitimate mail gets trapped in quarantine or rejected. A stable 220 response doesn’t guarantee inbox placement, but it removes a common technical barrier that stops your messages from even being considered. Without it, you’re fighting uphill from the first connection.
Let’s be clear: you don’t need to be an email security expert to understand this. But you do need tools that check it for you — not just the final deliverability result, but the underlying signals. That’s why testing your infrastructure’s SMTP behavior is essential, and why platforms that automate these checks are worth using when you're building a real email strategy. Tools like bulk email verification catch more than just invalid addresses — they surface technical misconfigurations that hurt sender reputation before you send.
Real-world verification: When does 220 checking prevent delivery failure?
Checking that your mail server sends a correct 220 greeting within a few seconds isn’t just a formality—it’s a frontline defense against delivery failure. When the server delays or fails to respond with a proper 220 code, sending clients time out, get blocked, or are flagged as unreliable. Fixing these issues has been shown to reduce bounce rates by up to 18% in real-world cases, especially in high-volume environments where every second counts.
When the delay hits: Server responsiveness matters
Let’s say your server takes 30 seconds to respond with a 220. That’s a red flag. Most MTAs (Mail Transfer Agents) have timeouts set between 10 and 20 seconds. If your server is sluggish, the connection drops before it even gets to the 220 phase. One SaaS provider found that after optimizing their mail gateway to reply within 5 seconds, outbound bounces dropped by 18%. You’re not just verifying syntax—you’re validating performance that impacts inbox placement.
The SMTP protocol standard (RFC 5321) requires that a server respond promptly to connection attempts. A delayed 220 isn’t just a minor delay—it’s a violation of baseline SMTP behavior, and modern spam filters treat sluggishness as a sign of poor infrastructure or hosting abuse.
When the problem isn’t the server, but the signal
It’s not always the server’s fault. An e-commerce company discovered that their mail server domain was improperly configured in DNS. The MX record pointed to a server that didn’t exist, while a backup domain (not properly synchronized) responded with a delayed or malformed 220. This made testing appear inconsistent—40% of attempts failed, not because of the server, but because of a redirection loop. Once they fixed the DNS alignment, 220 responses normalized across all test points.
Another case involved a cloud-hosted message queue that hit the rate limit set by a security group. Even though the server was technically ready, the cloud provider throttled incoming SMTP connections. This caused delayed 220 responses or outright connection drops. The fix? Adjusting the security group policy and enabling a retry mechanism at the sending layer. Monitoring 220 timing at scale reveals these hidden throttles before they impact deliverability.
These real-world cases show that a properly timed 220 isn’t just a test—it’s a measurable indicator of whether your mail infrastructure can keep up with modern expectations. You can catch these gaps early by simulating real delivery conditions. Testing your SMTP handshake behavior regularly can prevent delivery failures before they happen.
How to prevent 220 issues before they break your deliverability
220 responses are the first handshake between your mail server and the recipient’s system. If they’re inconsistent, delayed, or absent, inboxes will reject your messages—even if everything else is correct. Prevent issues by monitoring server health, validating setup with real-world tools, simulating client behavior, and testing actual delivery results. Let’s get you past the handshake.
Monitor the fundamentals
- Check your mail server’s uptime and response time during SMTP handshakes—delays beyond 2–3 seconds often correlate with 220 timeouts or network jitter.
- Include SMTP response time as part of your regular infrastructure health checks. Tools like MxToolbox can help spot recurring connection stalls.
- Set alerts for server downtime or unresponsive ports. A server that doesn’t answer 220 when queried is not sending mail reliably.
Test in the real world
- Before scaling your email volume, verify your server configuration with public SMTP test tools—like SMTP-test.com—to confirm it returns a correct 220 prompt on every connection.
- Don’t rely only on internal testing. Internal systems may be whitelisted or behave differently than real inbound email systems.
- Simulate real client behavior: connect from multiple IPs, test during high-load periods, and ensure your server consistently replies with valid 220 responses under stress.
Even if your server responds 220 correctly locally, delivery depends on how that response is interpreted by receiving mail systems. You can’t trust a flawless handshake if the rest of your setup fails later in the chain. That’s why actual inbox placement matters.
- Use inbox-placement tests to validate how your mail server’s 220 behavior translates across real inboxes—Gmail, Outlook, Apple Mail—with actual message delivery and sorting results.
- These tests reveal whether your server's 220 reply is seen as reliable. If messages land in spam or are silently dropped, even correct 220 responses aren’t enough.
- Troubleshoot based on real delivery outcomes, not just internal signal flags. A 220 response doesn’t guarantee inbox placement—only real-world testing does.
Why automated verification beats manual testing for 220 reliability
Manual testing with telnet only checks one server at a time, often missing broader issues like regional delays or temporary failures. Automated tools like Emaillistchecker.io run 50+ verification checks per minute across real global locations, catching inconsistencies no human can replicate at scale. You don’t need to guess if your 220 response is stable — the system detects patterns in timing, geographic variation, and degradation over time.
Manual checks fail at scale and consistency
Using telnet to verify the 220 greeting requires typing commands, waiting for responses, and interpreting results — each step introduces delay and human error. One person might test from a single location, while another uses a different network. The results aren’t reproducible, and subtle failures like delayed 220 responses or inconsistent MX routing go unnoticed. This approach is unreliable when your email infrastructure spans multiple ISPs or cloud zones.
Automation reveals the full picture
Automated systems simulate real sender behavior from 30+ different locations worldwide, measuring not just whether a 220 response occurs, but how quickly and consistently it appears. They detect transient network issues, differences in response time across regions, and long-term signal degradation — all indicators of underlying problems that might only trigger bounces under load. Unlike manual testing, they run continuously and log trends, so you catch issues before they hit deliverability.
Tools like Emaillistchecker.io integrate directly into CI/CD pipelines, so every deploy triggers a check on your mail server’s readiness. This means you catch configuration drift or DNS misconfigurations—like a faulty SPF or a broken MX record—before they affect your outbound email flow. You’re not reacting to bounces; you’re preventing them.
SMTP behavior is standardized in RFC 5321, but real-world implementations vary. Using automated verification ensures your server meets those standards not just in theory, but under actual operating conditions. For teams using tools like SendGrid, Mailchimp, or HubSpot, real-time validation via API helps maintain sender reputation. You can run this as a health check before every campaign, using the real-time verification API or schedule bulk checks with bulk verification to audit your entire list. A well-maintained 220 response reduces bounce rates, avoids spam traps, and keeps your messages in the inbox.
Final note: The 220 message is not just a technical detail—it’s a deliverability checkpoint.
The 220 greeting message is the first signal a mail server sends during connection setup. If it's malformed, delayed, or inconsistent, delivery fails before the message even begins.
Even small deviations—like missing whitespace, incorrect timing, or a non-standard hostname—can trigger rejection by major email providers. This isn’t theory; it’s how systems respond to known anomalies.
Verifying 220 consistency is a low-cost, high-impact step. It’s one of the first things a deliverability engineer checks when diagnosing send failures.
With Emaillistchecker.io, you can test this at scale, in real time, with 98.9% accuracy.
Keep reading
- Engineering guides: frameworks, pipelines and data imports (complete guide)
- How to Test if Mail Server Returns Correct 220 Code on Connection
- Automated IPv6 MX Record Validation for Email Server Finder Output
- Validate Mail Server 220 Response Before Sending Bulk Emails
- How to Fix 554 Error Mail Server Rejecting Non-ASCII in Envelope RCPT
Ready to put this into practice? Emaillistchecker.io verifies emails with 98.9% accuracy — start with 100 free verifications.
Frequently asked questions
What does a 220 SMTP message mean?
The 220 message is the server's initial response to an SMTP connection, indicating it is ready to receive email. It must be sent promptly and correctly.
Can a missing 220 response cause an email to fail?
Yes—without a valid 220 response, the client terminates the connection immediately, leading to delivery failure.
How fast should a 220 response appear?
It should be delivered within 10 seconds of connection initiation. Delays beyond this are considered failures by most email providers.
What’s the difference between a 220 and a 250 response?
The 220 message signals that the server is ready to start the SMTP handshake. The 250 response confirms a successful command, such as 'MAIL FROM'.
Do all mail servers use the same 220 format?
The core format is standardized, but the domain name and service description may vary. It must include the server's domain and a readiness message.
Can greylisting cause a 220 delay?
Yes—greylisting services may delay the 220 response or temporarily reject connections until an acceptable delay is honored.
How often should I test my mail server's 220 response?
Test during setup, after configuration changes, and regularly as part of infrastructure monitoring—ideally once a week.
Does Emaillistchecker.io test 220 responses in real time?
Yes—our API performs live SMTP tests in real time, simulating client connections from multiple global locations.
Is 220 verification included in email deliverability checks?
Yes—220 verification is a core part of inbox-placement testing and is included in deliverability health assessments.
Can a misconfigured domain cause a wrong 220 response?
Yes—incorrect DNS records or missing MX entries can cause the server to return a malformed or incorrect domain in the 220 message.
Does Emaillistchecker.io help fix 220 issues?
We identify the issue and return structured results. Fixing requires updating server configuration or DNS records based on our findings.
Do disposable email providers send a correct 220?
Many do—but some use non-standard responses or delayed handshakes, which can be flagged during automated testing.