Skip to content

// guide

Verify a prospect list before it goes into a cold sequence

For sDRs, outbound agencies and RevOps engineers who load prospect lists into sequencing tools · Updated · 7 min read

I bought or scraped a list, loaded it into my sequencer, and the first step bounced so hard my sending domain got flagged.

Verify every prospect address before it enters a cold sequence, then load only the valid ones into your main campaign. pingutil's /v1/verify/batch endpoint checks up to 50 addresses per call (syntax, disposable domain, DNS/MX, an SMTP RCPT TO and a catch-all probe) and returns valid, invalid, risky or unknown for each. Drop invalid, hold risky and unknown in a separate low-volume segment, and you stop the first step of the sequence from being the one that hurts your domain.

This guide is for anyone loading prospect data from a vendor, a scraper, an enrichment tool or a trade-show export into a sequencer. The data is cold, nobody opted in, and no confirmation email will filter the bad rows for you.

What this problem costs you

A cold list goes stale quietly. People change jobs, companies rename domains, data vendors guess at address formats (first.last@, flast@) and ship the guesses as if they were confirmed. You find out which rows were wrong when the sequencer reports bounces.

That's the expensive moment. Mailbox providers watch how a sender behaves, and a burst of mail to addresses that don't exist looks like the behaviour of a spammer working from a bought list. The consequences pile up in a specific order:

  • Step one bounces. The sequencer may auto-pause the campaign, or worse, keep sending.
  • Your sending domain picks up a bad reputation. Later mail, including replies to warm prospects and mail from your teammates on the same domain, lands in spam more often.
  • Reps waste time. Every non-existent contact is a slot in a sequence that could have gone to a real person, and a row someone has to clean up in the CRM.
  • You lose the signal. When a campaign underperforms, you can't tell if the message failed or the list did.

Each of these is worse than the cost of checking first. We cover the reputation side in more depth in the cost of bad emails in outbound.

How pingutil solves it

  1. Get an API key. Sign in at the dashboard with a passwordless link and create a key. It's shown once, so put it in your secret store straight away.
  2. Dedupe the list before you spend checks. Lowercase the address, trim whitespace, drop exact duplicates. Every address you send counts toward the account's 300 verifications a day, including repeats.
  3. Pick a path by list size.
    • Up to 50 rows and no code: upload the CSV on the dashboard. It takes up to 50 rows and 30 columns, lets you pick the email column, and gives you back your original file with result columns appended.
    • Anything larger, or anything you want to automate: call POST /v1/verify/batch with up to 50 addresses per request.
  4. Sort the results into buckets using the decision table below.
  5. Re-check unknown later. Greylisting and temporary blocks clear up. Run those addresses again an hour or more later.
  6. Load the buckets separately. valid goes into the main sequence. risky goes into a throttled sequence or a hold list. invalid goes into your suppression list so nobody re-imports it next quarter.

The 300-a-day budget changes how you plan

At the Free plan's 300 addresses a day (3,000 a month) per account, a 2,000-row list takes about a week; Enterprise has custom limits. Don't verify the whole list in one go and then start sending. Verify the accounts you plan to work this week, send to those, and verify the next tranche tomorrow. Verification results also age, so checking close to send time gives you better answers anyway.

Decision table: what to do with each result

Field and value What it means Action in your outbound workflow
status: valid, reason: mailbox_exists The server accepted the address and rejected a random address on the same domain Load into the main sequence
status: invalid, reason: mailbox_not_found or mailbox_disabled The server said this mailbox doesn't exist or is turned off Remove and add to suppression
status: invalid, reason: no_domain, no_mx or null_mx The domain doesn't exist or can't receive mail Remove. Check if the company moved domains before you discard the account
status: invalid, reason: disposable_domain Throwaway inbox domain Remove. It's not a prospect
status: risky, reason: accept_all Catch-all domain: the server accepts any address, so the check can't confirm this one Separate low-volume segment, send after the valid segment is clean
status: risky, reason: role_based info@, sales@, support@ and similar Usually skip. If you keep it, use a different message aimed at a shared inbox
status: risky, reason: mailbox_full Mailbox exists but is over quota Hold. Often abandoned. Re-check in a few weeks
status: risky, reason: randomized_local_part The local part looks machine-generated Skip. Real prospects rarely have addresses like this
status: unknown (greylisted, blocked, rate_limited, timeout, ...) The server wouldn't give a definitive answer Re-check in an hour or more, then treat leftovers like accept_all
did_you_mean is not null The domain looks like a typo of a major provider Fix only if you can confirm the intended address. Don't auto-correct
checks.free_provider: true Personal webmail address on a B2B list Deprioritize, or route to a different play

score (0 to 100) is a confidence that a message would reach a person. It's useful for sorting the risky segment so the strongest catch-all contacts go first. Don't treat it as a replacement for status.

Catch-all needs a decision, not a guess

A catch-all domain accepts every address during the SMTP conversation and decides later. No verifier can see past that, and pingutil never reports a catch-all address as valid. Many mid-size and large companies run catch-all gateways, so on B2B lists this bucket can be large. We explain the mechanics in catch-all email domains.

