Article

What Accuracy Rate Should an Email Verifier Have?

By Unlimited Verifier Team ·

Diagram showing an email list passing through a verifier that sorts addresses into Valid, Risky, and Invalid, with accuracy targets for each path.

Summary

An email verifier should be at least 95% accurate on decisive results (Valid or Invalid) and its Valid verdicts should be deliverable at least 98% of the time. These are working targets rather than published standards, so measure accuracy on a labeled sample from your own list.

An email verifier should be at least 95% accurate on decisive results (Valid or Invalid), measured against a labeled sample from your own list, and its Valid results should be correct at least 98% of the time. These are working targets, not published standards: no regulator or standards body sets a required accuracy figure, so the number that matters is the one you measure on your own data.

Quick answer

What does accuracy mean for an email verifier?

Accuracy is the share of verdicts that match reality. A verifier returns three categories rather than a yes or no, so one headline number can hide the errors that cost you money.

Every address has a ground truth (did it accept mail?) and a verdict (Valid, Risky or Invalid). Four outcomes matter:

Accuracy also needs a baseline. If 20% of a list is dead and a tool labels everything Valid, it scores 80% while catching zero dead addresses. Before you compare any two numbers, ask what the bad rate of the test list was.

Metric Question it answers Formula Our target
Overall accuracy (decisive) How often is a Valid or Invalid call right? (Correct Valid + Correct Invalid) ÷ all Valid and Invalid calls 95%
Valid precision When it says Valid, is it deliverable? Correct Valid ÷ all Valid calls 98%
Invalid recall Of the dead addresses, how many did it catch? Correct Invalid ÷ all truly dead addresses 95%
Risky share How many addresses could it not call? Risky ÷ total Report it, and watch it by domain type

Bottom line: Accuracy is a set of metrics, not one number. Valid precision protects the send, and invalid recall protects the list.

Why 95% and 98%, and not 99%?

The targets work backward from a bounce ceiling, not from a published standard. Platforms disagree about where the danger line sits, so we recommend the stricter reading.

Amazon SES's documentation describes reviewing an account at a 5% bounce rate and pausing sending at 10%. Many ESPs act earlier, especially on a single campaign to an unproven list, and none publishes a single line that applies everywhere. Where sources disagree, we use a 2% total bounce ceiling, which leaves room before most automated triggers. Google's sender guidelines add a separate limit on spam complaints. A verifier can't fix complaints directly, but a list full of dead or recycled addresses tends to generate both bounces and complaints.

Two calculations explain the targets.

Invalid recall. Take a 100,000-address list with 5% dead addresses (5,000). A verifier with 95% recall catches 4,750 and misses 250, which adds 0.25% to your bounce rate before you send anything. At 90% recall it misses 500, or 0.5%. That single miss rate uses a quarter of a 2% budget before any other bounce source is counted.

Valid precision. Precision is what you pay at send time. If your Valid bucket holds 90,000 addresses, 98% precision means up to 1,800 of them (2%) are dead. That is inside the ceiling but leaves little margin. A tool at 95% precision would put up to 4,500 dead addresses in front of you.

Your list changes the numbers. A fresh, double opt-in consumer list has a low dead share, so you can set stricter targets. An imported B2B list has a higher bad rate and more Risky results, so expect the same tool to look weaker.

Bottom line: Precision protects the send and recall protects the list. Both targets come from a 2% bounce ceiling, so adjust them to your list's bad rate, not to a vendor's marketing.

Why do vendors publish different accuracy numbers?

Vendors publish different figures because they test different lists, score results differently and use different ground truth. The same address can get different verdicts from different tools, so headline numbers are not comparable until those three things match.

Three factors drive most of the gap:

  1. Test set. A clean consumer list is easier than a messy B2B list full of catch-all domains.
  2. Scoring. Some headline figures exclude Risky results from the calculation, which can inflate them. Others count Risky as wrong. Ask which method was used.
  3. Ground truth. If a vendor labels its test addresses with its own checks, the test is partly circular. Delivery outcomes are a stronger reference, though they have blind spots of their own.

Unlimited Verifier states 99.5% accuracy for deep verification. That is the company's stated figure, and we have not found an independent benchmark behind it, so treat it as a claim to test on your data. For a broader view of what a percentage can and cannot tell you, read how accurate is email verification really. To see how two popular tools can disagree on one address, read why ZeroBounce and NeverBounce disagree on the same email.

