How to Test an SMTP Server Connection and Handshake

Emails aren’t sending, or you’re setting up a new mail server configuration and want to confirm it’s actually reachable and responding correctly before wiring an application to depend on it. Testing an SMTP connection means more than just confirming the server responds at all — you want to see the actual handshake: the server’s greeting, its advertised capabilities, and whether STARTTLS (the mechanism for upgrading to an encrypted connection) is offered and working correctly.

A raw SMTP conversation is plain text, readable in principle, but genuinely tedious to interpret from raw command-line output if you’re not already deeply familiar with the protocol’s specific response codes and expected sequence of exchanges.

What an SMTP handshake actually reveals

When a client connects to an SMTP server, the server responds first with a greeting that identifies itself and confirms it’s ready to accept a connection. The client then typically sends an EHLO command, to which the server responds with its advertised capabilities — which extensions and features it supports, including whether STARTTLS is available for upgrading the connection to encrypted communication. Checking whether STARTTLS is actually offered and functions correctly matters specifically for security, since sending email credentials or content over an unencrypted connection is a real exposure risk if the server doesn’t properly support or enforce the upgrade to TLS.

Seeing this full sequence — not just “did the server respond” — is what actually confirms the server is configured correctly and ready for real use, rather than just technically reachable.

Why people get stuck here

• Emails failing to send with no clear indication of why. Without inspecting the actual SMTP handshake, it’s hard to know whether the failure is a connectivity issue, a configuration problem, or something else entirely.
• Not knowing whether STARTTLS is actually working. A server might claim to support encrypted connections, but confirming that the upgrade actually succeeds requires inspecting the real handshake, not just assuming based on configuration documentation.
• Raw command-line SMTP output being genuinely hard to parse. The actual text exchange during an SMTP session uses protocol-specific response codes and formatting that isn’t immediately readable without protocol familiarity.
• Testing a new server configuration before wiring an application to depend on it. Confirming a mail server actually works correctly, end to end, before pointing production email sending at it avoids discovering a configuration issue only once real emails start failing.

What a good SMTP test tool looks like

Shows the full handshake sequence

Displaying the server greeting, capabilities, and STARTTLS negotiation together gives a complete picture of the connection, not just a pass or fail result.

Presents the exchange in a readable format

Translating the raw protocol exchange into a clean, readable log makes it accessible without requiring deep SMTP protocol expertise to interpret.

Actually tests the live connection

Running a genuine connection test against the real server, rather than just validating configuration syntax, confirms the server is actually reachable and responding as expected right now.

Common mistakes to avoid

• Assuming email sending failures are always application-level issues without checking whether the underlying SMTP connection and handshake are actually working correctly.
• Trusting that STARTTLS is properly supported based on documentation alone, without actually testing the live handshake to confirm it works.
• Deploying a new mail server configuration to production without first testing the connection and handshake in isolation.
• Not reviewing the full capability list the server advertises, missing a relevant feature or limitation that affects how your application should actually connect.
• Confusing a successful basic connection with a fully working configuration — reaching the server is necessary but not sufficient to confirm everything (including encryption) is set up correctly.

How to do it with Online SMTP Test

Online Tool Store’s Online SMTP Test runs the connection test and shows the handshake clearly.

1. Open the Online SMTP Test tool.
2. Enter the SMTP server details you want to test.
3. Run the connection test.
4. Review the handshake log — greeting, capabilities, and STARTTLS — in a clean, readable view.

It’s a fast way to confirm a mail server is actually configured correctly before depending on it for real email sending.

Frequently asked questions

Why does confirming STARTTLS support actually matter?

Because sending email credentials or message content over an unencrypted connection is a real security exposure — confirming the server both advertises and correctly completes the STARTTLS upgrade during the actual handshake is what verifies encrypted communication is genuinely working, not just configured in documentation.

What does the server’s greeting message actually tell me?

The initial greeting confirms the server is reachable and ready to accept a connection, and it typically identifies the server software or hostname — useful for confirming you’re actually connecting to the intended server, especially when troubleshooting a configuration that might be pointing somewhere unexpected.

Can this help troubleshoot why my application’s emails aren’t sending?

Yes — testing the underlying SMTP connection and handshake independently of your application helps isolate whether an email sending failure is actually a server connectivity or configuration issue, versus something in your application’s own email-sending logic.

Final thought

An SMTP connection test that only confirms “the server responded” misses the details that actually matter — the full handshake, including whether encryption is genuinely working, is what confirms a mail server is truly ready for real use.

Try the free Online SMTP Test tool