Author: Shoaibdethoadmin

Short answer: clean the list before you migrate, not after. A new sending domain or IP has no reputation, so your first campaigns on it are what mailbox providers use to decide who you are. Opening with a bounce-heavy send from a list you carried over unverified is the most expensive mistake in the whole migration.

Why the first send matters so much

Reputation attaches to your sending domain and IP. When either is new, there is no history to weigh your first send against, so that send carries disproportionate weight.

On established infrastructure a 6% bounce rate is a bad week inside a long record of good ones. On new infrastructure it is the entire record. And reputation repair takes weeks of disciplined sending, so a bad start costs you the first month or two of the new platform you just paid to move to.

The pre-migration checklist

1. Export everything from the old platform

Not just active subscribers. You need the suppression list too – unsubscribes, hard bounces, complaints. That file is the single most important thing you carry across, and it is the one people forget.

Migrating without it means re-mailing everyone who already unsubscribed. That is a compliance problem, not just a deliverability one.

2. Verify the whole list

Every address, including segments you have not mailed in a while – those are the ones carrying the most decay. Remove invalid addresses entirely and hold catch-alls in a separate segment. Do not import them into the new platform at all; there is no reason to pay a new ESP to store dead records.

3. Apply the suppression list before import

Filter the cleaned list against your historical suppressions, then import. Load the suppression file into the new platform as well, so future imports cannot reintroduce those addresses.

4. Segment by engagement before you send anything

Build these segments in the new platform on day one:

• Opened or clicked in the last 30 days – your warm-up audience
• Last 31-90 days
• Last 91-365 days
• No engagement in 12 months – do not mail from new infrastructure at all until it is established
• Catch-all and risky – separate, small-batch testing only

5. Set up authentication on the new domain

SPF, DKIM and DMARC, all three, with the From: domain aligned to whichever of SPF or DKIM authenticates. Configure a custom return-path or sending subdomain so alignment passes rather than authenticating your ESP’s domain.

Verify it with a real test – send to a seed account and read the headers for three passes before you send anything at volume. The setup order is here.

The warm-up order

1. Week 1: 30-day engaged segment only, at modest volume. These are the people most likely to open, and opens are what builds the new reputation.
2. Week 2: increase volume within the same segment. Keep cadence steady – providers reward predictability.
3. Week 3-4: add the 31-90 day segment if bounce and complaint rates are holding.
4. Month 2: add 91-365 days, in stages.
5. Ongoing: the 12-month-plus segment goes through re-engagement, then suppression. Do not fold it in.

If complaint or bounce rates move at any stage, stop and narrow back to the previous segment. Ramping too fast is the second most common migration failure after skipping the clean.

Things that go wrong

• Sending to everyone on day one to “test the new platform”. This is the failure that costs a month.
• Losing the suppression list in the export.
• Running both platforms in parallel without deduplicating, so subscribers get everything twice and complain.
• Changing the From: name and address at the same time as the platform. Recipients do not recognise you, complaints spike, and you cannot tell which change caused it.
• Forgetting the DMARC record on a new subdomain, which was covered by the old domain’s policy but is not automatically inherited in your new setup.

Change one thing at a time where you can. If the platform is changing, keep the sender identity and the content style constant so any problem has one plausible cause.

Clean before you migrate: 250,000 emails for $100, one million for $350, results back with the original columns intact. Start with 100 free credits.

Short answer: yes, but only for one of the three things that decide deliverability. Verification removes invalid addresses, so your bounce rate drops on the very next send. It does nothing about authentication failures and nothing about whether recipients want your mail. Senders who clean and see no improvement usually had one of those other two problems all along.

The three inputs providers actually grade

Input	What it signals	Does cleaning fix it?
Bounce rate	Whether you maintain your list	Yes, immediately
Authentication	Whether you are who you claim	No
Complaint rate and engagement	Whether recipients want your mail	Partly, indirectly

What cleaning fixes, and how fast

Bounce rate is the direct one. Remove the invalid addresses and the next campaign bounces less – there is no lag, because bounces are generated at send time.

