Skip to content

Why emails from B2B data exports bounce, and how to verify them before you sequence

· Updated · 6 min read · Email validation

Emails from B2B data exports bounce for three main reasons: the person left the company since the record was last checked, the address was inferred from the company's naming pattern rather than confirmed, or the domain is catch-all and accepted any address during verification. None of this is specific to one data provider. It's how contact databases work. The fix is the same everywhere: verify the exported list yourself, right before you load it into a sequence, and treat catch-all and unknown results as a separate risk tier.

If you've exported contacts from Apollo, ZoomInfo, Lusha, a Sales Navigator scraper or a list broker, the advice below applies the same way. We're not making claims about any vendor's accuracy; we're describing the mechanics every database has to deal with. If Apollo is your source, the Apollo integration page shows where the check fits in that workflow.

Reason 1: people change jobs and the address dies

A work email exists only as long as the job does. When someone leaves, IT disables or deletes the mailbox, sometimes immediately, sometimes after a forwarding period. The record in the database still shows the old title at the old company until something updates it.

This decay is continuous. Every week a slice of any B2B list goes stale, and the older the last check on a record, the more likely it has died. B2B email list decay covers how fast this happens and how to spot it in your own data.

What you'll see in bounces: 550 5.1.1 style "user unknown" responses (the enhanced status codes are defined in RFC 3463), or mailbox_disabled from a verifier, for addresses that looked perfect on export.

Reason 2: the address was guessed from a pattern

Most companies use a predictable format: first.last@, flast@, first@. If a database knows the person works at the company and knows the company's format, it can produce a likely address without ever confirming that mailbox. That's a reasonable way to fill gaps, and it's often right.

It goes wrong when:

  • The person's name doesn't fit the pattern (a nickname, a hyphenated surname, a second hire with the same name who got jane.smith2@).
  • The company changed formats or domains after a rebrand or acquisition.
  • The person never had a mailbox there at all (contractors, people listed under a parent company).

Whether a given record was confirmed or inferred is not always visible in an export. Some tools label it, some don't. Your own verification step doesn't care either way: it checks what the mail server says now.

Reason 3: catch-all domains hide dead mailboxes