Evaluation method What it tells you Main weakness
Vendor headline figure A starting claim Self-selected dataset and scoring
Independent benchmark Comparable results across tools A snapshot that ages; see the 2026 independent benchmark
Your own bounce logs (back-test) The closest match to your reality Covers only addresses you have already mailed
Hand-labeled sample Ground truth you can defend Slow, and human labelers make mistakes
Open-source engine review Which checks run and how they combine Shows logic, not accuracy at scale

Unlimited Verifier's verification engine is open source on GitHub, so you can read which checks run before you trust a verdict. Reading code tells you about the logic, though, not about how often the output is right.

Bottom line: Headline numbers are not comparable until the test set, scoring and ground truth match. Run your own test before you choose.

How do you measure a verifier's accuracy on your own list?

Build a labeled sample from your own send history, hide the labels, run the verifier and score the results on the four metrics. For the method in more depth, see how email verifiers measure accuracy. Here is the process.

  1. Create ground truth from bounce logs. Label an address Dead if it hard-bounced with an addressing code from RFC 3463, such as 5.1.1 (bad destination mailbox) or 5.1.2 (bad destination system). Label it Good only when it was delivered without a hard bounce. Exclude soft bounces rather than guessing their status.
  2. Stratify the sample. Include consumer domains, corporate domains, catch-all corporate domains and disposable addresses. A sample of only Gmail addresses will flatter almost any tool, because mailbox providers differ in how they respond to verification probes.
  3. Size for the rare class. Most lists are mostly good, so dead addresses are the scarce rows. Aim for 1,000 to 2,000 rows with at least 200 Dead. At 200 dead rows, invalid recall carries a margin of roughly ±3 points at 95% confidence, so a 2-point gap between two tools proves nothing.
  4. Reweight to your real mix. Precision moves with the bad rate. A sample that is 20% dead will not predict what a 5%-dead list produces. Reweight the results to your true bad rate before you quote a figure.
  5. Run a blind test. Keep the labels in a separate file and upload only the addresses. Use the same verification mode (standard or deep) you will use in production, because the vendor's 99.5% figure refers to deep verification.
  6. Score and break down by stratum. Calculate the four metrics in a spreadsheet and keep the formulas visible. Check catch-all accuracy separately. A tool that calls catch-all addresses Valid is guessing, even if its overall score looks strong.
  7. Repeat on a schedule. Verifiers change their checks, and mailbox providers change their responses. Re-test quarterly and fold the results into your list maintenance routine.

Note the limit in step 1. Your bounce history covers only addresses you already mailed, so it under-represents addresses you never sent to. Say so in any report you share.

Bottom line: A blind, stratified sample of 1,000 to 2,000 rows, with at least 200 dead, scored on four metrics, tells you more than any headline figure.

How do you run the accuracy test in Unlimited Verifier?

You can run the full test in Unlimited Verifier by splitting the labels from the addresses, uploading the blind file, exporting the results and joining them back in a spreadsheet. Unlimited Verifier has no native ESP, CRM or Zapier integration, so the workflow is export, verify, then join by hand or call the API from your own script.

  1. Export your history. Pull the hard-bounce log with status codes from your ESP, plus a random sample of delivered addresses. Put both in one spreadsheet and make sure every stratum is represented.
  2. Split the file. Save one CSV with only the email column. Save a second file with email and a Truth column (Dead or Good). Never upload the second file.
  3. Sign up and choose a plan. Sample size decides which one fits:
    • Free: 25 lists a month, up to 150 emails per list, and 750 deep verifications a month. There is no API access. A 2,000-row sample needs 14 lists (13 × 150 + 1 × 50 = 2,000), within the 25-list allowance. But only 750 rows can be deep-verified, so the rest run on standard checks, which doesn't match a test of the deep figure.
    • Pro: $29 a month, or $25 a month billed annually. Each list holds up to 25,000 emails, so a 2,000-row test fits in one list, and the plan includes 25,000 deep verifications a month.
  4. Upload the address file. CSV and Excel files up to 10MB are accepted, and the email column is detected automatically.
  5. Export immediately. Results are kept for 24 hours on Free and 30 days on Pro. Export as CSV or JSON and date-stamp the file.
  6. Join the results. In one sheet, paste the verdicts into column B and the truth labels into column C, matching on the email column with VLOOKUP or XLOOKUP.
  7. Compute the metrics. With those columns, Valid precision is =COUNTIFS(B:B,"Valid",C:C,"Good")/COUNTIF(B:B,"Valid"). Invalid recall is =COUNTIFS(B:B,"Invalid",C:C,"Dead")/COUNTIF(C:C,"Dead"). Decisive accuracy is =(COUNTIFS(B:B,"Valid",C:C,"Good")+COUNTIFS(B:B,"Invalid",C:C,"Dead"))/(COUNTIF(B:B,"Valid")+COUNTIF(B:B,"Invalid")).
  8. Spot-check disagreements. For individual addresses where a verdict looks wrong, run them through the free email checker.

