Skip to content

How to reduce your cold email bounce rate

· 6 min read · Email validation

To reduce your cold email bounce rate, verify every address right before it enters a sequence (not when you exported it), remove invalid results, send to confirmed addresses first, put catch-all and unknown addresses in a small capped segment that only goes out after the main list runs clean, and ramp sending volume per mailbox instead of launching at full speed. Most outbound bounces come from three things: stale work addresses, guessed address patterns, and catch-all domains sent at the same volume as confirmed ones. Each has a specific fix.

Where cold email bounces actually come from

Before changing anything, sort last campaign's bounces by cause. The fix depends on which bucket is biggest.

Source of bounces How to spot it Fix
People who left the company 5.1.1 at companies you've emailed successfully before Verify close to send; re-verify aged contacts
Guessed addresses (first.last@ patterns) Bounces cluster at one domain with several names Verify; never send unverified guesses
Catch-all domains Verifier said accept_all; bounce arrived later Cap them; send last
Dead domains no_domain, null_mx, 5.1.2, 5.4.4 Verification catches these; drop the domain
Policy blocks 5.7.x codes Not a list problem. Fix authentication and reputation.

If you're not sure how to read the codes, SMTP bounce codes explained has the tables. If a large share are 5.7.x, stop reading this and fix your sending setup; Gmail and Yahoo bulk sender requirements covers authentication.

Verify right before sequencing, not at export

Most teams verify once, when they pull the list. Then the list sits in a spreadsheet for two weeks, gets enriched, gets reviewed, and finally goes into the sequencer. Every day in between, some of those people change jobs. B2B email list decay explains why work addresses go stale faster than personal ones.

Make verification the last step before import:

  1. Build and review the list as usual.
  2. On the day you import, verify every address.
  3. Import only what passed, in the segments described below.
  4. For multi-step sequences that run for weeks, re-verify before adding contacts to a later wave.

Data providers often include their own "verified" flag. Treat it as a hint about when they last checked, not a current result. Re-verify anyway.

Split results into segments that send in order

Verification gives you four statuses. For outbound, each one goes somewhere different:

Status Typical reasons Segment
valid mailbox_exists Main sequence, sends first
invalid mailbox_not_found, no_domain, no_mx, null_mx, mailbox_disabled, disposable_domain Remove and add to suppression
risky accept_all Capped catch-all segment, sends after main runs clean
risky role_based (info@, sales@) Usually remove from cold outreach
risky mailbox_full Hold; re-verify next week
unknown greylisted, rate_limited, blocked, timeout Re-verify in an hour or two, then re-sort

The important part is the order. Your main sequence should go out first and run for a few days. If its bounce rate is low, add the catch-all segment at a fraction of daily volume. If the catch-all segment bounces, you'll see it in a small batch rather than across your whole send.

Handle catch-all domains with a cap, not a blanket rule

A catch-all domain accepts every recipient when a verifier asks, so the verifier can't tell you whether jane@ exists. These domains are common among small and mid-sized companies on custom domains, which is exactly who many outbound teams target. Catch-all email domains explains why.

Deleting every catch-all address throws away real prospects. Sending them at full volume risks a bounce spike. A middle path:

  • Prefer catch-all addresses you have a second reason to trust: found on the company's own site, confirmed by a reply in a previous campaign, or provided by the prospect.
  • Cap the share. Pick a ceiling for catch-all sends per mailbox per day. Choose it from your own bounce data; there is no universal right number.
  • Drop domains that bounce. If one address at a catch-all domain hard-bounces later, the domain accepts-then-rejects. Treat other guesses at that domain as suspect.

Re-check aged data before every new wave

Contacts that were verified for an earlier campaign are not verified for this one. A reasonable rule: if a result is older than the time it takes your list to go stale, re-verify. pingutil caches definitive results for 30 days, so re-running a verify within that window returns the cached answer (cached: true in the response) and the original checked_at. Use checked_at to decide whether a result is fresh enough for your purpose.

Ramp sending volume per mailbox

Even a perfectly clean list can produce soft bounces and deferrals if a new mailbox or domain suddenly sends hundreds of messages a day. Mailbox providers throttle senders they don't know yet, and those 421 and 4.7.x deferrals show up as soft bounces in your sequencer.

  • Start each new sending mailbox at a low daily volume and increase it gradually over weeks.
  • Spread volume across mailboxes rather than pushing one hard.
  • If deferrals rise, slow down. Gmail's email sender guidelines say that if messages start bouncing or being deferred, reduce the sending volume until the SMTP error rate decreases.

