Guides

Best e-mail verification APIs in 2026: a criteria-based comparison

Eight e-mail verification APIs and MobileValidate compared on public, dated evidence: unknown billing, catch-all handling, retention, SDKs, MCP, free tiers and list prices, plus a bake-off script.

By Published 11 min readHow we research and fact-check

On this page

Choose an e-mail verification API by how it reports unknown and catch-all results, whether it charges for them, whether it has a real-time API for sign-up forms, how long it keeps your data and what it costs at your volume. Don't choose it by a claimed accuracy percentage: none of the services below publishes independently audited accuracy. The tables compare eight services and MobileValidate on public evidence fetched on 26 September 2026, and say where each is strongest.

Disclosure: we make MobileValidate. It's in the tables, including the rows where other services fit better. Our mailbox check covers major webmail providers only, so for company domains and catch-all detection, it's not the right choice.

How did we build this comparison?

Only from each service's own public pages: pricing pages, API documentation, help centres and privacy or retention policies. Every page was fetched on 2026-09-26, and each service's pages are listed under Sources. The rules:

  1. Criteria come before products (next section).
  2. Only facts the service states publicly. Where we couldn't find or load a fact, the cell says "not found".
  3. No accuracy figures. Several services publish accuracy claims. We haven't tested them and don't repeat them. The bake-off script below lets you measure on your own data.
  4. List prices only, in USD, for the smallest published option that covers the volume. Discounts, subscriptions and taxes change the real price.
  5. Service names are used descriptively. No logos, no copy from their sites. We aren't affiliated with any of them.

Prices and policies change. We plan to refresh this page every quarter, and the "Updated" date above shows when we last did.

A criteria table of generic e-mail verification providers with columns for free unknowns, catch-all, SDKs and MCP, an envelope marked as an estimate for catch-all, and list prices at 10K, 100K and 1M.A criteria table of generic e-mail verification providers with columns for free unknowns, catch-all, SDKs and MCP, an envelope marked as an estimate for catch-all, and list prices at 10K, 100K and 1M.
Compare e-mail verifiers on unknown billing, catch-all handling, SDKs, MCP and price at your volume.

Which criteria matter for sign-up vs list cleaning?

The same API can be a good fit for one job and a poor fit for another.

CriterionSign-up form (real time)List cleaning (bulk)
Single-address API with low latencyEssentialNice to have
Typo suggestions ("did you mean gmail.com?")Very usefulRarely used
Disposable-domain flagUseful as a risk signalUseful
Catch-all reportingShows as "unknown": confirm by e-mailDecides what you keep
Free unknown resultsImportantVery important at volume
Data retentionShort is betterShort, or deletable on demand
Bulk upload API and price per 100k+IrrelevantEssential
SDKs, MCP serverSaves integration timeLess important

Two points apply everywhere. First, what happens to unknowns: a service that charges for "unknown" or "catch-all" rows charges you for its own uncertainty. Second, what the answer is based on: a mail-server reply, a model score or a cached result are three different kinds of evidence. The mailbox check article explains why mail servers often can't be asked directly.

No verifier replaces consent and confirmation. Google's sender guidelines ask senders to confirm each recipient's address before subscribing them, and to keep the spam rate below 0.10%, never reaching 0.30%. Verification catches typos and dead mailboxes; it doesn't make an unsolicited list safe to mail.

How do the services compare?

Features and policies, from each service's public pages (fetched 2026-09-26):

ServiceReal-time APIBulk APICatch-all reportingUnknown resultsData retention (as stated)Official SDKsOfficial MCP serverFree tier
ZeroBounceYesYescatch-all status; its Email Scoring product suggested for catch-alls"we will never charge you"Uploaded lists deleted after 30 days13 languages, incl. JS, Python, PHP, Java, Go, C#Yes100 per month (business domain sign-up)
KickboxYesYes (batch)accept_all flag, classed "Risky"Credit refundedList data deleted after 90 daysNode.js, PHP, Python, RubyNot found100
EmailableYesYesaccept_all flag; accept-all addresses classed as riskyFree (refunded)Customizable retention (Enterprise page); default period not foundRuby, Node.js, PythonNot found250
BouncerYesYesacceptAll field; "Deep Verification of Catch-All"Never chargedDeleted after 60 daysNot listed (OpenAPI spec)Yes100
HunterYesIn the web appaccept_all statusNo credit countedVerification history kept 3 monthsNone official (community libraries)Yes50 credits per month
VerifaliaYes (jobs with wait)Yes (jobs)ServerIsCatchAll statusNot foundConfigurable, 5 minutes to 30 days.NET, Go, Java, JavaScript, PHP, RubyNot found25 per day
MillionVerifierYesYescatch_all result; "catch-all verification at no extra cost"Unknown and catch-all not chargedFiles normally deleted within 30 daysNot specifiedNot found100
ClearoutYesYes"Catch-All" status; "Deep Verify""Unknowns are always free"Not stored more than 30 daysNode.js, JavaScript widgetNot found100
MobileValidateYesYesNot detected: company and custom domains return unknown (UNSUPPORTED_PROVIDER)FreeLookups 7 days, bulk jobs 30 days by default (configurable)Node.js, PythonYesTest mode free; every live account gets 5 real e-mail checks free on the dashboard

