Enter a domain
Drop in any domain whose mail server you want to test. No login, no account, nothing to install. A single domain is all the SMTP test needs to run the full live handshake.
SMTP server test
Enter any domain and Verifox runs the live SMTP handshake a receiving server runs: the 220 banner, the EHLO capabilities, STARTTLS support, and the mail host's reverse DNS. No signup.
No login, no install. Enter any domain and Verifox resolves the mail server that answers SMTP for it, runs the live handshake, then shows whether mail has somewhere to land and which provider runs it.
Drop in any domain whose mail server you want to test. No login, no account, nothing to install. A single domain is all the SMTP test needs to run the full live handshake.
Verifox resolves the domain's mail servers live, connects to the top-priority host on port 25, and opens the same SMTP handshake a real sending server runs before it delivers any message.
See which mail server answers for the domain: the 220 banner, the EHLO capabilities, STARTTLS support, and the host's reverse DNS, plus the plain-English name of the provider running the mail.
One question, answered live: if I send mail to this domain, is there a server ready to take it?
An SMTP test answers one question: is there a live server ready to accept mail for this domain? The test resolves the domain to its mail server, opens an SMTP connection, and reads the handshake. A healthy server accepts the connection and signals it will receive mail; one that refuses or times out means mail bound for it bounces.
The same nine-check engine our paid email verification API runs. Every email, every verification, every time.
Every address runs a full RFC 5321 and RFC 5322 compliance pass before a single network call goes out. The engine catches what visual scanning misses, the double dot in alice@verifox..ai, the trailing period, the IDN homograph that looks valid but resolves to a different domain.
Bundled typo suggestions let your form offer “did you mean alice@gmail.com?” instead of rejecting silently.


Once syntax passes, the engine resolves the domain. We confirm the DNS records exist, fetch the MX record priority list in order, and verify at least one mail-exchange server is actively accepting connections right now.
Misspelled domains like gmial.com, expired domains, and parked-for-sale domains all fail this gate before the engine wastes a single SMTP roundtrip.


The engine opens a TCP connection on port 25, performs the EHLO handshake, then negotiates MAIL FROM and RCPT TO. Every server response code (220, 250, 550, 552) is parsed deterministically against the IANA enhanced-status registry.
This is the moment a mailbox proves it actually exists. No third-party guesses, no statistical heuristics, just the receiving server's own answer.


Some domains accept every email regardless of whether the mailbox exists, a setup known as a catch-all configuration. The engine sends a deterministic probe to a deliberately fake address (zzz9k7q@domain.com); if the server returns the same 250 OK it returned for the real address, the domain is catch-all.
The verdict isn't dropped, it's flagged RISKY so you know the deliverability signal is degraded.


The engine maintains a curated registry of 10,247 disposable email providers, including Mailinator, Guerrilla Mail, 10MinuteMail, Tempmail, and the long tail of regional clones.
Any address matching the blocklist is flagged INVALID. Deliverability to a mailbox that exists for 10 minutes and is never checked is functionally zero, regardless of whether the SMTP handshake passes.


info@, support@, no-reply@, admin@, billing@. These are shared inboxes, not individuals.
The engine extracts the local-part of every address, matches it against the known role-prefix registry, and tags the result with a reduced engagement score.
You don't drop them automatically. The verdict flags them as roles so you can decide.


Fresh-spam domains registered hours ago are the single biggest source of inbound abuse. The engine queries WHOIS and RDAP for every unique domain, extracts the registration date, and flags anything under 30 days old with a “fresh” warning.
Domains aged 5+ years pick up a corresponding trust signal. The same heuristic spam filters have been using since the early 2000s, ported into the verdict.


SPF, DKIM, and DMARC together prove the sender is authorised to send from that domain.
The engine reads each policy via DNS, validates SPF includes recursively, scans six common DKIM selectors, and confirms DMARC alignment with the From: header.
A failing DMARC policy means the sender can be spoofed, so the verdict warns you before you reply.


Beyond “exists vs doesn't exist”, the engine extracts the precise mailbox state from the SMTP server's response. Full inbox (552 / 522 quota), disabled mailbox (550 5.1.1), out-of-office autoresponder, frozen account.
Each state maps to a specific retry policy. Full inbox retries in 6 hours. Disabled drops permanently. The verdict tells you which bucket the bounce belongs in so your retry logic doesn't waste cycles.


An SMTP test is a read-only handshake with a domain's live mail server. In one probe you learn who runs the mail, how it routes, and whether messages have somewhere to land.
The same handshake the Verifox verification engine opens on every address it checks.
The probed MX host names the provider — Google Workspace, Microsoft 365, Proofpoint, or a self-hosted server.
The probe connects to the top-priority host, the same server real mail reaches first, with fallbacks in order.
No MX record, or a server that never answers, means mail bounces before it is ever sent.
The handshake starts the story; verifying the address confirms the mailbox itself is real.
An SMTP test is only the first step. Verifying the address confirms the mailbox is real and deliverable.
The single most useful thing an SMTP test tells you — who to talk to about the domain's mail.
MXToolbox, GMass, and Mailtrap check server responses; Verifox also identifies providers plainly and verifies real mailboxes.
Verifox ONE adds 15,000 credits to your account every month, and the ones you don't use roll over instead of resetting. Rather pay once? Credit packs never expire.
forever
1,000credits on signup
No card required
2,500 with a work email
Free includes
per month
15,000credits a month
$0.0053 each, $0.0044 billed yearly
Up to 25% less per credit than the 10,000 pack
Everything in Free, plus
one time
10,000credits
$0.0059 eachSAVE 34%
Everything in Free, plus
One credit verifies one address; a find costs 10, a company search 100 and an email reveal 50. All prices in USD, secure checkout via Dodo Payments.
Prices are before tax. Any VAT, GST or sales tax your country charges is added at checkout. Buying as a business? Enter your VAT or GST number there.
The addresses you submit are used only to run your verification. They are never sold, and nobody on your list hears from us.