Ramping doesn't fix a bad list. It stops a good list from looking like a bad one.

A batch verification script that writes segments

This Node.js 18+ script reads one address per line, verifies in chunks of 50 with POST /v1/verify/batch, and writes one file per segment, ready to import. It stops cleanly if the account's daily verification budget runs out.

// segment-list.mjs
// usage: node segment-list.mjs prospects.txt
import { readFile, writeFile } from 'node:fs/promises';

const KEY = process.env.PINGUTIL_KEY;
if (!KEY) throw new Error('set PINGUTIL_KEY');
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

function segmentOf(r) {
  if (r.status === 'valid') return 'main';
  if (r.status === 'invalid') return 'suppress';
  if (r.status === 'unknown') return 'recheck';
  if (r.reason === 'accept_all') return 'catch_all';
  if (r.reason === 'mailbox_full') return 'recheck';
  return 'review'; // role_based, randomized_local_part
}

async function verifyChunk(emails, attempt = 0) {
  const res = await fetch('https://pingutil.com/v1/verify/batch', {
    method: 'POST',
    headers: { authorization: `Bearer ${KEY}`, 'content-type': 'application/json' },
    body: JSON.stringify({ emails }),
    signal: AbortSignal.timeout(120_000),
  });
  if (res.status === 429) {
    const body = await res.json().catch(() => ({}));
    if (body.error === 'quota_exceeded') return null; // daily budget used up
    if (attempt >= 5) throw new Error('still rate limited after retries');
    await sleep((body.retry_after_seconds ?? 2 ** attempt) * 1000);
    return verifyChunk(emails, attempt + 1);
  }
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  return (await res.json()).results;
}

const emails = [...new Set(
  (await readFile(process.argv[2], 'utf8'))
    .split(/\r?\n/).map((s) => s.trim().toLowerCase()).filter(Boolean),
)];

const segments = { main: [], catch_all: [], recheck: [], review: [], suppress: [] };
let done = 0;
for (let i = 0; i < emails.length; i += 50) {
  const results = await verifyChunk(emails.slice(i, i + 50));
  if (!results) { console.warn(`quota reached after ${done} addresses`); break; }
  for (const r of results) {
    segments[segmentOf(r)].push([r.input, r.status, r.reason, r.did_you_mean ?? ''].join(','));
  }
  done += results.length;
}

for (const [name, rows] of Object.entries(segments)) {
  await writeFile(`${name}.csv`, ['email,status,reason,did_you_mean', ...rows].join('\n') + '\n');
  console.log(`${name}.csv  ${rows.length}`);
}
export PINGUTIL_KEY=pk_live_...
node segment-list.mjs prospects.txt

Import main.csv first. Hold catch_all.csv until the main sequence has run for a few days. Run recheck.csv through the script again later. Add suppress.csv to your sequencer's do-not-contact list so the addresses don't sneak back in with the next export.

Verification counts against the account's daily budget, so very large lists take more than one day or need the dashboard CSV upload split across days. The full request and response shapes are in the API reference. If you'd rather see the workflow from the sales-ops side, verify emails before cold outreach and how to clean a lead list before sequencing cover the same ground without code.

What verification won't fix

Be honest with yourself about the limits. Verification can't confirm mailboxes on catch-all domains or servers that refuse to answer, and it can't detect spam traps reliably (spam traps and list hygiene explains why). Some servers accept at check time and bounce later. A low bounce rate also says nothing about spam complaints, which come from who you're emailing and what you say.

Before the next campaign

  • Verify the day you import, not the day you export.
  • Send valid first. Hold catch-all until the main segment runs clean, then cap it.
  • Re-verify unknown results within a few hours; re-verify anything older than your list's decay window.
  • Suppress every invalid result and every hard bounce, in every tool that sends.
  • Ramp new mailboxes slowly and back off when deferrals rise.

Questions people ask

Why is my cold email bounce rate so high?
Usually because the list was never verified, was verified weeks before sending, or includes guessed addresses and catch-all domains sent at full volume. Work addresses also decay as people change jobs, so data from a provider export can be stale on arrival.
Should I send cold emails to catch-all addresses?
Only a small, capped share, and only after the verified addresses have run clean. A catch-all domain accepts every recipient at check time, so a verifier can't confirm the mailbox. Send those last, watch the bounces, and drop the domain if it bounces.
How soon before sending should I verify a cold email list?
As close to the first send as you can, ideally the same day or the day before. A result from a month ago doesn't account for people who left their job since, and outbound lists are mostly work addresses, which go stale fastest.