Article
What Accuracy Rate Should an Email Verifier Have?
By Unlimited Verifier Team ·

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
- Overall accuracy: 95% or higher on decisive results, measured on a labeled sample of 1,000 to 2,000 rows from your own history.
- Valid precision: 98% or higher. A Valid verdict should be deliverable at least 98% of the time, which keeps the set you mail under a 2% bounce ceiling.
- Invalid recall: 95% or higher. Dead addresses the tool misses become hard bounces when you send.
- Treat vendor headline figures as claims to test. That includes Unlimited Verifier's stated 99.5% for deep verification, which is the company's own figure.
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:
- Correct Valid: deliverable, and labeled Valid.
- Correct Invalid: dead, and labeled Invalid.
- False Valid: labeled Valid but bounces. This is the expensive error, because it lands as a bounce in your campaign. For the related concept, see what is a false positive in email verification.
- False Invalid: labeled Invalid but deliverable. This costs reach, not reputation.
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:
- Test set. A clean consumer list is easier than a messy B2B list full of catch-all domains.
- Scoring. Some headline figures exclude Risky results from the calculation, which can inflate them. Others count Risky as wrong. Ask which method was used.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Upload the address file. CSV and Excel files up to 10MB are accepted, and the email column is detected automatically.
- 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.
- 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.
- 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")). - 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:
- Decisive accuracy: (1,480 + 365) ÷ (1,500 + 380) = 1,845 ÷ 1,880 = 98.1%
- Overall accuracy, Risky counted as wrong: 1,845 ÷ 2,000 = 92.3%
- Valid precision: 1,480 ÷ 1,500 = 98.7%
- Invalid recall: 365 ÷ 400 = 91.3%
- Baseline (label everything Valid): 1,600 ÷ 2,000 = 80%
Read against the targets:
- Decisive accuracy passes the 95% floor.
- Valid precision passes the 98% target, but narrowly.
- Invalid recall fails the 95% target. Its 35 misses are 20 dead addresses in the Valid bucket and 15 in Risky.
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:
- Three buckets. Valid, Risky and Invalid let you keep Risky addresses out of first sends.
- Flags that map to your strata. Catch-all domains are detected, and disposable and role-based addresses are flagged, so you can break scores down the way the test requires.
- Export formats. CSV, Excel or JSON let you script the join or keep an audit file.
- API on Pro. Single checks and bulk batches of up to 10,000 emails per request are supported, and Pro includes 100,000 API emails a month. The Free plan has no API access. For automation patterns, see email verification API and automation and the email verification API.
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:
- Quoting one headline figure without a baseline. Ask what the bad rate of the test list was.
- Testing on your cleanest list. A sample of recently engaged contacts inflates every score.
- Silently excluding Risky results. Excluding them changes the score. State the method every time.
- Treating silence as truth. An address that never bounced isn't proven valid. Label Good only on delivery evidence, and drop ambiguous rows.
- Letting the verifier's output become the label. If you label with the tool you're testing, the test is circular.
- Choosing between tools that differ by one point on 400 rows. Sampling noise is larger than the gap.
- Ignoring the catch-all share. A low Risky count can mean the tool is guessing.
- Mixing deep and standard results. Compare like with like, and record which checks you ran.
- Forgetting that results expire. Free results are kept for 24 hours and Pro results for 30 days, so export before the window closes.
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 standard verification on all plans, including Free, with no per-email fees.
- Catch-all detection so you know which domains accept every address.
- Clear Valid / Risky / Invalid results, exportable as CSV, Excel or JSON.
- An open-source verification engine you can inspect on GitHub.
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.