What we'd do: send the catch-all segment in small batches, only after the valid segment went out without problems, and watch bounces per batch. For high-value accounts, look for a second signal first (a matching profile, a reply from a colleague, an address format confirmed by someone at the company).

Complete script: verify a CSV in batches of 50

This Python script reads a CSV with an email column, dedupes it, verifies in batches of 50, waits on rate limits, stops cleanly when the daily budget runs out, and writes one CSV per bucket. Re-run it the next day with the remaining rows.

import csv
import os
import sys
import time

import requests

API = "https://pingutil.com/v1/verify/batch"
KEY = os.environ["PINGUTIL_KEY"]  # pk_live_...
BATCH = 50


def load_emails(path):
    seen, emails = set(), []
    with open(path, newline="", encoding="utf-8") as f:
        for row in csv.DictReader(f):
            e = (row.get("email") or "").strip().lower()
            if e and e not in seen:
                seen.add(e)
                emails.append(e)
    return emails


def verify_batch(emails):
    while True:
        r = requests.post(
            API,
            headers={"Authorization": f"Bearer {KEY}"},
            json={"emails": emails},
            timeout=120,  # mailbox checks wait on remote servers
        )
        if r.status_code == 200:
            return r.json()["results"]
        body = r.json() if r.headers.get("content-type", "").startswith("application/json") else {}
        if r.status_code == 429 and body.get("error") == "rate_limited":
            time.sleep(body.get("retry_after_seconds", 60))
            continue
        if r.status_code == 429 and body.get("error") == "quota_exceeded":
            return None  # daily budget used; resets 00:00 UTC
        r.raise_for_status()


def bucket(result):
    status, reason = result["status"], result["reason"]
    if status == "valid":
        return "send"
    if status == "invalid":
        return "suppress"
    if status == "unknown":
        return "recheck"
    if reason == "accept_all":
        return "catch_all"
    return "hold"  # role_based, mailbox_full, randomized_local_part


def main(path):
    emails = load_emails(path)
    out = {name: [] for name in ("send", "suppress", "recheck", "catch_all", "hold")}
    done = 0
    for i in range(0, len(emails), BATCH):
        results = verify_batch(emails[i : i + BATCH])
        if results is None:
            print(f"Daily verification budget reached after {done} addresses.")
            break
        for res in results:
            out[bucket(res)].append(res)
        done += len(results)

    for name, rows in out.items():
        with open(f"{name}.csv", "w", newline="", encoding="utf-8") as f:
            w = csv.writer(f)
            w.writerow(["email", "status", "reason", "score", "did_you_mean"])
            for res in sorted(rows, key=lambda x: -x["score"]):
                w.writerow([res["input"], res["status"], res["reason"], res["score"], res["did_you_mean"] or ""])

    remaining = emails[done:]
    with open("remaining.csv", "w", newline="", encoding="utf-8") as f:
        w = csv.writer(f)
        w.writerow(["email"])
        w.writerows([e] for e in remaining)
    print({k: len(v) for k, v in out.items()}, f"remaining={len(remaining)}")


if __name__ == "__main__":
    main(sys.argv[1])

Run it with PINGUTIL_KEY=pk_live_... python verify_list.py prospects.csv. Tomorrow, run it on remaining.csv and on recheck.csv.

A batch is reserved against the daily budget as a whole before any checks run. If you have 20 verifications left and send 50, the whole call gets 429 quota_exceeded. Send a smaller final batch if you want to use the last few.

Edge cases and limits

  • Catch-all and unresponsive servers stay uncertain. Some providers accept everything (Yahoo, for example, comes back risky/accept_all). Corporate gateways sometimes block verification traffic and come back unknown. Those are honest answers, and you still have to choose what to do.
  • A valid result decays. It means the mailbox existed when we checked. Results are cached for 30 days, so re-verify anything older than your comfort window before a new campaign.
  • Verification doesn't check consent or fit. It tells you an address can receive mail, nothing about whether the person wants yours. Your local rules on cold email still apply.
  • Rate limit. 60 requests a minute per account, shared across all keys. With 50 addresses per batch you won't hit it in normal use, but parallel scripts on the same account share it.
  • No webhooks. Batch calls return results synchronously. For a long list, the script above is the pattern: loop, save, resume.
  • Spam traps aren't detectable by SMTP. A recycled trap address looks like a real mailbox. List sourcing still matters.

For the wider workflow around this, including the sequencer side, read clean a lead list before sequencing and the cold outreach use case. If your list also feeds newsletters, clean an email list before sending covers that version.

Next step

Try one address on the email verification demo to see the response, then create an API key on the dashboard and run the script above on this week's prospects. Full request and response schemas are in the API reference.

Questions people ask

Can I send cold email to risky addresses?
You can, but keep them out of the main sequence. Put catch-all and role addresses in a separate, smaller segment, send it only after the valid segment has gone out cleanly, and stop if bounces rise.
How many addresses can I verify with pingutil per day?
On the Free plan each account can verify 300 addresses per UTC day and 3,000 a month, shared between the API and dashboard CSV uploads. The batch endpoint takes up to 50 addresses per call.
Does mailbox verification email the prospect?
No. The check opens an SMTP session with the recipient's mail server, asks whether it would accept the address, and disconnects before any message is sent.