Guide

How Email Verification Works: Syntax, DNS, MX and SMTP Checks Explained

By Unlimited Verifier Team ·

Flow diagram showing how email verification works, from syntax and MX checks to an SMTP RCPT TO probe that sorts addresses into Valid, Risky or Invalid.

Summary

Email verification checks each address through layered tests (RFC 5322 syntax, DNS and MX lookups, and a live SMTP RCPT TO probe) without ever sending a message. Risk flags like catch-all, disposable and role-based detection then sort addresses into Valid, Risky or Invalid, so you can send, segment or suppress and protect your sender reputation.

Email verification works by running each address through a layered set of checks (syntax rules from RFC 5322, DNS and MX record lookups, and a live SMTP handshake that asks the receiving server whether the mailbox exists) without ever sending a message. A good verifier then adds risk signals such as catch-all, disposable and role-based detection, and sorts every address into a clear verdict like Valid, Risky or Invalid.

That one-sentence answer hides most of the interesting engineering. The hard parts are what verification can and cannot prove, why some domains refuse to give a straight answer, and how to turn results into sending decisions that protect your sender reputation.

This guide covers the full pipeline. It explains each check, what every result code means, where verification breaks down, and how to clean a real list step by step. Each section links to a deeper article if you want to go further on one piece.

Quick answer

What is email verification, and why does it matter?

Email verification is the process of checking whether an email address is correctly formatted, belongs to a domain that accepts mail, and points to a mailbox that exists, all before you send to it. If you want the plain-English primer on what is email verification, our introductory explainer on email verification covers the basics. This guide focuses on the mechanics.

It matters because mailbox providers judge you by how you treat their users. Every send to a dead address produces a hard bounce, and a high bounce rate is one of the clearest signals that a sender isn't maintaining its list.

Since February 2024, Google's email sender guidelines require bulk senders to Gmail to:

Yahoo's sender hub publishes comparable requirements. Neither provider publishes a hard bounce ceiling.

Practitioners differ on what bounce rate is acceptable: figures from under 1% to 2% are commonly cited. Our recommendation: treat 2% as a hard ceiling and aim for under 1%.

How verification connects to deliverability

Verification is the cheapest lever in email deliverability because it removes problems before they happen. Authentication proves who you are. Content and engagement determine whether people want your mail. Verification ensures you aren't knocking on doors that don't exist, which is a behavior spammers are known for.

How verification connects to ROI

Every invalid address costs money twice:

  1. You pay your ESP to send to it, since most ESPs price by contacts or volume.
  2. The bounce erodes the reputation that gets your valid emails into the inbox.

Our breakdown of email marketing ROI shows how list quality compounds into revenue per send. A list that is 10% dead means 10% of your sending budget buys nothing except reputational damage.

Bottom line: Verification is preventive maintenance for your sender reputation. It is cheaper than recovering from a blocklisting or a throttled domain.

How does email verification work, step by step?

A verifier runs a funnel of increasingly expensive checks and stops as soon as an address fails. Cheap checks (syntax) run first, network checks (DNS, SMTP) run later, and the results are combined into one verdict.

If you're new to this, our beginner walkthrough of the verification steps explains each stage with zero jargon. Here is the practitioner version.

Step 1: Syntax validation (is it a well-formed address?)

The first check confirms the address follows the rules of email formatting: one @, a valid local part (before the @), and a valid domain (after it). Our deep dive on syntax validation for email addresses covers the edge cases. In practice, this step catches:

There is a nuance most guides skip. The official grammar in RFC 5322 is more permissive than what real mailbox providers accept. For example, RFC 5322 allows quoted local parts like "john smith"@example.com and comments in parentheses. Almost no consumer provider issues such addresses, and many sending systems choke on them.

Production verifiers therefore apply a stricter "practical" syntax that is valid per the RFC and deliverable in the real world. Our article on RFC 5322 email syntax explains where the standard and reality diverge.

Bottom line: Syntax checks are instant and free. They catch obvious garbage but can't tell you anything about whether a mailbox exists.

Step 2: Domain and DNS checks (can this domain receive mail?)

Next, the verifier queries DNS to confirm the domain exists and is configured to receive email. A domain that doesn't resolve at all (NXDOMAIN) is an immediate Invalid.