Coverage is the difference the table can't show. The eight other services attempt addresses on any domain. MobileValidate's mailbox check answers only for major webmail providers.

Two more fields matter for sign-up forms:

  • Disposable domains. ZeroBounce, Kickbox, Emailable, Bouncer, Verifalia, MillionVerifier and Clearout document a disposable flag or status. Hunter flags disposable addresses and doesn't charge a credit for them. MobileValidate has no disposable-domain flag.
  • Typo suggestions. ZeroBounce, Kickbox, Emailable, Bouncer, Verifalia, MillionVerifier, Clearout and MobileValidate document a suggestion field or status. We didn't find one in Hunter's API docs.

Which is best for real-time sign-up checks?

Pick one with a single-address API, typo suggestions, a disposable flag and free unknowns. On public evidence, Kickbox, Emailable, Bouncer, ZeroBounce, MillionVerifier and Clearout all tick those four boxes. Verifalia also does, through its job API with a wait time, except that we couldn't find its policy on unknowns.

What the pages don't tell you is latency. None of them publishes percentile latency for its real-time API, so measure it (see the bake-off below). A sign-up form needs an answer in a second or two. Anything slower should run after the form is submitted.

Where MobileValidate fits: sign-up flows where most users give addresses at big webmail providers and you also check the phone number. One request can check an e-mail address and a phone number together, unknowns are free, and our MCP server exposes the same checks to AI agents. Where it doesn't: if many of your users sign up with work addresses, most of our answers will be unknown, because we don't check company domains.

Which is best for custom-domain (B2B) addresses?

Not MobileValidate. For company domains, you need a service that probes any domain and tells you when it is catch-all. All eight other services report catch-all or accept-all domains. ZeroBounce, Bouncer, Clearout and MillionVerifier also advertise extra processing for catch-all addresses (Email Scoring, Deep Verification, Deep Verify and included catch-all verification).

Treat those extras as estimates. A catch-all domain accepts every address, so the mail server itself can't confirm the mailbox: it says yes to real and made-up addresses alike. Ask any provider how it measured the accuracy of its catch-all answers, and test on addresses where you already know the outcome.

Which is best on price at 10k, 100k and 1M checks?

List prices in USD for the smallest published option that covers the volume (fetched 2026-09-26):

Service10,000100,0001,000,000Notes
MillionVerifier$39$149$449Credit packs
Verifalia$49.90$389$1,490Credit packs; standard quality uses 1 credit, higher quality levels use 2 or 4
Emailable$60$420$2,100Credits; minimum purchase 5,000
Bouncer$60$400$2,000Credits; minimum purchase 1,000
Kickbox$70$500$2,999Credits
ZeroBounce$129$649$3,199Pay as you go; a subscription option exists
Hunter149€ per monthsee notessee notesSubscription; 1 verification = 0.5 credit, so the 10,000-credit plan covers 20,000 verifications. Bulk credits are priced in an on-page calculator that bundles search and verification credits, so we couldn't derive a like-for-like price
Clearoutnot capturednot capturednot capturedPrices load in the browser; we couldn't read them reliably
MobileValidate$60 real time / $40 bulk$400 bulk$4,000 bulk$6.00 per 1,000 real time, $4.00 per 1,000 bulk, per conclusive answer (prices from 17 October 2026; see pricing for current prices); top-ups from $100 add 5–10% bonus credit; committed volume on request

The ZeroBounce, Emailable, Verifalia and MillionVerifier figures come from the price data their pricing pages load, rather than from visible page text. Check them in a browser before you buy. On 2026-11-03 we re-checked the Kickbox, Bouncer, MillionVerifier and Hunter figures on their pricing pages; they were unchanged.

On list price, MillionVerifier is the cheapest at every volume here, and the gap widens with volume. Bouncer, Emailable and Verifalia sit in the middle. MobileValidate is mid-range at 10,000 checks and expensive for large bulk lists. Price per check isn't the whole cost, though. Compare the price per useful answer: a service that returns more unknowns, or charges for them, costs more than its list price suggests.

Which is best for AI agents (MCP)?