There is also a second-order effect worth understanding. Bounces damage reputation, degraded reputation pushes more mail into spam folders, and mail in the spam folder collects complaints at a far higher rate than mail in the inbox. So a bounce problem becomes a complaint problem, and Google requires bulk senders to hold complaints under 0.1% and never reach 0.3%. Cleaning breaks that loop at the start.

What does not move immediately is reputation itself. If you have been bouncing heavily for months, expect several weeks of consistent clean sending before inbox placement follows. Reputation is deliberately slow to recover – the alternative would let spammers reset by behaving well for an afternoon.

What cleaning will never fix

Broken authentication

If your SPF, DKIM or DMARC records are wrong or misaligned, receiving servers reject your mail and your platform logs it as a bounce. The addresses are fine. Cleaning them removes real subscribers to fix a DNS problem.

Rule it out first: send a test to a seed account at each major provider and check the raw headers for spf=pass, dkim=pass and dmarc=pass. Anything else is your answer, and no amount of list hygiene will change it.

Unwanted mail

Verification confirms a mailbox exists. It says nothing about consent. Verify a purchased list and you have a list of confirmed-real addresses belonging to people who never asked to hear from you – the bounces disappear, the complaints and trap hits do not. Pristine traps in particular are perfectly valid mailboxes; no verifier can reliably identify them.

Disengagement

An address that has been deliverable and ignored for three years passes verification cleanly. Providers weight recent engagement heavily, so a large block of non-openers suppresses placement for your whole list. Only a sunset policy fixes that.

How to tell which problem you have

• Bounces rising, opens flat – list decay. Cleaning is the answer.
• Opens falling, bounces flat – you are being filtered, not bouncing. Look at complaints, traps and authentication. Cleaning will not help much.
• Fine at most providers, terrible at one – a provider-specific reputation issue or a blocklist. Read the rejection strings.
• Sudden spike across previously healthy addresses – infrastructure or a block, not decay. Something changed in your sending setup.

Diagnose before you spend. Cleaning is cheap enough that it is rarely wasted, but it is not a general-purpose deliverability fix and anyone selling it that way is overstating it.

The honest summary

Verification is the highest-leverage single action available for bounce rate, produces measurable results on the next send, and is a prerequisite for the rest of deliverability work rather than a substitute for it. Pair it with correct authentication and a genuine permission-based list and you have covered what mailbox providers actually measure.

Start with the bounce problem: 250,000 emails for $100, results on the next send. Try 100 free credits.

Short answer: email lists decay continuously because people change jobs, abandon personal accounts and close mailboxes. Industry estimates commonly put annual decay somewhere in the low-to-mid twenties percent for B2B lists, lower for consumer lists. Whatever the exact figure for your audience, the practical consequence is the same: a list you verified a year ago is not verified now.

What actually decays

Job changes – the B2B driver

Someone leaves, IT deletes the mailbox, and the address that was valid last quarter now hard-bounces. This is why B2B lists decay faster than consumer lists: a work address is tied to employment, and employment turns over.

Worse, some companies route departed employees’ mail to a successor or a shared inbox rather than bouncing it. Now a stranger is reading mail addressed to someone who left, and they have every reason to mark it as spam.

Abandonment – the consumer driver

People open a new account and stop checking the old one. It does not bounce; nobody is home. Eventually the provider reclaims the address, and after a dormancy period it may come back as a recycled spam trap.

This is the dangerous category, because an abandoned address looks healthy right up until it becomes a trap. Nothing in your metrics flags it.

Silent disengagement

The address works, the person is alive, and they stopped caring two years ago. Technically deliverable, practically dead, and actively harmful: mailbox providers weight recent engagement heavily, so a large block of non-openers drags placement down for everyone else on your list.

No verifier catches this one. Only your own engagement data does.

What makes your rate worse than average

• B2B over consumer. Work addresses die with jobs.
• High-turnover industries. Agencies, hospitality, startups, sales – faster churn, faster decay.
• Infrequent sending. Mail quarterly and you discover a year of decay all at once, as one large bounce event.
• No signup verification. Typos and burner addresses enter as permanent dead weight from day one.
• Acquired or inherited lists. You did not see the decay that happened before you owned it.

Measuring your own rate

Do not rely on industry averages. Yours is knowable:

1. Take a segment you verified at a known date.
2. Re-verify the same segment now.
3. The share that changed from valid to invalid, divided by the elapsed months, is your monthly decay rate.

Run that once and you can set a cleaning cadence based on your data rather than someone’s blog post. If you are losing 2% a month, you cross the 2% bounce threshold roughly a month after each clean – which tells you cleaning quarterly is not enough.

Staying ahead of it

• Verify at capture. An API check at the signup form stops bad addresses entering. This is the cheapest intervention available.
• Re-verify on a schedule. Quarterly for most, monthly for high-volume senders, always before an ESP migration.
• Suppress hard bounces automatically and enforce that suppression against every future import.
• Run a sunset policy. No opens or clicks in 12 months goes to re-engagement, then suppression. This is the only defence against the silent-disengagement category, and it is also what keeps you out of recycled traps.
• Re-permission acquired lists before mailing them at volume.

Decay is not a failure of your marketing. It is the normal condition of any list, and the only question is whether you find the dead addresses before your bounce rate announces them to Gmail.

Re-verify on a schedule: 250,000 emails for $100, one million for $350. Start with 100 free credits.

Short answer: you verify an email address without sending to it by checking its format, confirming the domain has mail servers, and opening an SMTP connection to ask the receiving server whether the mailbox exists – then disconnecting before any message is transmitted. Nothing arrives in the recipient’s inbox and no bounce is recorded against your sending reputation.

Why not just send a test email?

Because a bounce is permanent. When you send to a dead address, the receiving server records the failure and your mailbox provider counts it against you. Do that across a list and you have told Gmail, in the only language it reads, that you mail addresses you have not checked.

A verification check produces the same information as a private lookup nobody grades you on. Same answer, no consequence.

The four methods, weakest to strongest

1. Syntax check

Confirm the address is structurally legal – one @ symbol, no illegal characters or spaces, a plausible top-level domain, within length limits. Free, instant, no network call.

Catches: typing mistakes and junk entries. Misses: everything else. definitely.not.real@gmail.com passes.

2. Domain and MX record lookup

Query DNS for the domain’s MX records. No MX records means the domain is not configured to receive mail at any address. One cheap DNS query.

Catches: expired domains, invented domains, abandoned company domains. Misses: any dead mailbox on a live domain, which is most of the problem.

3. SMTP handshake

The real check. Connect to the domain’s mail server on port 25 and begin the conversation a sending server would have – identify yourself, state the sender, then state the recipient. The server responds with a code indicating whether it will accept mail for that mailbox. Disconnect there. No message body is ever sent.

Catches: non-existent mailboxes on live domains. Misses: nothing definitive – but two things get in the way in practice:

• Catch-all domains accept every address, so the answer is always yes and tells you nothing.
• Throttling. Major providers rate-limit or block repeated checks from one source. Run this from a single server against a list of any size and you will be blocked within minutes, and your results will be mostly unknowns.

That second point is why do-it-yourself scripts do not scale. It is not a coding problem, it is an IP reputation problem.

4. A verification service

Runs all three above across a distributed pool of IPs with managed pacing, and adds the checks you cannot perform yourself: spam trap pattern detection, disposable-domain databases maintained continuously, role-address identification, and typo correction that recovers gmial.com as a real subscriber rather than discarding it.

Checking one address by hand

For a single address you genuinely care about, the fastest reliable route is a free tier from a verification provider – most give 100 credits, no card. Beyond that:

• Check whether the domain resolves and has MX records.
• Compare the address pattern against other known addresses at the same company. If everyone is first.last@ and yours is flast@, be suspicious.
• Confirm through another channel for anything high-value. A verifier tells you a mailbox exists, not that the person still works there.

What verification cannot tell you

That the person wants your email. A perfectly valid address can still generate a spam complaint, and complaints damage you more than bounces – Google requires bulk senders to stay under 0.1% and never touch 0.3%. Verification confirms deliverability. Consent is a separate problem, and no tool solves it.

Verify without sending: syntax, MX, live SMTP check, trap and disposable detection, at up to 10,000 addresses a minute. Start with 100 free credits.