Pricing matters because you may run the test several times. Unlimited Verifier includes unlimited standard verification on every plan, with no per-email fee. If you use all 25,000 deep verifications on Pro, the $29 monthly plan works out to about $1.16 per 1,000 deep checks, and the $25 annual rate to about $1.00. For how these models compare, see email verification pricing.

Bottom line: Split the labels from the addresses, export before the retention window closes, and calculate the metrics with formulas anyone on your team can audit.

What does a worked accuracy test look like?

The example below is hypothetical. The numbers are invented to show the arithmetic, not to describe any real tool.

Suppose your sample has 2,000 addresses: 1,600 Good and 400 Dead. The verifier returns these results:

Verdict Truly deliverable Truly dead Total
Valid 1,480 20 1,500
Invalid 15 365 380
Risky 105 15 120
Total 1,600 400 2,000

The calculations:

Read against the targets:

The 20 false Valids are 1.3% of the Valid bucket. That is under the 2% ceiling but above the 1% you want for re-entry sends. The recall gap is also larger than sampling noise: with 400 dead rows, the margin is about ±2.8 points, so 91.3% sits clearly below 95%.

This sample is 20% dead, so step 4 of the method applies. Reweighted to a 5%-dead list, Valid precision would look better, but the recall failure would not change. The decision: keep this verifier for Valid and Invalid calls, hold back Risky addresses, and re-check Valid addresses from catch-all domains before a major send.

Bottom line: A verifier can pass the headline test and still miss enough dead addresses to hurt your bounce rate. Read invalid recall and Valid precision separately.

Which accuracy profile fits your use case?

Choose a verifier by the metric your use case punishes most. A promotional consumer send, a B2B outbound list and a compliance audit need different balances.

Use case Priority metric Minimum we would accept How to set it up
High-volume consumer campaigns Valid precision 98% Send to Valid only and hold Risky back
B2B outbound or SaaS trial lists Invalid recall and catch-all handling 95% invalid recall Expect more Risky results and rank by recent engagement
Compliance audit Documented metrics and retained exports Full exports archived Export and archive each run before the window closes
Signup forms Speed and API access Fast single-address checks Validate at entry; see real-time email validation

For ecommerce and SaaS teams, email verification for ecommerce and SaaS usually means high volume and frequent re-checks. Compliance teams should weigh the audit trail as heavily as the score, which is covered in email verification compliance and hygiene.

Unlimited Verifier suits repeat runs without per-email fees. Its differentiators for this purpose are:

If you are shortlisting providers, start with the best email verification tools and use the buyer's guide to set your own criteria.

Bottom line: Match the verifier to the metric your use case penalizes most, then test it on your own sample before committing.

Where do accuracy numbers break down?

Accuracy numbers break down in four places: catch-all domains, provider-specific behavior, the gap between Valid and deliverable, and time. Design sends around these limits rather than trusting one figure.

Catch-all domains. Some mail servers accept every recipient address, so the server never reveals whether a specific mailbox exists. RFC 5321 defines the SMTP dialogue but doesn't require servers to reveal which mailboxes are real. A verifier can't confirm a mailbox on a catch-all domain, so the honest verdict is Risky. Judge a tool on whether it flags catch-all addresses rather than calling them Valid. See how accurate are email verifiers on catch-all domains and catch-all email verification.

Provider-specific behavior. Mailbox providers can respond to probes differently, so accuracy may vary between Gmail, Outlook and other domains. Test each major provider in your stratified sample rather than relying on one average. For provider-level detail, see email verifier accuracy on Gmail vs Outlook addresses.

Valid is not the same as deliverable. A Valid result means the mailbox passed a check at that moment. It doesn't prove the message will reach the inbox or that the recipient wants it. Read does a valid result mean the email will be delivered before treating Valid as a guarantee.