If an AI agent or coding assistant will run the checks, an official Model Context Protocol (MCP) server saves you writing and securing your own tool wrapper. On their public pages, ZeroBounce, Bouncer and Hunter describe official MCP servers, and so do we. For the other five, we found no official MCP page on 2026-09-26. That doesn't stop an agent from calling their REST APIs, but you'd build the tool yourself.

What to look for in an agent integration, whichever service you pick:

  • Spend limits. An agent can loop. Our MCP server accepts only scoped, spend-capped agent keys and asks for confirmation above a cost threshold. Ask the others how they cap spend.
  • Clear unknowns. The tool result should say "unknown" in words, so the agent doesn't read a missing answer as "invalid".
  • No enumeration. An agent asked to "find the right address for Jane at a company" is guessing addresses. Tools should refuse generated lists; ours does.

How do their answers map to "exists", "missing" and "unknown"?

Each service uses its own status names, so a fair comparison maps them onto the same three outcomes first. Using the top-level status fields documented on 2026-09-26:

Service (field)ExistsMissingUnknown or not provable
ZeroBounce (status)validinvalidcatch-all, unknown; spamtrap, abuse, do_not_mail are policy flags, decide separately
Kickbox (result)deliverableundeliverablerisky, unknown
Emailable (state)deliverableundeliverablerisky, unknown
Bouncer (status)deliverableundeliverablerisky, unknown
Hunter (status)validinvalidaccept_all, unknown; webmail and disposable describe the provider, not the mailbox
MillionVerifier (result)okinvalidcatch_all, unknown; disposable is a policy flag
MobileValidate (registered)truefalsenull, with reason

For Verifalia and Clearout, map the status list in their docs the same way. Two traps: "risky" usually bundles catch-all, disposable and role addresses together, so read the reason field before you count it; and a service that returns fewer unknowns isn't automatically better unless its extra answers are right. Only a labelled sample tells you that.

How do I test a verifier before buying?

Run the same labelled sample through each candidate and compare four numbers: conclusive rate, agreement with your labels, latency and billed rows. Use addresses you're allowed to process and whose outcome you already know, for example confirmed sign-ups (label exists) and addresses that hard-bounced (label missing). Don't build a sample by guessing addresses. That's enumeration, which our acceptable use policy forbids, and it isn't a fair test anyway: you don't know the right answers.

This Node script (Node 18 or later) measures the four numbers. It includes a MobileValidate adapter. Add one adapter per candidate that maps its statuses to exists, missing or unknown:

bakeoff.mjs
// Usage: node bakeoff.mjs sample.csv
// sample.csv: email,label   (label = exists | missing; addresses you are allowed to process)
import { readFile } from "node:fs/promises";

// One adapter per service. Each returns "exists" | "missing" | "unknown" and whether it was billed.
const adapters = {
  mobilevalidate: async (email) => {
    const res = await fetch("https://api.mobilevalidate.com/v1/lookup", {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.MOBILEVALIDATE_API_KEY ?? "mv_test_publicSandboxn9ZgneuhR1B9CRfKG3fulym"}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ emails: [email], checks: ["email"], wait: 10 }),
    });
    const check = (await res.json()).results?.[0]?.checks?.["email.valid"];
    const verdict = check?.registered === true ? "exists" : check?.registered === false ? "missing" : "unknown";
    return { verdict, billed: check?.billed ?? false };
  },
  // other: async (email) => { /* call the other service's API and map its statuses */ },
};

const pct = (n, d) => (d ? `${((100 * n) / d).toFixed(1)}%` : "n/a");
const quantile = (xs, q) => xs.slice().sort((a, b) => a - b)[Math.min(xs.length - 1, Math.floor(q * xs.length))];

const rows = (await readFile(process.argv[2], "utf8")).trim().split("\n").slice(1).map((l) => l.split(","));
for (const [name, check] of Object.entries(adapters)) {
  const s = { conclusive: 0, correct: 0, unknown: 0, billed: 0, ms: [] };
  for (const [email, label] of rows) {
    const t0 = performance.now();
    const { verdict, billed } = await check(email.trim());
    s.ms.push(performance.now() - t0);
    if (billed) s.billed++;
    if (verdict === "unknown") { s.unknown++; continue; }
    s.conclusive++;
    if (verdict === label.trim()) s.correct++;
  }
  console.log(`${name}: n=${rows.length} conclusive=${pct(s.conclusive, rows.length)} ` +
    `agreement=${pct(s.correct, s.conclusive)} unknown=${s.unknown} billed=${s.billed} ` +
    `p50=${quantile(s.ms, 0.5).toFixed(0)}ms p95=${quantile(s.ms, 0.95).toFixed(0)}ms`);
}