A catch-all domain accepts mail for any address at the SMTP stage. Ask it about jane@, zzz@ or anything@ and it says yes. A verifier can detect that the domain behaves this way (by probing an address that can't exist), but it cannot tell whether the specific mailbox is real.

Catch-all is common in B2B because many mail gateways and security filters are configured to accept everything and sort it out later. So a contact can be "accepted" during verification and still bounce after your message is delivered to the gateway, or vanish without a bounce at all. Catch-all email domains explains detection in detail.

This is why honest verifiers return catch-all as risky, never as valid. pingutil returns status: "risky" with reason: "accept_all" for these.

Reason 4: the domain itself is gone

Less common, but it happens with older records: the company shut down, was acquired and moved everyone to the parent's domain, or let the domain expire. A verifier catches these cheaply, since there's no mail server to talk to (no_domain or no_mx).

What each verification result means for a sequence

Status Typical reason What to do with the contact
valid mailbox_exists Send
invalid mailbox_not_found, mailbox_disabled, no_mx, no_domain Remove; don't retry with this address
risky accept_all Separate small batch, watch bounces, or skip
risky role_based Usually skip for cold outreach (info@, sales@)
risky mailbox_full Skip for now, retry later
unknown greylisted, timeout, blocked Re-verify in a day; don't send blind

The statuses are defined in more depth in email verification statuses explained. The short version: only valid is safe to send at full volume, and unknown means the server wouldn't answer, not that the address is fine.

Verify the export before it reaches your sequencer

The script below reads a CSV exported from any tool, verifies the email column in chunks of 50 through POST /v1/verify/batch, and writes two files: send.csv (valid only) and hold.csv (everything else, with the status and reason appended). Python 3.9+, standard library only.

# verify_export.py
# usage: PINGUTIL_KEY=pk_... python verify_export.py export.csv "Email"
import csv
import json
import os
import sys
import time
import urllib.error
import urllib.request

KEY = os.environ["PINGUTIL_KEY"]
URL = "https://pingutil.com/v1/verify/batch"
CHUNK = 50


def verify_batch(emails):
    body = json.dumps({"emails": emails}).encode()
    for attempt in range(5):
        req = urllib.request.Request(
            URL,
            data=body,
            headers={"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"},
            method="POST",
        )
        try:
            with urllib.request.urlopen(req, timeout=120) as res:
                return json.load(res)["results"]
        except urllib.error.HTTPError as e:
            err = json.loads(e.read() or b"{}")
            if e.code == 429 and err.get("error") == "quota_exceeded":
                raise SystemExit(f"daily verification budget used: {err.get('message')}")
            if e.code == 429 or e.code >= 500:
                wait = err.get("retry_after_seconds") or 2 ** attempt
                print(f"{e.code}, retrying in {wait}s", file=sys.stderr)
                time.sleep(wait)
                continue
            raise
        except (urllib.error.URLError, TimeoutError):
            time.sleep(2 ** attempt)
    raise SystemExit("gave up after 5 attempts")


def main(path, column):
    with open(path, newline="", encoding="utf-8-sig") as f:
        reader = csv.DictReader(f)
        rows = list(reader)
        fields = reader.fieldnames or []
    if column not in fields:
        raise SystemExit(f"column {column!r} not found; columns are {fields}")

    # Deduplicate so you don't pay for the same address twice.
    unique = sorted({r[column].strip().lower() for r in rows if r[column].strip()})
    results = {}
    for i in range(0, len(unique), CHUNK):
        chunk = unique[i : i + CHUNK]
        for email, r in zip(chunk, verify_batch(chunk)):
            results[email] = r
        print(f"{len(results)}/{len(unique)} verified", file=sys.stderr)

    out_fields = fields + ["email_status", "email_reason", "email_score"]
    with open("send.csv", "w", newline="") as send, open("hold.csv", "w", newline="") as hold:
        ws, wh = csv.DictWriter(send, out_fields), csv.DictWriter(hold, out_fields)
        ws.writeheader()
        wh.writeheader()
        counts = {}
        for row in rows:
            r = results.get(row[column].strip().lower())
            status = r["status"] if r else "missing"
            row.update(
                email_status=status,
                email_reason=r["reason"] if r else "",
                email_score=r["score"] if r else "",
            )
            counts[status] = counts.get(status, 0) + 1
            (ws if status == "valid" else wh).writerow(row)
    print(json.dumps(counts), file=sys.stderr)


if __name__ == "__main__":
    main(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "Email")
PINGUTIL_KEY=pk_your_key_here python verify_export.py contacts_export.csv "Email"

Two practical notes. Every address counts toward your account's daily verification budget, so a large export may take more than one day; the script stops cleanly on quota_exceeded. Deduplicating first means each address in the file is checked once, and splitting a big export into daily files keeps reruns cheap. And the batch endpoint takes 50 addresses per call, which is why the script chunks. For a dashboard alternative on small lists, the email verification page accepts CSV uploads.

Handle the catch-all tier on purpose

After verification, a B2B export usually splits into three groups: valid, invalid, and a catch-all pile that's often bigger than you'd like. Options for that pile, from safest to riskiest:

  1. Skip it. You lose reach, you keep your bounce rate predictable.
  2. Find another channel. If the contact matters, LinkedIn or a phone call doesn't care about mail server configuration.
  3. Send a small test batch from a separate sending pool and measure that batch's bounce rate alone. If it's high, stop.
  4. Send at full volume. Don't, unless you've measured that this specific segment behaves.

Reducing cold email bounce rate covers sending-side tactics, and the guide to verifying cold outreach lists has the full pre-send workflow.

Re-verify long sequences

A five-step sequence spread over six weeks is sending to a list that ages the whole time. If a step is more than a few weeks after the original verification, re-verify the contacts still in the sequence before it fires. Cached results within a short window are fine; results from two months ago are not.

The checklist for every export:

  1. Export, then verify within days of the first send.
  2. Remove invalid. Don't re-add those addresses from the next export without re-checking.
  3. Split risky by reason: skip role addresses, quarantine accept_all.
  4. Re-verify unknown the next day.
  5. Re-verify anyone still in the sequence after a few weeks.
  6. Track bounces per export and per segment, so you know which sources and filters produce clean data.

Questions people ask

Why do emails from my B2B database bounce even when they're marked verified?
A verified label reflects a check at one point in time, and work addresses die whenever someone changes jobs. Some addresses are also inferred from a company's naming pattern, and catch-all domains accept any address during a check but may reject or silently drop the real message later. Re-verify close to the send date.
How long before sending should I verify an exported list?
As close to the send as practical, ideally within a few days. For long sequences, re-verify contacts that haven't been emailed in a month or more before each new step.
Should I send to catch-all addresses from a B2B export?
Send to them carefully, if at all. Put catch-all contacts in a separate, smaller batch, watch the bounce rate on that batch alone, and stop if it climbs.