MX record lookup

The core of this step is the MX (Mail Exchanger) record lookup, which returns the hostnames of the servers that accept mail for the domain, ranked by priority. Our explainer on MX record lookups in email verification shows real query output. Two details matter:

Does the domain actually accept mail?

Having an MX record isn't the same as accepting mail. The verifier also checks that the MX host resolves and listens on port 25. Our guide to how verifiers check if a domain accepts mail covers parked domains, expired domains whose MX still points somewhere, and misconfigured records.

Can you stop at DNS?

People often ask whether DNS alone is enough. It isn't. DNS proves a domain can receive mail. It says nothing about whether jane@ exists on that domain. Our analysis of whether you can verify an address with only DNS shows what a DNS-only check catches (dead domains, typo domains like gmial.com) and the much larger class of bad addresses it misses.

Bottom line: DNS checks eliminate dead and misconfigured domains cheaply. Mailbox-level truth requires talking to the mail server.

Step 3: The SMTP handshake (does the mailbox exist?)

The verifier connects to the domain's highest-priority MX server and begins a normal SMTP conversation. It asks whether the server would accept mail for the address, then hangs up before sending anything. This is the step that separates real verification from guesswork.

Here is a simplified transcript (S = server, C = verifier):

S: 220 mx.example.com ESMTP ready
C: EHLO verify.yourdomain.com
S: 250-mx.example.com Hello
C: MAIL FROM:<probe@yourdomain.com>
S: 250 2.1.0 OK
C: RCPT TO:<jane.doe@example.com>
S: 250 2.1.5 OK                 ← server will accept this recipient
C: RCPT TO:<qz8x1v7k3m@example.com>
S: 550 5.1.1 User unknown       ← random address rejected → not catch-all
C: QUIT
S: 221 2.0.0 Bye

Our walkthrough of what happens during an SMTP handshake check annotates every line, including TLS negotiation and the timeouts that make some servers slow.

Why RCPT TO is the moment of truth

The decisive line is RCPT TO, the command where the client names the recipient. The server's reply code is the verdict:

Gmail, for example, typically answers a nonexistent address with a 550 5.1.1 response stating the account does not exist. That is a clean, reliable signal. Our explainer on what RCPT TO means in email verification catalogs the codes you'll actually see.

Putting the existence check together

The verifier combines DNS, connection, and RCPT TO results into an existence verdict. It also needs to recognize the many ways servers dodge the question. Our guide to how a verifier checks if an address exists covers the full decision tree.

Bottom line: The SMTP RCPT TO reply is the closest thing to ground truth a verifier can get without sending mail. It is only trustworthy when the server answers honestly.

Step 4: Catch-all detection (is the server telling the truth?)

A catch-all (or accept-all) server returns 250 for every recipient, real or not, so a 250 reply proves nothing on that domain. Verifiers detect this by probing an address that cannot possibly exist (like the random qz8x1v7k3m@ above). If the server accepts that too, the domain is flagged catch-all.

Our article on how verifiers detect catch-all domains explains the probe design, including why the random string has to be long and unguessable.

Why domains are catch-all

Catch-all configurations are common on business domains. Organizations don't want to lose mail sent to misspelled employee names, and some security gateways accept everything at the edge and filter later.

That's why deleting every catch-all result is a costly mistake in B2B (see Common mistakes below). "Accept-all" and "catch-all" describe the same behavior. Our note on what accept-all means in an email verifier explains how different tools label it.

Bottom line: Catch-all detection doesn't validate the address. It tells you SMTP can't validate it, which is exactly why those results belong in a separate Risky bucket.

Step 5: Risk flags (disposable and role-based addresses)

Even an address that exists may be one you don't want. Verifiers attach risk flags for two common categories.

Disposable addresses come from throwaway inbox services (Mailinator-style domains, "10-minute" mail services). They're valid for minutes or hours, then abandoned. Detection combines:

Our guide to disposable email domain detection explains why list freshness matters: new disposable domains appear constantly.

