If you run B2B email and compare your bounce rate to a general benchmark, you will conclude you have a hygiene problem when you may not have one.
Published averages put cross-industry bounce rates somewhere around 1.2% to 2.5% depending on the source, with healthy sending generally considered to be under 2% and strong performance under 1%. But those figures blend B2B and B2C, and the two are not comparable. Industry reporting consistently puts B2B bounce rates roughly 0.7 percentage points above B2C, around 1.6% against 0.9%.
That gap is not because B2B marketers are worse at hygiene. It is because professional contact data decays faster than consumer data. People change jobs, companies restructure, and a work address dies the day someone leaves. Consumer addresses persist for years.
So the first useful thing to know is that your target is not the general benchmark. It is a hard bounce rate under 0.5%, which is achievable with verification in place, and a total bounce rate under 2%.
This post covers where bounces actually come from, ranked by how much they contribute, and which fixes move the number.
Hard and soft bounces are different problems
Lumping them together is why most bounce-reduction efforts stall.
Hard bounces are permanent. The mailbox does not exist, the domain does not exist, or the server has permanently rejected delivery. The address will never work. These are a data quality problem.
Soft bounces are temporary. The mailbox is full, the server is down, the message is too large, or you are being throttled or greylisted. The address may work tomorrow. These are an infrastructure and reputation problem.
The distinction matters because the fixes are unrelated. Verification reduces hard bounces and does nothing for soft ones. Authentication and sending discipline reduce soft bounces and do nothing for hard ones. A team that verifies aggressively and still has rising soft bounces has been solving the wrong problem for a quarter.
A practical rule: track them as separate metrics on separate charts. If you only have one bounce number, you cannot tell which problem you have.
| Performance | Hard bounce | Total bounce |
|---|---|---|
| Excellent | under 0.3% | under 1% |
| Healthy | under 0.5% | 1% to 2% |
| Acceptable | 0.5% to 1% | 2% to 3% |
| Needs attention | over 1% | over 3% |
| Serious | over 2% | over 5% |
Six causes, ranked by contribution
In rough order of how much they actually account for in B2B programs.
1. Data decay
The largest single contributor and the one most often misattributed to list sourcing.
Work email is tied to employment. The moment someone leaves, the address starts dying, usually immediately but sometimes after a forwarding period. Published estimates put roughly 30% of professional contacts in a new role each year, which means a list you built twelve months ago has lost a substantial share of its addresses through no fault of anyone.
This is why a CRM that has not been touched in a year can bounce at 6% to 8% on first send while a verified list from the same source bounces under 2%. The addresses were fine when they were captured.
The fix is not a one-time clean. It is a refresh cadence matched to how fast each field decays, which is covered in CRM data decay.
2. Catch-all domains treated as valid
The second largest contributor and the most invisible, because these addresses pass verification looking clean.
Industry analysis suggests roughly 23% to 31% of B2B email databases consist of catch-all addresses that standard verifiers return as valid but which carry real bounce risk. That is a quarter to a third of a typical B2B list sitting in a category most tools round up to "deliverable."
A catch-all domain accepts mail for every address whether or not the mailbox exists, so the server says yes, your sending tool records a delivery, and the bounce arrives days later through a different path. By the time it shows in your reporting, it is detached from the campaign that caused it.
This is also why healthcare consistently reports the worst bounce rates of any B2B sector, around 5.9% total: high practitioner mobility combined with widespread catch-all institutional domains. Both causes at once.
The complete treatment, including corroboration strategies, is in catch-all email domains.
3. Pattern-guessed addresses
Addresses constructed by applying first.last@ to a name, then sent to without verification.
On a normal domain a wrong guess bounces immediately and you learn. On a catch-all domain it never bounces visibly and you keep using the pattern. Either way the practice generates bounces at a rate no other acquisition method matches.
Guessing is a reasonable way to produce a candidate. It is not a way to produce an address you send to. The method comparison is in how to find a work email address.
4. Authentication failures
This one causes soft bounces and spam placement rather than hard bounces, and it is frequently the real cause when a bounce rate rises without the list changing.
Three records need to be correct:
SPF lists which servers may send on behalf of your domain. DKIM cryptographically signs your mail so the receiver can confirm it was not altered. DMARC tells receivers what to do when SPF or DKIM fails, and gives you reporting.
Major mailbox providers tightened enforcement of these significantly for bulk senders, and mail that would have been delivered a few years ago is now rejected or filtered. If your bounce rate rose and your list did not change, check authentication before you touch the list.
This is worth auditing even if everything looks fine, because the failure mode is silent and the records drift when someone adds a new sending tool.
5. Spam traps
Addresses that were real, were abandoned, and have been reactivated by mailbox providers specifically to identify senders who are not maintaining their lists.
They do not bounce. They accept mail and quietly damage your reputation. The only defense is list hygiene, because a trap is by definition an address that has been dead long enough to be repurposed. Old purchased lists are the highest-risk source.
6. Role accounts and typos
The smallest contributors, but easy to eliminate.
Role accounts like info@ and support@ are queues rather than people. They do not usually bounce, but they drag engagement down and are more likely to mark mail as spam. Typos from form input bounce immediately and should be caught at the point of capture rather than at send time.
The fixes, in order of impact
Verify before every campaign, not once a quarter. The single highest-return action. A verification pass on a list that has been sitting for months typically pulls a 6% to 8% raw bounce rate back under 2%. The gap between verifying monthly and verifying before each send is small; the gap between verifying and not verifying is enormous.
Segment catch-all separately. Costs nothing, contains the damage. If a quarter to a third of your list is catch-all and you treat it as clean, you have no way to tell whether a rising bounce rate is a data problem or a sending problem.
Fix authentication once, audit quarterly. SPF, DKIM and DMARC. This is a one-afternoon job that stops a whole class of delivery failure, and the records drift as teams add tools.
Suppress hard bounces permanently and immediately. A hard bounce is a final answer. Sending to the same address again is a reputation cost with a guaranteed zero return, and automated suppression on first hard bounce should be non-negotiable.
Set a refresh cadence by field. Email decays faster than company or industry data, so refreshing everything on one annual cycle means you over-refresh stable fields and under-refresh the one that actually bounces.
Validate at the point of capture. A typo caught in a form costs nothing. The same typo caught at send time costs a bounce and sits in your database until someone cleans it.
Warm up new sending domains and ramp volume. Sending 10,000 messages from a cold domain on day one produces throttling and soft bounces regardless of list quality.
Verifying programmatically
For anything beyond a small list, this runs as a batch rather than per address.
1from renidly import Renidly
2
3renidly = Renidly() # reads RENIDLY_API_KEY from the environment
4
5job = renidly.emails.verify_batch([r.email for r in rows])
6
7for row in job.stream():
8 persist(row.matched_input, row)If your stack is Node, the same pattern with async iteration:
1import { Renidly } from "renidly";
2
3const renidly = new Renidly();
4
5const job = await renidly.emails.verifyBatch(rows.map((r) => r.email));
6
7for await (const row of job.stream()) {
8 await persist(row.matched_input, row);
9}Streaming rather than waiting means a failure partway through does not discard completed work, and matched_input ties each result back to exactly what you submitted. The resumability patterns for larger jobs are in batch enrichment at scale.
The routing is where bounce reduction actually happens, and it branches on more than a boolean:
1def route(check) -> str:
2 if check.reason in ("mailbox_rejected", "no_mx", "invalid_syntax"):
3 return "suppress_permanent" # these are your hard bounces
4 if check.reason in ("disposable", "relay"):
5 return "suppress_outreach"
6 if check.catch_all:
7 return "catch_all_segment" # separate subdomain, separate monitoring
8 if check.reason == "risky":
9 return "low_volume_segment"
10 return "main_list"Note that catch_all is read as its own field rather than folded into the deliverable verdict. That single branch is the difference between a list that looks clean and one that is. The full verdict model is in the email verification API guide, and you can check an individual address in the free email verifier to see how the verdicts differ in practice.
The step after verification
Verification confirms an address can receive mail. It does not confirm the person still works there.
On a normal domain those converge eventually, because a deactivated mailbox starts rejecting. On a catch-all domain they never converge: mail is accepted indefinitely for someone who left months ago, your delivery rate looks perfect, and nobody reads any of it.
So for B2B specifically, employment confirmation is part of bounce management rather than a separate concern. If someone changed jobs, the old address is either already bouncing or about to, and knowing in advance lets you suppress it before it costs you anything. The monitoring pattern is in job change signals, and the free job change detector will check a single person.
Measure it properly
Four numbers, tracked separately. Most teams track one and cannot diagnose anything.
| Metric | Why separately |
|---|---|
| Hard bounce rate | Data quality. Should be under 0.5% |
| Soft bounce rate | Infrastructure and reputation. Rises before hard bounces do |
| Catch-all segment bounce rate | Tells you whether corroboration is working |
| Confirmed segment bounce rate | Your actual list quality, undistorted by catch-all |
Watch soft bounces as an early warning. Reputation problems usually show up there first, weeks before anything appears in your hard bounce number or your open rate.
And watch the two segments separately. A blended 2.5% could be a healthy confirmed segment plus a badly behaved catch-all segment, or a uniformly mediocre list. Those need completely different responses and the blended number cannot distinguish them.
The broader approach to measuring data vendors on outcomes rather than claims is in how to evaluate a B2B data provider.
What not to do
Do not buy a list. The bounce rate is the smallest problem. Purchased lists concentrate spam traps, and traps damage reputation without ever bouncing, so you cannot detect the harm by watching your bounce rate.
Do not delete catch-all addresses. They cluster at larger organizations, which are usually the accounts you most want. Segment rather than delete.
Do not re-send to hard bounces. Ever. Some sequencing tools retry by default; turn that off.
Do not chase the benchmark instead of the trend. Your own bounce rate last month is a far more useful comparison than an industry average built from a different mix of industries and list ages.
Do not verify once and consider it solved. Verification is a snapshot with a shelf life of months, not a permanent property of an address.
Frequently asked questions
What is a good email bounce rate?
Under 2% total is healthy and under 1% is strong. For hard bounces specifically, under 0.5% is the achievable target with verification in place.
Why is my B2B bounce rate higher than the benchmark?
Most published benchmarks blend B2B and B2C. B2B runs roughly 0.7 percentage points higher because professional data decays faster, so compare against B2B-specific figures.
What is the difference between a hard and a soft bounce?
A hard bounce is permanent, meaning the address does not exist. A soft bounce is temporary, such as a full mailbox or a throttling server. They have different causes and different fixes.
Does verification eliminate bounces?
It substantially reduces hard bounces and does nothing for soft bounces. It also cannot confirm mailboxes on catch-all domains, which is why those need separate handling.
How often should I verify my list?
Before each campaign for cold or aged lists. Monthly is reasonable for actively maintained ones. Results have a shelf life measured in months.
Can a high bounce rate get my domain blocked?
Sustained high bounce rates degrade sender reputation, which suppresses delivery of your good mail before anything is formally blocked. The damage shows up as declining inbox placement rather than as an obvious block.
The one-line version
Separate hard bounces from soft ones, because one is a data problem and one is an infrastructure problem and the fixes do not overlap. Verify before sending rather than quarterly. Treat catch-all as its own segment, since it is a quarter to a third of a typical B2B list and the one category that bounces invisibly. Fix SPF, DKIM and DMARC once. And compare against your own trend rather than a blended benchmark that includes consumer email.
The reason B2B bounce rates run high is decay, not carelessness. Which means the durable fix is a refresh cadence, not a one-time cleanup.
If you want to see where your own list sits, the free email verifier checks individual addresses with no signup, and the full set of free tools covers lookup and finding too. For list-scale work, the Email API returns the catch-all flag as its own field, and the Quickstart takes about five minutes.