Short answer: cleaning an email list costs between $0.35 and $8 per 1,000 addresses depending on volume and provider. A 50,000-address list runs roughly $20 to $275. A one-million-address list runs $350 to $3,199. Rates fall steeply as volume rises, so the per-address price at 5,000 tells you nothing about the price at 500,000.

Cost by list size

List size	EmailListClean	Typical market range
50,000	Included in 250K tier	$75 – $275
100,000	Included in 250K tier	$135 – $500
250,000	$100	$750 – $1,299
500,000	$180	$450 – $2,199
1,000,000	$350	$449 – $3,199
2,000,000	$720	$1,300 and up

Market ranges reflect published rates from nine providers in September 2026. The full pricing comparison has the per-provider detail.

What changes the number

• Volume. The dominant factor. ZeroBounce charges $19.50 per 1,000 at 2,000 credits and $3.20 per 1,000 at a million – the same check.
• Duplicates. You pay per address submitted. Deduplicating before upload is free money.
• Catch-all billing. Most providers do not charge for results they cannot resolve. DeBounce bills catch-alls at 10 credits each, which on a B2B list can triple the effective cost.
• Subscription vs one-off. Monthly plans only beat pay-as-you-go if you use the full allowance every month. Cleaning is usually quarterly work.
• Credit expiry. NeverBounce credits expire after 12 months. A volume discount you cannot use is not a discount.

Does it pay for itself?

Work it out directly rather than taking it on faith. Take a 250,000-address list that has never been verified, where 15% is dead – a normal figure.

• Cleaning cost: $100, once.
• Wasted sends avoided: 37,500 messages per campaign. At a typical ESP rate that is real money on every send, forever.
• ESP tier: most platforms price on contact count. Removing 37,500 contacts may drop you a pricing tier on its own.
• The part that actually matters: your bounce rate falls below the 2% line on the next send, and mailbox providers stop reading your sending pattern as evidence you mail a list you do not maintain.

The first three are arithmetic. The fourth is the one that decides whether your campaigns reach the inbox at all, and it has no price tag until it goes wrong.

The cost of not cleaning

Gmail requires bulk senders – anyone approaching 5,000 messages a day to personal Gmail accounts – to keep spam complaint rates under 0.1% and never at or above 0.3%. Microsoft has rejected non-compliant bulk mail outright since May 2025 rather than deferring it.

Bounces feed that machinery. High bounce rates degrade reputation, more mail lands in spam, mail in spam collects complaints at a much higher rate than mail in the inbox, and the complaint rate that gets you throttled follows. Recovering a damaged sender reputation takes weeks of disciplined sending. Cleaning takes an afternoon and a hundred dollars.

How often to spend it

• Quarterly for most senders – budget four cleans a year.
• Monthly for high-volume outbound.
• Before ESP migration, every time.
• Continuously at the signup form via API, which is the cheapest of all because it prevents the problem rather than fixing it.

Transparent pricing, no subscription: 250,000 emails $100, 500,000 $180, one million $350, two million $720. Start with 100 free credits.

Short answer: an email verification API checks a single address in real time – typically in under a second – so you can block bad addresses at the signup form instead of cleaning them out months later. Before integrating, check three things: rate limits on your tier, whether API calls draw from the same credit pool as bulk, and what the API returns for catch-all domains.

Why the API matters more than the bulk pass

A bulk clean is remediation. It fixes the list you have and does nothing about the one you are building. Six months later you are paying to clean the same problem again.

Real-time verification at the point of capture is the prevention. Bad addresses never enter the database, which also means you never deliver the lead magnet to a burner address, never store a typo, and never pay to re-check any of it.

Check these before you build

Rate limits

This is the most common integration surprise. Clearout publishes API limits of 3, 25 and 55 requests per minute depending on tier. Three requests per minute is fine for a low-traffic form and will fall over on a launch day or a paid campaign spike.

Work out your peak minute, not your average, and confirm the limit covers it. Then decide what your form does when the limit is hit – which brings us to the next point.

Failure behaviour

Decide in advance whether the verifier is a gate or an adviser. If the API times out or returns an error, do you reject the signup or accept it?

Almost always: accept, flag the record, and verify it in the next bulk pass. Blocking real signups because a third-party API had a bad thirty seconds costs more than the bad addresses you let through. Set a hard client-side timeout – 2 to 3 seconds – and fail open.