Role-based addresses like info@, sales@, support@, admin@ and postmaster@ route to a function or group rather than a person. RFC 2142 even standardizes several of them. They often have multiple recipients, higher complaint rates, and nobody who personally opted in. Our article on role-based address detection covers when to keep them; for example, a B2B buyer who signed up as purchasing@ on purpose.

Bottom line: Risk flags turn "does it exist?" into "should I send to it?" That second question is what actually protects your reputation.

Step 6: Classification (turning signals into a verdict)

Finally, the verifier merges every signal into a status you can act on. Unlimited Verifier, for example, sorts every address into Valid, Risky or Invalid, while flagging catch-all, disposable and role-based addresses along the way. That keeps the decision simple without hiding the reason.

Bottom line: A good classification scheme is simple enough to act on and transparent enough to explain why each address landed where it did.

What checks does an email verifier run, at a glance?

Most verifiers run six to eight checks in sequence: syntax, domain existence, MX/null-MX, SMTP connection, RCPT TO mailbox probe, catch-all probe, and disposable/role-based lookups. Our full inventory of the checks an email verifier runs goes deeper. Here is the comparison that matters for decisions:

Check What it proves What it can't prove Speed Typical verdict on failure
Syntax Address is well-formed That the domain or mailbox exists Instant Invalid
Domain/DNS Domain exists That it accepts mail Milliseconds Invalid
MX / null MX Domain is set up to receive mail That the mailbox exists Milliseconds Invalid
SMTP connect Mail server is reachable Anything about the recipient Sub-second to seconds Risky (if temporary)
RCPT TO probe Server accepts this recipient Inbox placement, engagement Seconds; minutes if greylisted Invalid (5xx) or Risky (4xx)
Catch-all probe Whether a 250 is meaningful Whether this address is real Seconds Risky
Disposable lookup Domain is a throwaway service Intent of the person Instant Risky/Invalid by policy
Role-based lookup Address is functional, not personal Whether it opted in Instant Risky

Verification methods compared

Beyond the checks inside one verifier, there are several methods you can use to validate addresses. Here's how they stack up:

Method Proves mailbox exists? Handles catch-all? Risk to your reputation Best for
Regex/syntax only (e.g., a form validator) No No None Catching typos at input
DNS/MX only No No None Filtering dead domains cheaply
SMTP probe (bulk verifier) Yes, on honest servers Detects, can't resolve None to your sending domain Cleaning lists before sending
Double opt-in confirmation email Yes, plus proves ownership Yes Low (sent to fresh signups) New subscriber acquisition
Send-based / bounce-based testing Yes Yes Real; bounces count against you Resolving high-value catch-all segments

Bottom line: No single check is sufficient. Layering them, and knowing each one's blind spot, is what makes verification accurate.

What do email verification results actually mean?

Each verdict reflects a specific server behavior. Understanding that behavior lets you choose the right action instead of treating every non-Valid result the same. The typical mapping is below; exact labels vary by tool.

Server behavior Typical code Typical verdict Recommended action
Accepts real address, rejects random probe 250 / 550 Valid (deliverable) Send
Rejects the address 550 5.1.1 Invalid Suppress permanently
Accepts everything, including random probe 250 / 250 Risky (catch-all) Segment; deep-verify or send cautiously
Mailbox over quota 452 4.2.2 or 552 5.2.2 Risky Hold; re-verify in 2–4 weeks
Greylisting/rate-limit persists after retries 421 / 450 / 451 Risky (unknown) Re-verify later
No MX/A record, or null MX — Invalid Suppress
Disposable domain — Risky or Invalid Remove for most marketing
Role-based address 250 Risky Keep only if explicitly opted in

What "deliverable" really means

"Deliverable" or "Valid" means the receiving server agreed to accept mail for that exact address, and the domain isn't catch-all. It does not mean the message will reach the inbox rather than spam, and it doesn't mean anyone reads it. Our article on what "deliverable" means in email verification separates deliverability of the address from inbox placement of your message. Conflating the two is the root of many disappointing campaigns.

What a "mailbox full" result tells you

A full mailbox (usually 452 4.2.2 as a temporary error or 552 5.2.2 as a permanent one) means the account exists but can't take more mail. One full-mailbox result is often temporary. The same address returning "full" across months usually signals an abandoned account that is still technically live. Our guide to mailbox-full verification results shows how to tell the two apart.