We ran it on 2026-09-26 with the public sandbox key and the five test addresses. It printed mobilevalidate: n=5 conclusive=60.0% agreement=100.0% unknown=2 billed=0 p50=78ms p95=5062ms. The 5-second p95 is the pending@ test address, which waits 5 seconds by design. Sandbox numbers only prove the plumbing. Your own sample decides.

Tips for a fair test:

  • Use at least a few hundred labelled addresses, with a mix of webmail and company domains that matches your real traffic.
  • Run candidates on the same day, because answers can change over time.
  • Record the raw status, not just your mapping, so you can re-map later.
  • Compare cost per conclusive, correct answer, not the list price.

Where MobileValidate fits, and where it doesn't

A summary, in the same spirit as the tables:

Your situationGood fit?Why
Consumer sign-ups, mostly big webmail providersYesReal-time mailbox check, typo suggestions, unknowns free
You also verify phone numbers at sign-upYesOne API and one request for e-mail and phone checks
AI agents need to run checksYesMCP server with spend caps
Many work or custom-domain addressesNoCompany domains return unknown; choose a service that probes any domain
You need catch-all detection or scoringNoWe don't offer it
You need a disposable-domain flagNo, not yetPair us with a disposable-domain blocklist
Large list cleaning at 1M+Usually noSeveral services here have lower list prices at volume

If we're the wrong fit for your job, pick from the tables above using your own bake-off. Our mailbox check page and pricing have the details for when we are the right one. The phone side of the decision is covered in the phone number validation API buyer's guide.

What are the key takeaways?

  • Choose on criteria, not claimed accuracy: real-time API, unknown billing, catch-all reporting, retention and price at your volume.
  • Most services here say unknown results are free. We couldn't find Verifalia's policy on unknowns.
  • Catch-all "resolution" is an estimate. No mail server can confirm a mailbox on a catch-all domain.
  • MillionVerifier has the lowest list prices here at 10k, 100k and 1M. ZeroBounce has the most official SDKs. ZeroBounce, Bouncer, Hunter and MobileValidate publish MCP servers.
  • MobileValidate covers major webmail providers only. It suits consumer sign-ups combined with phone checks. It doesn't suit company domains, catch-all detection or very large lists.
  • Run a bake-off on your own labelled addresses before you commit.

Sources

  1. ZeroBounce: pricing, API status codes, FAQ (retention), API wrappers and MCP server pages — ZeroBounce, 2026
  2. Kickbox: pricing, single verification API, terminology, list security and privacy, API libraries — Kickbox, 2026
  3. Emailable: pricing, API documentation and data retention — Emailable, 2026
  4. Bouncer: pricing, e-mail verification API, terminology, FAQ, GDPR and MCP server pages — Bouncer, 2026
  5. Hunter: pricing, API documentation v2 and privacy policy — Hunter, 2026
  6. Verifalia: pricing and developer documentation — Verifalia, 2026
  7. MillionVerifier: home page pricing, price policy, developer docs and privacy policy — MillionVerifier, 2026
  8. Clearout: pricing guide, FAQs, API overview and SDKs — Clearout, 2026
  9. Email sender guidelines — Google (Gmail Help), 2026

Frequently asked questions

What is the best e-mail verification API?

It depends on the job. For real-time sign-up checks, look for a single-address API, typo suggestions and free unknown results. For company (B2B) addresses, look at how catch-all domains are reported. For large lists, compare list prices at your volume. No provider publishes independently audited accuracy, so run your own bake-off.

Do e-mail verifiers charge for unknown results?

Most in this comparison say they don't. ZeroBounce, Kickbox, Emailable, Bouncer, Hunter, Clearout and MobileValidate state that unknown results are free; MillionVerifier doesn't charge for unknown or catch-all results. We couldn't find Verifalia's policy on unknowns on the pages we checked.

Can any verifier confirm an address on a catch-all domain?

Not with certainty. A catch-all domain accepts every address, so the mail server can't confirm a specific mailbox. Some services offer catch-all scoring or deep verification. Those are estimates, and their accuracy isn't independently published.

Where is MobileValidate a poor fit?

For company and custom domains, catch-all detection and large-volume list cleaning. Our mailbox check covers major webmail providers only, and at list prices it costs more per address at volume than several services here. It fits sign-up checks that combine e-mail with phone signals.

How was this comparison made?

Only from each provider's own public pricing pages, API docs and policies, all fetched on 26 September 2026. We didn't test the other services' accuracy, and we don't repeat accuracy claims. We make MobileValidate.

All articles

Know before you send.

Create a free account: approved automatically, usually within 10–15 minutes.

Free to start: check 20 phone numbers and 10 e-mail addresses for real on your account, plus an unlimited test mode. You pay only for conclusive answers, from $20.