Billing model

Providers differ on whether real-time calls come from the same credits as bulk verification. DeBounce states the API needs no separate credits. Bouncer prices real-time checks as a separate monthly product, priced differently from its bulk credits – at one million checks the real-time product is cheaper per check than the bulk credits, which is not a mistake, they are different services.

Ask directly: does one API call consume one bulk credit, or is it a separate meter?

Catch-all responses

A real-time check against a catch-all domain cannot return a definitive answer, because the server accepts everything. Find out what the API returns in that case and decide what your form does with it.

Rejecting every catch-all address at signup means rejecting a large share of B2B prospects. Accept them, tag them, and segment them when you send.

Where to place the call

• On blur, not on submit. Verify when the user leaves the email field. You get the result before they finish the form, so there is no perceived delay.
• Server-side, not in the browser. A client-side call exposes your API key and can be bypassed. Proxy it through your own endpoint.
• Offer the typo correction. If the engine flags gmial.com, show “did you mean gmail.com?” rather than a hard rejection. That recovers a real subscriber you would otherwise lose silently – the single highest-value thing a signup-form integration does.
• Hard-block disposables. Someone using a burner address to take your lead magnet is not a lead. Reject with a message asking for a permanent address.
• Soft-warn role addresses. “We recommend a personal work address so you do not miss anything” converts a meaningful share of info@ submissions into usable contacts.

What to log

Store the verification status and the date on the record. Three reasons: you can segment on it later, you can measure how much the integration is actually catching, and a status from eighteen months ago tells you which records are due for re-checking. Addresses decay whether or not you mail them.

Real-time verification plus a quarterly bulk pass is the full system. The API keeps the list clean; the bulk pass catches what decayed since.

API and bulk on the same credits: no separate meter, no per-endpoint pricing. Start with 100 free credits or see volume pricing.

Short answer: bulk email verification means uploading a list file and getting it back annotated with a status for every row, rather than checking addresses one at a time. At 10,000 addresses a minute, a one-million-record list finishes in under two hours. The work that decides whether it was worth doing happens after the file comes back.

Before you upload

Verification is billed per address, so every duplicate is money you set on fire. Three steps first:

1. Deduplicate. Lowercase everything first – Sarah@Acme.com and sarah@acme.com are one mailbox. Decide how you treat Gmail dots and plus-addressing, since s.chen@gmail.com and schen+news@gmail.com both land in the same inbox.
2. Keep your columns. Export signup date, source, last open and last click alongside the address. The verifier returns a technical status; those columns are what let you make the judgement calls it cannot.
3. Pull everything, not just the active segment. The damage usually lives in the parts of the database nobody looks at – an old trade show import, a list inherited from a predecessor, a form that never had validation on it.

Throughput and what it depends on

Bulk verification is not CPU-bound. It is bound by how fast receiving mail servers will talk to you. Large providers throttle aggressively, so real throughput depends on how many source IPs the service runs and how well it paces requests across them.

At 10,000 addresses a minute: 250,000 records in roughly 25 minutes, one million in under two hours. A service that is much slower than that is usually working from a thin IP pool, and a thin pool produces a second symptom – a high unknown rate, because throttled checks return no definitive answer.

Watch the unknown percentage in your results. It is the honest measure of engine quality, and you may be re-paying to check those rows later.

What comes back

Status	Typical share	Action
Valid	75-90%	Mail normally
Invalid	5-15%	Delete and suppress permanently
Catch-all / risky	3-25%	Segment, test in small batches
Unknown	1-5%	Retry in a few days, then treat as risky
Disposable / role	1-5%	Delete disposables, judge role addresses by use case

The catch-all share swings hardest by audience. A consumer list dominated by Gmail, Outlook and Yahoo will show almost none. A B2B list built from small-company domains can run 20-30%, and how you handle that segment will matter more than anything else in the file.

Acting on a million-row result

Do not re-upload the cleaned file as a replacement list. Do this instead:

1. Suppress, do not delete. Add every invalid address to a permanent suppression file. Deleting a record means a future import can reintroduce it, and mailing an address a provider already told you does not exist is one of the loudest bad-sender signals there is.
2. Create a catch-all segment and leave it out of your main sends until it has earned its way back in.
3. Layer engagement rules on top. An address can be perfectly deliverable and still be dead weight. No opens in 12 months on a monthly cadence goes to re-engagement, then suppression.
4. Purge by source. If part of the list came from a purchase or a scrape, delete that segment whole. Verification does not make it safe – the traps and complaints survive.
5. Fix capture so you are not repeating this in six months. Real-time API verification on signup forms stops bad addresses entering at all.

When to run a bulk pass

• Quarterly for most senders.
• Monthly if you send several times a week or run high-volume outbound.
• Before any list that has sat untouched for 90 days gets mailed again.
• Before migrating to a new ESP or sending domain. This is the most commonly skipped and most expensive omission – new sending infrastructure has no reputation to spend, and opening with a bounce-heavy send starts you in a hole.

Clean at volume: 250,000 emails for $100, one million for $350, two million for $720. CSV, TXT, TSV or XLSX in, the same columns back with a status on every row. Start with 100 free credits.

Short answer: free email verifiers fall into two groups. Free tiers from paid providers run the full engine on a small allowance – typically 100 credits – and are genuinely useful for testing. Free tools that check unlimited addresses at no cost usually run syntax and MX checks only, which catches the obvious errors and misses the expensive ones.

What a free tool can check without cost

Two of the five verification stages are effectively free to run:

• Syntax and format – pure pattern matching, no network call. Catches a missing @, illegal characters, a broken top-level domain.
• Domain and MX lookup – one cheap DNS query. Catches domains that do not exist or have no mail servers.

Together those remove maybe a third of the bad addresses on a typical list. They will not tell you whether sarah.chen@acmecorp.com exists, because that requires an SMTP conversation with the receiving server.

What costs money, and why

The SMTP mailbox check is the expensive part, for reasons that are structural rather than greedy:

• Receiving servers throttle or block repeated checks from the same source. Running them at scale needs a large pool of IPs and careful pacing.
• Those IPs need their own reputation management. An IP that gets blocklisted stops returning usable results.
• Disposable-domain and spam-trap pattern data has to be maintained continuously. New burner services appear weekly; a static list from last year is close to useless.

That infrastructure is what you are buying. A free unlimited tool is not running it.

Free credits from paid providers

These run the real engine, just on a small allowance. Figures from each provider’s own site, September 2026:

Provider	Free credits	Notes
ZeroBounce	100 per month	Refills monthly
Emailable	250	One-off, no expiry
EmailListClean	100	One-off
Bouncer	100	One-off
Clearout	100	Lifetime, no card
DeBounce	100	No card required
Kickbox	100	One-off
MillionVerifier	100	Help centre cites 500 for business-email signups
NeverBounce	10	Plus free list analysis

ZeroBounce’s monthly refill is the most generous structure here if your ongoing need is genuinely tiny – a hundred addresses a month indefinitely, rather than a hundred once.

Where free stops being free

The cost of a syntax-only clean is not the tool. It is what survives it:

• Dead but well-formed addresses. john.smith@realcompany.com where John left two years ago passes every free check and hard-bounces on send.
• Recycled spam traps. Perfectly valid syntax, real domain, live MX. A free tool will pass one straight through, and a single pristine trap hit can get your domain blocklisted.
• Disposable domains. Real and accepting mail at the moment you check. Detecting them needs a maintained database, not a lookup.
• Role addresses. Valid, monitored, and generating complaints at a much higher rate than personal addresses.

Run the arithmetic before deciding free is cheaper. Cleaning 250,000 addresses properly costs $100. If a free pass leaves 12% of that list undeliverable, you send 30,000 messages into nothing on every campaign, and Gmail reads the resulting bounce rate as evidence you do not maintain your list. The $100 is not the expensive number in that comparison.

When free is the right answer

• Checking a handful of addresses by hand.
• Testing providers before you buy – use the free credits on a control file where you already know the right answers.
• A list under a few thousand addresses that you built yourself with double opt-in and have mailed consistently. Low decay, low risk.

Above that, or on any list you did not build yourself, the free version is a false economy – and no amount of verification makes a purchased list safe to mail.