Bottom line: Treat the verdict as a description of server behavior, then decide the action. Invalid gets suppressed; Risky gets a plan, not a deletion.

Does email verification send an email or leave a trace?

No email is sent: the verifier ends the SMTP session with QUIT before the DATA command, so no message body is ever transmitted and nothing arrives in the recipient's inbox. The receiving server may log the connection, though.

Is a message ever delivered?

The mailbox owner sees nothing: no message, no notification, no read receipt. Our explainer on whether verification sends an email to the address walks through exactly where in the conversation the verifier stops. It also covers the one exception: send-based methods, which do send real mail on purpose (covered below).

What the server records

Mail servers routinely log connections, including the connecting IP, the EHLO hostname, the MAIL FROM address and each RCPT TO attempt. An administrator reviewing logs could see that an address was queried.

Some security gateways also count repeated recipient queries as suspicious behavior. That is why reputable verifiers throttle probes per domain. Our article on whether verification leaves a trace on the mail server explains what gets logged and why it matters for privacy-conscious senders.

Bottom line: Verification is invisible to the person and visible only in server logs. It is non-intrusive by design, but not completely traceless.

Why is email verification slow for some domains, and why do servers block it?

Most addresses verify in a second or two. Some domains take minutes or never give a definitive answer, because of greylisting, rate limiting, tarpitting, or deliberate anti-verification policies.

Why some domains are slow

The main culprits:

A bulk job where 3% of addresses sit on greylisting domains will see its tail end take far longer than the first 97%. Our analysis of why verification is slow for some domains covers what a well-built verifier does about each cause.

How verifiers handle temporary errors

A 4xx reply means "not now," not "no." Good verifiers retry with backoff: they wait, retry, and wait longer if needed. Only after retries are exhausted do they return a Risky/unknown verdict. A verifier that marks every 4xx as Invalid will wrongly delete real customers. Our guide to how verifiers handle temporary SMTP errors explains retry strategy and which 4xx codes are worth retrying.

Why mail servers block verification probes

Server operators have good reasons to resist recipient probing. Spammers use the same RCPT TO technique for directory harvest attacks, guessing addresses at scale to build lists. Defensive responses include:

Our article on why mail servers block verification probes goes deeper. It also explains why do-it-yourself scripts usually fail: many cloud and residential networks block outbound port 25 entirely, and a fresh server IP with no reputation gets rejected or blocklisted fast.

If you want to see how a production engine handles this, Unlimited Verifier publishes its open-source verification engine on GitHub.

The Yahoo and AOL problem

Some large consumer providers don't give reliable mailbox-level answers to SMTP probes. Yahoo and AOL are the examples most often cited by verification vendors. Behavior varies over time, and verifiers commonly return more Risky/unknown results for these domains than for Gmail or Outlook. Our dedicated piece on verifying Yahoo and AOL addresses covers what results to expect and how to treat them, often by leaning on engagement data instead.

Bottom line: Slow and unknown results usually reflect server policy, not verifier failure. The right response is retry-then-segment, never delete-on-sight.

How do verifiers resolve catch-all addresses beyond SMTP?

Since SMTP can't distinguish real from fake addresses on a catch-all domain, verifiers resolve them with extra evidence. That evidence comes from deeper probing and scoring, from sending real mail and watching for confirmation, or from analyzing bounces. Each approach trades accuracy against cost and risk.

Send-based catch-all verification

This approach sends an actual message to the address and judges validity by what happens next: a delayed bounce, a successful delivery, or engagement. It works because many catch-all gateways accept at the SMTP stage but generate a bounce once internal routing finds no such user. Our explainer on send-based catch-all verification covers the mechanics. The catch is that someone's sending infrastructure absorbs the bounces, so this must be done carefully.

Bounce-based catch-all verification

Here, a sample or the full catch-all segment is mailed in small, throttled batches. Hard bounces are captured and suppressed, and the survivors are promoted to Valid. You'd use it, for example, for a 5,000-address B2B catch-all segment that represents real pipeline. Our guide to how bounce-based catch-all verification works shows how to size batches so bounces never spike above your threshold on any single send.