The addresses you submit are never sold or shared.

We ask the mail server. Not one message is sent.

Full GDPR data-subject rights for everyone in the EU and UK.

California opt-out, do not sell and DSAR handling.
An investigation into the money leaking out of your list - and the nine checks that decide whether your email is read, or never arrives at all.

57 pages, free PDF, no signup
Common questions
FAQs about SMTP testing: what the handshake proves, which ports matter, what error codes mean & where SMTP fits alongside email verification.
An SMTP test checks whether a domain’s mail server is reachable and willing to receive email. It resolves the domain to the server that handles its mail, opens an SMTP connection, and reads how the server replies to the opening handshake. Type a domain into the tool above and Verifox runs a live lookup of its mail servers, names the host that receives the domain’s email, and shows whether mail has somewhere to land.
It is the fastest way to answer one question that bounces and silent drops hinge on: if I send mail to this domain, is there a live server on the other end ready to accept it? That is the exact SMTP step our verification engine runs after it resolves the MX records.
When one mail server delivers to another, they hold a short conversation in the Simple Mail Transfer Protocol. The sender connects, the receiver answers with a 220 greeting, the sender says EHLO, and they negotiate encryption and the envelope (MAIL FROM and RCPT TO) before any message body is sent.
An SMTP test exercises the front of that exchange. A healthy server answers the connection and greeting promptly; one that times out, refuses, or returns an error never gets to accept your mail. That handshake is also where mailbox-level verification begins, which is why the test doubles as a deliverability check.
The simplest way is to paste the domain into the SMTP test above and read the result. No account, no install. Verifox runs a live lookup of the mail server behind the domain and shows the host that would answer the SMTP connection.
You can also test from a terminal with openssl s_client -connect mail.example.com:25 -starttls smtp or an old-school telnet mail.example.com 25, but those make you read raw protocol replies yourself. The Verifox test names the mail provider in plain English and flows straight into a real mailbox verification when you need to go past the handshake.
Three things. First, whether mail is accepted at all, a live server that answers the handshake can receive email; a dead one means every message bounces. Second, which server and provider handle the mail, whether the domain runs on Google Workspace, Microsoft 365, or a self-hosted server; the mail domain lookup goes deeper on ownership. Third, a baseline deliverability signal: the response time, STARTTLS support, and whether the mail host's reverse DNS (PTR) resolves, the hygiene receivers check before trusting a server.
What it cannot prove by itself is that one specific address exists, because many servers accept every recipient at the handshake and reject unknown mailboxes only later. To confirm a single address is reachable, the mailbox itself has to be checked, the step the test alone cannot finish.
Server-to-server mail delivery uses port 25, which is the port an SMTP test for inbound mail cares about, it is where another mail server connects to hand off a message. Submission from a mail client uses port 587 (with STARTTLS) or the older port 465 (implicit TLS).
The test above cares about the delivery path, the same path real mail takes to the domain’s receiving server. If you are configuring a mail client and need the submission host and port, the mail client server settings lookup pulls the documented IMAP, POP, and SMTP settings, and the MX lookup identifies the provider behind the domain.
A failed SMTP test usually means one of a few things: the domain publishes no mail server (no MX record), so nothing is listening; the server is down or refusing connections; a firewall is blocking port 25; or the domain does not resolve (a typo, expired registration, or DNS misconfiguration). In every case, mail to that domain bounces or stalls.
If you are chasing bounces, an SMTP test is the first place to look. Then a mail exchanger lookup confirms the routing, checking SPF, DKIM, and DMARC covers the authentication side that decides inbox versus spam, and a full email deliverability test rolls every signal into one report.
Yes. The single test above is free with no account. For a list of domains, verify one address at each domain through the REST API: every response carries the mail server and the SMTP result, so you can run a bulk SMTP test across a whole list programmatically and feed the results into your CRM or onboarding flow.
Each verification costs one pay-as-you-go credit, from the same balance as the rest of the platform, and those credits never expire.
No, and the difference matters. An SMTP test on the server checks the domain’s mail server, is it alive and accepting connections. Verifying an email checks the specific mailbox, does jane@example.com actually exist and accept mail.
A domain can have a perfectly healthy SMTP server while a given address on it is dead, and some servers accept every recipient at the handshake and bounce unknown ones only afterward. That is why an SMTP test is step one of deliverability and the free email checker is step two. Verifox runs both on the same engine.
The domain you enter is used only to run the test and show you the result, and we never sell it. A mail server’s response is public, queryable data, but your tests are still yours.
Verifox is GDPR ready, and our security overview covers the controls. The full breakdown of what we touch and what we do not is in the privacy policy.
Yes. The REST API reference documents an endpoint that resolves a domain’s mail server and returns its SMTP response, so you can wire mail-server checks into your CRM, your signup flow, or any tool that speaks REST.
Verifox also ships native MCP server support, so AI agents (Claude, Cursor, custom LLM apps) can test a domain’s SMTP server and verify addresses without glue code. Live uptime and incident history are at status.verifox.ai.