Try the full engine free: 100 credits, no card. Then 250,000 emails for $100 if it earns it. Start free or see volume pricing.

Short answer: published email verification pricing in September 2026 ranges from about $0.35 to $19.50 per 1,000 addresses. Where you land depends almost entirely on volume – rates fall steeply as you buy more – and on whether the provider bills you for catch-all and unknown results.

Why the same job has a 50x price range

Verification is priced per address, and almost every provider discounts hard at volume. ZeroBounce charges $19.50 per 1,000 for a 2,000-credit purchase and $3.20 per 1,000 at one million – the same engine, the same check, a six-fold difference in rate.

So a headline rate means nothing without the volume attached to it. Compare at the volume you actually intend to buy.

Published rates per 1,000, by volume

Provider	Small buy	100K	1M
EmailListClean	$0.40 (250K)	–	$0.35
MillionVerifier	$1.78 (50K)	$1.49	$0.45
DeBounce	$3.00 (5K)	$1.35	$0.75
Clearout	$8.00 (5K)	$4.00	$1.40
Bouncer	$8.00 (1K)	$4.00	$2.00
Emailable	$7.60 (5K)	$4.20	$2.10
Kickbox	$10.00 (500)	$5.00	$3.00
ZeroBounce	$19.50 (2K)	$6.49	$3.20
NeverBounce	$8.00 (1K)	Quote only	Quote only

All figures read from each provider’s own pricing page in September 2026. EmailListClean’s entry tier is 250,000 emails at $100; it does not sell a 5,000-credit pack, which is why the small-buy column is not directly comparable.

The three things that change your real cost

1. Catch-all and unknown billing

This is the largest hidden variable. A verifier cannot definitively resolve an address on a catch-all domain, and on B2B lists those can be 20-30% of the file.

Most providers do not bill for unknowns. DeBounce charges 10 credits per catch-all validation instead of one. On a 100,000-record B2B list that is 25% catch-all, the effective cost is 325,000 credits – more than three times the headline.

2. Subscription vs pay-as-you-go

Subscription rates look cheaper per 1,000 but only if you use the full monthly allowance. NeverBounce’s Growth plan is $49 a month for up to 10,000 verifications – $4.90 per 1,000 at full usage, $9.80 if you use half. Clearout’s annual Pro plan is $32 a month for 10,000 credits on the same logic.

List cleaning is lumpy work. Most senders clean quarterly, which means a monthly subscription is usually the wrong instrument unless you are verifying continuously at signup.

3. Credit expiry

NeverBounce credits expire 12 months after purchase. Emailable, MillionVerifier and Clearout state their credits do not expire. If you buy at volume for the discount and then use them slowly, expiry converts a discount into a loss.

What a real cleaning job costs

Take a 250,000-address list, a common size for an established sender:

• EmailListClean: $100
• MillionVerifier: roughly $373 at its 100K rate, less at its unpublished 250K tier
• Bouncer: $750
• Emailable: $750
• Kickbox: $1,100
• ZeroBounce: $1,299

Set that against what the list costs you unclean. If 15% of those addresses are dead – a normal figure for a list that has never been verified – you are sending 37,500 messages into nothing on every campaign, and paying your ESP for the privilege while your bounce rate tells Gmail you do not maintain your list.

Questions to ask before buying

• What is the rate at my volume, not the advertised entry rate?
• Am I billed for catch-all results? For unknowns? For duplicates?
• Do credits expire?
• Does the API draw on the same credits, or is it a separate product with its own fee?
• What is the API rate limit on my tier, and will it throttle my signup form?
• Is there a refund or remedy attached to the accuracy guarantee, or is it just a number?

A provider that answers all six plainly on its pricing page is usually the one that will not surprise you on the invoice.

Transparent volume pricing: 250,000 emails for $100, 500,000 for $180, one million for $350, two million for $720. No subscription, no expiry. Start with 100 free credits or see the pricing table.

Short answer: the nine services below all verify email addresses competently. They differ enormously on price – from $0.35 to $3.20 per 1,000 addresses at one-million volume – and on whether they bill you for results they cannot resolve. Choose on cost per usable result and on catch-all billing policy, not on marketing accuracy claims.