If your list is heavy on business domains, a dedicated catch-all email verification pass is usually worth it before you resort to sending. It's cheaper than burning reputation on bounces.

Bottom line: Resolve catch-alls by escalating: deep verification first, throttled send-based testing only for segments valuable enough to justify the risk.

What's the difference between deep and standard email verification?

In general, "standard" verification covers the core checks (syntax, domain, MX and mailbox-level screening) at high speed and volume. "Deep" verification applies more intensive mailbox-level probing to squeeze definitive answers out of harder cases. Vendors define the tiers differently, so check what each one includes.

On Unlimited Verifier the split looks like this:

That structure suggests a practical workflow: run standard verification on everything, then spend deep verifications where they change decisions, typically on the Risky bucket. Our comparison of deep vs. standard email verification lays out when each tier is the right tool.

Bottom line: Use standard verification for breadth and deep verification for the ambiguous slice. Paying for depth on obviously valid addresses is wasted spend.

Which email verification tools should you consider?

The right tool depends on volume, how often you verify, and whether you need native integrations or are comfortable with CSV/API workflows. For a full head-to-head, see our roundup of the best email verification tools and the deeper verification tool comparison.

Tool How results are categorized Pricing model Notable differentiator Watch for
Unlimited Verifier Valid / Risky / Invalid, with catch-all, disposable and role-based flags Flat plans; unlimited standard verification Open-source engine; free single-email and domain blacklist checkers No native ESP/CRM integrations (CSV round-trip or API); Pro files capped at 25,000 emails each
Kickbox Deliverable / Undeliverable / Risky / Unknown Pay-as-you-go credits Sendex quality score per address Sendex is a proprietary score, so its weighting isn't fully transparent
ZeroBounce Granular statuses including valid, invalid, catch-all, unknown, spamtrap, abuse and do_not_mail Credits Separates spamtrap and abuse statuses More statuses means more mapping work before re-import
NeverBounce Valid / Invalid / Disposable / Catchall / Unknown Credits Promotes a broad catalog of native integrations Per-address cost grows linearly with re-verification frequency

How we compared (and limitations)

This table is based on each vendor's public documentation and on the verification standards cited in this guide. We did not run hands-on benchmarks.

Vendor accuracy figures, including Unlimited Verifier's stated 99.5% for deep verification, are the vendors' own claims, and the methodologies aren't independently audited. Status labels and features change, so confirm current details on each vendor's site before buying.

Bottom line: Choose on result transparency and cost per re-verification, because you'll verify the same list many times over its life.

How much does email verification cost?

Most verifiers charge per address through credits, with the per-1,000 rate falling as volume rises. That makes frequent re-verification expensive. Flat-rate tools change the math. Our breakdown of email verification pricing explains the models, and the full pricing analysis compares them at different volumes.

Here's why the model matters more than the sticker price. Good list hygiene means verifying the same contacts repeatedly: at import, before campaigns, and quarterly. Under per-address pricing, each pass costs the same again. Under unlimited standard verification, repeat passes are free at the margin.

Unlimited Verifier's published plans:

On Pro, verifying 200,000 addresses in a month (eight files of 25,000) works out to about $0.15 per 1,000 ($29 ÷ 200). The effective rate keeps falling the more you re-verify, because standard verification isn't metered.

Bottom line: Price verification by your annual re-verification volume, not by one list. That's where per-credit and flat pricing diverge most.

How do you verify an email list? (Hands-on tutorial)

You export your list, upload it to a verifier, review the Valid/Risky/Invalid split, deep-verify the ambiguous addresses, and re-import with suppressions applied. Here's the exact process using Unlimited Verifier, which a beginner can follow in under an hour for most lists.