Time. Addresses change, so a 95% result from six months ago has aged. Re-verify on a schedule, and use the unknown rate guide to decide when a rising Risky share is a warning sign.

Bottom line: Accuracy falls on catch-all domains and drifts over time. Design around those limits.

What are the common mistakes when judging verifier accuracy?

Most accuracy mistakes make a tool look better than it is, or make a test impossible to trust. Avoid these:

Bottom line: Most accuracy errors come from weak test design, not weak tools. Fix the design first.

How we compared (and limitations)

This article is based on public documentation and standard definitions. We relied on RFC 5321 and RFC 3463 for SMTP behavior and status codes, Amazon SES's documentation and Google's sender guidelines for provider thresholds, and the standard precision and recall definitions for the metrics.

We have not run controlled tests across verification vendors. The worked example uses hypothetical numbers to show the arithmetic. The 95%, 98% and 95% targets are our recommendations, not published standards. Provider thresholds change without notice, and the blind-test method relies on bounce history, which covers only addresses you already mailed.

The 99.5% deep verification figure is Unlimited Verifier's own stated number. We have not seen an independent benchmark behind it, so run the blind test on your own data before relying on it.

Bottom line: Use the method, not our example numbers. Run the test on your own list and decide from the four metrics.

Worked example: scoring a 1,000-row sample

Assume a 1,000-row labeled sample with 850 deliverable and 150 dead addresses. The verifier returns 830 Valid, 140 Invalid, and 30 Risky.

Result Count Calculation Value Target Status
Overall accuracy (decisive) 950 of 970 (820 Valid + 130 Invalid) ÷ 970 97.9% 95% Pass
Valid precision 820 of 830 820 ÷ 830 98.8% 98% Pass
Invalid recall 130 of 150 130 ÷ 150 86.7% 95% Fail
Bounce rate on Valid set 10 of 830 10 ÷ 830 1.2% Under 2% Pass

The headline accuracy looks strong, but recall fails. Roughly 20 dead addresses remain in the Valid and Risky groups, so they would reach the list. This is an illustrative example, not a benchmark of any product.

Frequently asked questions

How do I measure an email verifier's accuracy?

Pull a random sample of 1,000 to 2,000 addresses from your own history, where you know which ones accepted mail. Run them through the verifier, then compare each verdict to the known outcome. Count correct and incorrect calls to get overall accuracy, Valid precision, and Invalid recall.

What is a labeled sample in email verification testing?

A labeled sample is a set of addresses whose true status is already known from past sending results, such as delivered or hard-bounced. Because the ground truth is recorded, you can score each verifier verdict against it. The sample should reflect your real list, including its domains and age mix.

Why is a Risky result not counted in overall accuracy?

Risky addresses are ones the verifier could not confidently call, such as catch-all domains or servers that would not confirm a mailbox. Counting them as wrong would penalize honest uncertainty. Report the Risky share separately and decide how to handle it based on your sending practices.

Can a verifier be accurate and still miss many dead addresses?

Yes. If most addresses on a list are deliverable, a tool can post high overall accuracy while missing many dead ones. This is why invalid recall matters alongside overall accuracy. Check both metrics before trusting a headline figure.

What is a good bounce rate after verification?

Many senders aim to keep total bounces under 2% because platforms vary in how early they act on bounce levels. Verification lowers the risk but does not guarantee a bounce rate. Monitor actual bounces after each campaign to confirm the result.

Should I trust a vendor's advertised accuracy number?

Treat vendor figures as claims to test. Headline numbers are often measured on the vendor's own datasets, under conditions that may not match yours. Run your own labeled sample before committing, and compare vendors on the same list.

Does list quality affect verifier accuracy?

Yes. Lists with many catch-all domains, old addresses, or disposable domains tend to produce more Risky or wrong verdicts. Accuracy measured on a clean list can look better than performance on your real data. Test on a sample that matches your typical list.

How often should I re-test verifier accuracy?

Re-test whenever you change verification providers, notice a rise in bounces, or your audience sources shift. Many teams re-check on a regular schedule, such as quarterly, to catch drift. Keep the same method each time so results stay comparable.

What is the difference between precision and recall for email verification?

Precision asks how many addresses labeled Valid were actually deliverable. Recall asks how many dead addresses the tool caught out of all dead addresses. Precision protects your sends from bounces, while recall protects your list from accumulating dead addresses.

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.