Every price below was read from each provider’s own public pricing page in September 2026. Providers change pricing often; check the source before committing to a large purchase.

Price comparison at one million addresses

Provider	1,000,000 emails	Cost per 1,000	Free credits
EmailListClean	$350	$0.35	100
MillionVerifier	$449	$0.45	100
DeBounce	$750	$0.75	100
Clearout	$1,400	$1.40	100
Bouncer	$2,000	$2.00	100
Emailable	$2,100	$2.10	250
Kickbox	$2,999	$3.00	100
ZeroBounce	$3,199	$3.20	100 per month
NeverBounce	Quote only	Not published	10

That is a nine-fold spread between the cheapest and most expensive published rate for the same basic operation. The engines are not nine times better at the top of that range.

The pricing detail most people miss

Headline rates are not what you pay. What matters is how each provider bills results it cannot definitively resolve – catch-all domains and unknowns. On a B2B list, catch-alls can be 20-30% of the file.

• MillionVerifier states you pay only for good and bad results, not for risky, unknown or catch-all.
• Bouncer states it never charges for duplicates or unknown results.
• Emailable refunds duplicates and unknowns.
• Kickbox refunds the credit when it cannot give a definitive result.
• ZeroBounce states it never charges for unknown results; its catch-all policy is not addressed publicly.
• Clearout states in its pricing guide that only definitive results are billable.
• DeBounce is the outlier: catch-all validations are billed at 10 credits each rather than one. On a catch-all-heavy B2B list that changes the effective price substantially.

Read that DeBounce line carefully if you are pricing a B2B file. A 100,000-record list that is 25% catch-all costs 75,000 + 250,000 = 325,000 credits, not 100,000.

Accuracy guarantees, and what they are worth

Only some providers publish a number:

• ZeroBounce – 99.6% validation accuracy guaranteed
• EmailListClean – 99.2% accuracy
• MillionVerifier – 99%+, with money back if hard bounces exceed 4%
• DeBounce – 97.5% or better deliverability rate guarantee
• Clearout – 97% deliverability guarantee on its Safe-to-Send category, with exclusions for educational domains, free providers and Office 365
• Bouncer, Emailable, Kickbox, NeverBounce – no percentage published on their pricing pages

Treat these as marketing figures unless the guarantee has teeth. MillionVerifier’s is the most concrete of the set because it names a bounce threshold and a remedy. A percentage with no stated measurement method and no refund attached is a claim, not a guarantee.

How to actually choose

If you are cleaning a large list once

Buy on price per 1,000 and on catch-all billing. There is no ongoing relationship to protect, and the verification logic is broadly similar across providers. This is where the price spread hurts most – the same one-million-record job ranges from $350 to over $3,000.

If you need real-time verification at signup

All nine offer an API. Check two things the pricing page may hide: whether API calls draw from the same credit pool or are billed separately, and what rate limits apply on your tier. Bouncer prices real-time checks as a separate monthly product. DeBounce states the API needs no separate credits. Clearout publishes per-tier API rate limits of 3, 25 and 55 requests per minute – low limits will throttle a busy signup form.

If you send from a heavily B2B list

Catch-all handling dominates your real cost and your risk. Prefer a provider that does not bill for unresolvable results, and plan to segment catch-alls rather than blindly mailing them regardless of which service you use.

Test before you buy

Every provider here gives free credits. Use them properly rather than as a formality.

1. Build a control file of 100 addresses where you already know the answer – internal mailboxes that exist, addresses you deliberately broke, a known disposable domain, a known catch-all domain, and a role address.
2. Run it through two or three providers.
3. Compare on the edge cases, not the obvious ones. Everyone catches a missing @ symbol. The differences show up on catch-all, role and recently-abandoned addresses.
4. Count how many results come back unknown. A high unknown rate means the engine is being throttled by receiving servers, and you will be paying to re-check them.

What no provider can do is manufacture consent. Verification confirms a mailbox exists; it does not make a purchased list safe to mail. The spam traps and complaints survive the cleaning.

Ready to compare on your own data? EmailListClean verifies up to 10,000 addresses a minute at 99.2% accuracy – 250,000 emails for $100, one million for $350. Start with 100 free credits or see the full volume pricing.