Step-by-step: clean a list with Unlimited Verifier

  1. Export your list. From your ESP or CRM, export contacts as CSV or Excel. Include a unique ID column so you can match results back on re-import. Unlimited Verifier has no native ESP/CRM integrations, so this CSV round-trip is the workflow.
  2. Prep the file.
    • Remove exact duplicates and trim stray spaces.
    • Confirm the file is under 10MB. A 25,000-row CSV with a few columns is typically a few megabytes, well within the limit.
    • Check row counts: up to 150 emails per list on Free, up to 25,000 per list on Pro. Split larger files.
  3. Create an account. Sign up for Unlimited Verifier. The Free plan is enough to test the workflow on a sample.
  4. Upload. Go to upload and verify a list. The tool detects the email column automatically, so you don't need to rename headers.
  5. Run standard verification. Every address gets checked for syntax, domain, MX and SMTP mailbox. Catch-all, disposable and role-based addresses are flagged.
  6. Review the split. Expect three buckets: Valid, Risky, Invalid. Look at why addresses are Risky (catch-all vs. role-based vs. disposable), because each needs a different action.
  7. Deep-verify the Risky bucket. Spend your monthly deep verifications (750 Free / 25,000 Pro) on the ambiguous addresses, especially catch-alls, to promote real ones to Valid.
  8. Export and re-import.
    • Download results as CSV, Excel or JSON.
    • In your ESP, add every Invalid address to a suppression list rather than just deleting it, so it can't be re-imported later.
    • Tag Risky addresses as a separate segment.
  9. Send in order of confidence. Mail the Valid segment first. Trickle Risky addresses in small, throttled batches while watching bounce rates, and stop if bounces climb toward 2%.
  10. Download promptly. Results are kept 24 hours on Free and 30 days on Pro.

For one-off checks, such as a suspicious signup or a sales lead, the free single-address email checker runs the same pipeline on a single address without uploading anything.

Worked example: an agency cleaning a 60,000-contact list

An agency inherits a client's 60,000-address list that hasn't been mailed in eight months. They use Unlimited Verifier Pro.

Step 1: Split to respect the per-list cap. 60,000 exceeds the 25,000-per-list limit, so they create three files:

Total: 60,000. Standard verification is unlimited, so all three cost nothing extra.

Step 2: Results (illustrative distribution).

Bucket Count Share
Valid 48,600 81%
Risky 6,600 11%
Invalid 4,800 8%
Total 60,000 100%

Step 3: Deep-verify Risky. The 6,600 Risky addresses fit comfortably inside the 25,000 monthly deep verifications, leaving 18,400 for the rest of the month. Suppose deep verification promotes 2,400 to Valid, confirms 1,200 Invalid, and leaves 3,000 genuinely unresolved catch-alls.

Step 4: The outcome.

Why it matters. Had the agency mailed the raw list, the 6,000 invalid addresses alone would have produced roughly a 10% hard bounce rate (6,000 ÷ 60,000). That is five times our recommended 2% ceiling, on a list with no recent sending history to cushion it. Mailbox providers notice that pattern quickly.

Cost. One month of Pro at $29 (or $25/month billed annually). An illustrative comparison: a credit-based tool charging, say, $5 per 1,000 would cost about $300 for the first pass (60 × $5), and the same again for every re-verification.

Small-scale example: the Free plan

A founder with a 3,000-contact newsletter list splits it into 20 files of 150. That uses 20 of the Free plan's 25 monthly lists, leaving 5 for new signups. They use some of the 750 deep verifications on catch-alls. Total cost: $0.

Bottom line: Split to the per-list cap, verify everything, spend deep verifications on Risky, and send in order of confidence. Then do the math on what the bounces would have cost.

How do you automate email verification with an API?

You call a verification API either at the point of capture (signup forms, checkout) to stop bad addresses entering your database, or on a schedule to re-verify batches. Both approaches replace manual uploads. Our guide to email verification API and automation covers the architecture patterns, and the API automation deep dive includes implementation details.

Unlimited Verifier's REST API uses API keys and supports:

Worked arithmetic: a nightly job re-verifying 10,000 contacts per request could run 10 batch requests a month before hitting the 100,000 cap. Alternatively, a SaaS product with about 2,000 signups a day uses about 60,000 single checks a month (2,000 × 30), leaving 40,000 for periodic batches. You can generate credentials on the email verification API keys page.

A design tip most teams learn the hard way

Real-time checks occasionally take several seconds, because of greylisting and slow MX hosts. Don't make your signup form wait indefinitely or reject on "unknown."

Instead, set a short timeout:

Verification for ecommerce and SaaS

Email verification for ecommerce and SaaS has distinct stakes. Common problems include:

Our guide for online stores and SaaS teams covers where to place checks in the funnel. As a rule, verify at checkout and signup, flag disposables on trial forms, and batch re-verify dormant accounts before win-back campaigns.

Bottom line: Verify at the point of capture so bad data never lands. Batch-verify on a schedule so good data doesn't quietly decay.

How often should you verify, and is it required for compliance?

Verify at every point of entry, before any campaign to contacts not mailed in 90+ days, and roughly quarterly for active lists. No major email law mandates verification, but it supports the data-accuracy obligations some laws impose. Our guide to email verification compliance and hygiene covers the regulatory side, and the list hygiene playbook sets out schedules.

Why lists decay

People change jobs, abandon inboxes, and let domains expire. Industry estimates of annual list decay vary widely, and figures in the range of a fifth to a quarter or more are commonly quoted. Treat any single number as a rule of thumb.

B2B lists decay faster than consumer lists, because job changes kill corporate addresses. That's why we recommend quarterly re-verification as the default, and monthly for high-volume B2B senders.

What the law actually says

The compliance trap

Verification is not consent. Verifying a purchased or scraped list confirms addresses exist. It doesn't make mailing them lawful, and it doesn't make it safe either. Spam traps are real, functioning mailboxes, so an SMTP check will report many of them as "valid." M3AAWG, the industry's anti-abuse working group, consistently emphasizes permission-based acquisition for this reason.

Bottom line: Verify on a schedule, suppress rather than delete, and never treat a clean verification report as a substitute for consent.

What are the most common email verification mistakes?

The costliest mistakes come from misreading what verification proves: treating Valid as "safe," treating Risky as "bad," or verifying once and assuming the list stays clean.

  1. Deleting every catch-all address. On B2B lists, catch-all domains can make up a large share of your real buyers. Deleting them throws away pipeline. Segment them and deep-verify instead.
  2. Assuming "Valid" means "safe to blast." Valid means the mailbox exists. It says nothing about spam traps, chronic complainers, or people who never opted in. Pair verification with engagement-based sunsetting.
  3. Marking temporary errors as Invalid. A 4xx is a "later," not a "no." Re-verify unknowns after a few days before suppressing anything.
  4. Building a DIY verifier on a cloud server. Outbound port 25 is often blocked. A fresh IP has no reputation, so probes fail or get your IP blocklisted. Use a purpose-built engine and check your domains with a blacklist checker if you suspect damage.
  5. Verifying once. A list cleaned in January has decayed noticeably by summer. Schedule quarterly passes, plus a pass before reactivating any dormant segment.
  6. Deleting Invalid addresses instead of suppressing them. If they're deleted, the next CSV import or form resubmission can bring them back. Keep a permanent suppression list in your ESP.
  7. Skipping file prep. Duplicates, stray whitespace and multiple email columns cause confusing results and wasted runs. Dedupe and trim first, and split files to the per-list cap.
  8. Sending the whole Risky bucket at once. Even if only 10% of Risky addresses bounce, mailing them in one blast concentrates those bounces into a single send. Throttle in small batches and watch the bounce rate per batch.
  9. "Laundering" purchased lists through a verifier. A verifier removes dead addresses, but it can't remove the legal exposure or the spam traps. Build lists with permission.
  10. Blocking role-based addresses at B2B signup. If a company deliberately registers procurement@, blocking it loses a customer. Flag role-based addresses rather than rejecting them, and decide per use case.

Bottom line: Verification is a decision aid, not an autopilot. The teams that get the most from it read the reasons behind each verdict and act on them deliberately.

Verification result to action map

Result Typical cause Action
Valid Syntax OK, MX found, SMTP 250 for mailbox Send
Risky (catch-all) Domain accepts all RCPT TO Segment, send in small batches, monitor bounces
Risky (disposable/role) Temp-mail domain or info@/sales@ Suppress disposable; segment role-based
Unknown Timeout, greylisting (4xx), blocked probe Retry later, then treat as Risky
Invalid Bad syntax, no MX, SMTP 550 user unknown Suppress permanently

Frequently asked questions

Does email verification send an email to the address?

