How to Verify If an Email Is Valid
(5 Methods Tested in 2026)

Key takeaways

TL;DR

5 ways to verify if an email is valid

Each method below answers part of the question "is this email valid?" The first three are free and can be done from a terminal in a few seconds. The last two wrap all four validation checks into a single result and are what most B2B teams use in production. Pick by volume, accuracy needed, and how comfortable you are running scripts.

The first check is always format. RFC 5321 (the SMTP standard) and RFC 5322 (the message format standard) define what an email address is allowed to look like. A local part of up to 64 characters, an at sign, a domain of up to 255 characters, and a TLD. Anything that breaks these rules is invalid before you even hit DNS.

A simple regex catches roughly 60 to 70 percent of obviously bad addresses: typos, missing TLDs, extra at signs, and disallowed characters. It runs in microseconds and needs no network access, which is why it is the standard front-end check on signup forms.

# Python: RFC 5322 simplified regex check
import re

EMAIL_RE = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"

def is_syntactically_valid(email):
    return re.match(EMAIL_RE, email) is not None

is_syntactically_valid("sarah.chen@stripe.com")   # True
is_syntactically_valid("sarah@@stripe.com")        # False
is_syntactically_valid("sarah.chen@stripe")         # False (no TLD)
is_syntactically_valid("not-an-email")              # False

The next check is whether the domain in the email address can receive mail at all. You query DNS for an MX (Mail eXchange) record. If a domain has no MX record (and no A record fallback), it is not configured to accept email and the address is invalid no matter what the syntax looks like.

This filter alone removes parked domains, expired domains, typo domains (gmial.com), and disposable services that have been shut down. It is the second cheapest check after regex and a clean way to get accuracy from 70 percent up to roughly 85 percent.

# Bash: quick MX lookup with dig
$ dig +short MX stripe.com
10 mxa-00185c01.gslb.pphosted.com.
10 mxb-00185c01.gslb.pphosted.com.

$ dig +short MX asdfqwer1234.com
# (no output = no MX record = domain cannot receive mail)

# Python: programmatic MX lookup with dnspython
import dns.resolver

def has_mx_record(domain):
    try:
        records = dns.resolver.resolve(domain, "MX")
        return len(records) > 0
    except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
        return False

has_mx_record("stripe.com")        # True
has_mx_record("asdfqwer1234.com")   # False

The deepest free check is the SMTP handshake. You connect to the receiving mail server, identify yourself with HELO, set a sender with MAIL FROM, and ask if the recipient mailbox exists with RCPT TO. The server replies with a status code. 250 means the mailbox accepts mail. 550 means it does not. You then disconnect with QUIT before any actual message is sent.

This is what every paid verification tool runs under the hood. Done correctly, it pushes accuracy from 85 percent up to roughly 95 percent on B2B addresses. Done badly, it lands your sending IP on a blacklist.

# Python: SMTP handshake (simplified, single email)
import smtplib, dns.resolver

def smtp_verify(email):
    domain = email.split("@")[1]
    mx = str(dns.resolver.resolve(domain, "MX")[0].exchange)
    server = smtplib.SMTP(timeout=10)
    server.connect(mx)
    server.helo("verify.example.com")
    server.mail("check@example.com")
    code, _ = server.rcpt(email)
    server.quit()
    return code == 250  # 250 = mailbox accepted

smtp_verify("sarah.chen@stripe.com")   # True (likely)
smtp_verify("ghost.user@stripe.com")   # False (550 reply)

If you do not want to write code, the simplest way to verify if an email is valid is to paste it into a free real-time verifier. A good one runs all four checks (syntax, MX, SMTP, risk) and returns a verdict in under three seconds.

The free Mailsfinder email verifier gives you 100 verifications per day with no card on file. It uses the same dual-layer SMTP engine as the paid plans, so per-email accuracy is identical at 99 percent. For a fuller comparison of free options, see our roundup of the best free email verifier tools. Other free tiers worth knowing about: Reoon (600 per month), ZeroBounce (100 per month), Kickbox (100 on signup), and Emailable (250 on signup).

For anything above a few hundred addresses, a real-time verifier is too slow to use one-by-one. You want bulk. The Mailsfinder bulk email verifier accepts up to 50,000 emails per job, runs every check in parallel, and returns a clean CSV plus a per-email status flag ready for import into Instantly, Plusvibe, Smartlead, HubSpot, or Salesforce.

For production pipelines (signup forms, CRM updates, lead enrichment workflows), the same engine is available as a REST API. Pricing on the Growth plan is $0.001 per email, which is roughly six times cheaper than the average of ZeroBounce, NeverBounce, Kickbox, Emailable, and EmailListVerify.

# Verify a single email via the Mailsfinder REST API
curl -X POST https://api.mailsfinder.com/v1/verify \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "sarah.chen@stripe.com"}'

# Sample response
{
  "email": "sarah.chen@stripe.com",
  "status": "valid",
  "score": 98,
  "checks": {
    "syntax": "pass",
    "mx_record": "pass",
    "smtp": "pass",
    "catch_all": "false",
    "disposable": "false",
    "role_based": "false",
    "spam_trap": "false"
  }
}

For full deliverability scoring (not just per-email verification), pair the bulk verifier with the Mailsfinder deliverability checker. It tests SPF, DKIM, DMARC, blacklist status, and inbox placement across Gmail, Outlook, and Yahoo seed addresses so you know your sending infra is healthy before the first send.

What "valid" actually means

The word "valid" gets thrown around to mean four different things. Mixing them up is why teams think they have a clean list when they actually have a list that bounces. Here are the four definitions you should keep separate.

A useful rule of thumb. When somebody says "this email is valid," ask which of the four they mean. For cold outreach, only definition three counts. For a signup form, definitions one and two are usually enough.

Signals that an email is invalid

When you run any verifier, the result is almost never a clean yes or no. It is a status plus a list of flags. Knowing which flag means "do not send" saves you from learning the hard way at the cost of your sender reputation.

How email verification protects sender reputation

Verification is not just hygiene. It is the single biggest lever you have on whether your campaigns land in the inbox or in spam. Gmail and Yahoo introduced explicit sender thresholds in February 2024. Hit them and you get throttled. Cross them by much and you get blocked.

A clean verified list is the only reliable way to stay under those thresholds at scale. Every invalid address you remove before sending is one bounce that never hits your reputation, one complaint that never gets filed, and one spam-trap hit you avoid entirely.

When to verify (and when to re-verify)

Verification is not a one-time event. B2B contact data decays. People change jobs, companies sunset domains, mailboxes get retired. The cleanest rule of thumb: verify any list older than 90 days before any new send.

Related reading

Verification is one piece of the cold outreach stack. Here is what to read next.