No. A verifier opens an SMTP connection to the recipient's mail server, issues HELO, MAIL FROM and RCPT TO commands, and reads the server's response. It disconnects before the DATA stage, where message content would be transmitted. The recipient never receives anything and is not notified that their address was checked.

How accurate is email verification?

Verification is highly reliable for clearly invalid addresses, such as bad syntax, missing MX records or explicit 550 mailbox-not-found responses. Accuracy drops on catch-all domains, servers that greylist or rate-limit probes, and providers that accept every RCPT TO request. Treat results as a probability. Valid means the address is very likely deliverable, not guaranteed.

What is a catch-all email domain?

A catch-all domain is configured to accept mail for any address at that domain, whether or not the mailbox exists. Because the server answers 250 OK to every RCPT TO probe, SMTP verification can't tell real addresses from fake ones. Verifiers mark these results as Risky or Accept-All. You can then segment those addresses and send to them cautiously.

What is the difference between email validation and email verification?

The terms are often used interchangeably. Strictly speaking, validation usually means checking format and syntax against rules like RFC 5322. Verification goes further, confirming that the domain has MX records and that the mailbox exists through an SMTP check. In practice, most tools run both steps and present a single combined result.

What do the results Valid, Risky, Invalid and Unknown mean?

Valid means the server confirmed the mailbox exists and no major risk flags apply. Risky covers catch-all, disposable, role-based or full-mailbox addresses that may deliver but carry extra risk. Invalid means the syntax failed, the domain has no mail server, or the mailbox was rejected. Unknown means the server timed out or refused to answer, so a later retry is worthwhile.

How often should I verify my email list?

Verify new signups in real time at the point of capture. Re-verify any list or segment that hasn't been mailed in 90 days or more before you send to it again. Address lists decay continually as people change jobs and abandon accounts. Large or B2B lists benefit from re-checks every few months, even when they are mailed regularly.

Can email verification detect spam traps?

Only partially. Some verifiers flag known spam trap domains and recycled-trap patterns, but pristine spam traps look like normal valid addresses and are designed to be undetectable. The best protection is to never buy or scrape lists, use confirmed opt-in, and suppress addresses that show no engagement over a long period.

Why do some email addresses come back as Unknown?

Unknown results usually come from servers that time out, greylist the connection with a temporary 4xx code, rate-limit repeated probes, or block verification traffic entirely. Some large providers deliberately return ambiguous responses. Retrying later often resolves the result. Addresses that remain Unknown should be treated like Risky ones and sent to cautiously or in small batches.

Is it legal to verify email addresses?

Verifying addresses you collected legitimately is generally lawful because no message is sent and the check uses standard SMTP behavior. You still need a lawful basis to hold and email the data under laws like GDPR or CAN-SPAM, and you should use a verification provider with appropriate data-processing terms. Verification does not make a purchased list compliant.

Should I remove role-based addresses like info@ or sales@?

Not automatically. Role-based addresses often reach shared inboxes with several readers, which can mean lower engagement and higher complaint risk. Keep them if the contact explicitly opted in or the address is important for B2B. Otherwise, segment them and watch their engagement. Many senders exclude them from cold or promotional campaigns.

Cut Bounces and Protect Your Sender Reputation With Unlimited Email Verification

Every invalid address you send to hurts your sender reputation and your inbox placement. Verifying your list before each send means fewer bounces, healthier deliverability, and a predictable cost. With Unlimited Verifier, standard verification is unlimited on every plan, with no per-email fees.

Unlimited Verifier checks syntax, domain, MX records and the SMTP mailbox. It also detects catch-all domains and flags disposable and role-based addresses. Export a CSV from your email platform or CRM, upload and verify the list, then re-import the clean results. You can also automate checks with the email verification API.

Free Pro
Price $0 $29/month ($25/month billed annually)
Lists 25 a month, up to 150 emails each Unlimited, up to 25,000 emails each
Deep verifications 750 a month 25,000 a month
API access No Yes (100,000 emails a month)
Result retention 24 hours 30 days

Why teams choose Unlimited Verifier

Unlimited Verifier states 99.5% accuracy for deep verification.

Create a free account and verify your next list before you hit send.

Want to test a single address first? Try the free email checker.