// guide
How to clean an email list before you send a campaign
For marketers, founders and marketing-ops engineers about to send to a list they haven't mailed in a while · Updated · 7 min read
I'm about to send to a list I haven't touched in months and I'm scared the bounces will wreck our sender reputation.
To clean an email list before sending, dedupe it, strip obvious junk, then verify what's left and act on each status: drop invalid, keep valid, and hold risky and unknown for a separate, smaller send. With pingutil you can do this without code by uploading a CSV in the dashboard (50 rows per upload), or with POST /v1/verify/batch (50 addresses per call). Either way, an account on the Free plan verifies 300 addresses a day and 3,000 a month, so the Free plan fits lists in the hundreds today and lists in the low thousands if you start a week or two ahead.
This guide is honest about that budget and shows how to stretch it: pre-screen with the cheaper lookup endpoint, verify only what survives, and verify the riskiest segments first.
What this problem costs you
Sending to a stale list doesn't just waste the messages that bounce:
- Sender reputation. Mailbox providers watch your bounce rate. A send with a lot of hard bounces tells them you don't maintain your list, and that can push your next send, to good addresses, toward spam folders. How invalid emails damage sender reputation explains the mechanics.
- Spam traps. Old addresses that were abandoned and later recycled into traps look valid. Verification won't catch all of them, but a list nobody has cleaned in a year is where they live.
- ESP penalties. Most email platforms have acceptable-bounce thresholds in their terms. Cross them and they may pause your account mid-campaign.
- Paying to send to nobody. Many platforms charge per contact or per send.
Lists decay on their own. People change jobs, companies shut down mail servers, inboxes get closed. B2B email list decay covers why work addresses go stale faster than personal ones.
How pingutil solves it
1. Dedupe and trim the file
Lowercase the email column and remove duplicates before you verify anything. A result for the same address is cached for 30 days, but cached answers still count toward the daily budget, so duplicates waste it. Remove addresses you already know are bad: previous hard bounces, unsubscribes and complaints you'll never mail anyway.
2. Optional: pre-screen with the lookup endpoint
POST /v1/lookup with skip_enrichment: true classifies an address without a mailbox check, and it has its own, larger daily budget (2,000 lookups a day and 30,000 a month per account). Run your list through it first and remove everything where verdict.is_spam is true (disposable domains and machine-generated addresses). Those would come back invalid or risky from verification anyway, so there's no reason to spend verification budget on them.
3a. No code: upload a CSV in the dashboard
Sign in at the dashboard and open the verify section. Drop a CSV or paste addresses. The uploader finds the email column for you (comma, semicolon or tab separated). Limits per upload: 50 rows, 30 columns, cells up to 256 characters.
Progress shows as rows are processed. When it's done, download the file: your original columns come back with verify_status, verify_reason, verify_score, did_you_mean, disposable, free_provider, role_based, catch_all and mx_host appended. Uploads are kept for 30 days.
Fifty rows per upload is fine for a small list or for spot-checking a segment. For a few hundred addresses, the API is less clicking.
3b. With code: the batch API
POST https://pingutil.com/v1/verify/batch takes {"emails": [...]} with up to 50 addresses and returns {"results": [...]} in the same order. The script below handles the daily budget: it stops cleanly on quota_exceeded, saves its place, and picks up from there when you run it again after 00:00 UTC.
4. Split the list by status
Use the decision table below, then send to the valid segment first and watch your bounce numbers before you touch the rest.
Decision table: status and reason to action
status |
reason |
What it means | Action |
|---|---|---|---|
valid |
mailbox_exists |
Server confirmed the mailbox | Send |
invalid |
mailbox_not_found, mailbox_disabled |
Server rejected the mailbox | Remove. Suppress in your ESP |
invalid |
no_domain, no_mx, null_mx |
Domain can't receive mail | Remove |
invalid |
disposable_domain |
Throwaway provider | Remove |
invalid |
invalid_syntax |
Not an email address | Remove, or fix if did_you_mean is set |
risky |
accept_all |
Catch-all domain, server accepts everything | Separate segment, send after the clean send |
risky |
role_based |
info@, sales@ and similar |
Keep if they opted in, else remove |
risky |
randomized_local_part |
Looks machine-generated | Remove unless you know the source |
risky |
mailbox_full |
Exists but over quota | Hold, re-verify next month |
unknown |
greylisted, rate_limited, blocked, timeout |
Server wouldn't answer now | Re-verify in an hour or a day |
unknown |
smtp_unavailable |
Mailbox check didn't run | Domain checks passed; re-verify later |
| any | did_you_mean not null |
Looks like a typo (gmial.com) |
Fix only if you can confirm with the person |
score (0 to 100) is a rough delivery likelihood if you want a single number to sort by. Email verification statuses explained has more on each reason.
Complete example: a resumable list-cleaning script
# clean_list.py (Python 3.9+, pip install requests)
"""usage: python clean_list.py contacts.csv cleaned.csv [email_column]
Verifies in batches of 50, stops on the daily budget, and resumes where it left
off when you run it again (results are kept in a .progress.json file)."""
import csv
import json
import os
import sys
import time
import requests
URL = "https://pingutil.com/v1/verify/batch"
KEY = os.environ["PINGUTIL_KEY"] # pk_live_...
OUT_COLUMNS = ["status", "reason", "score", "did_you_mean"]
src, dst = sys.argv[1], sys.argv[2]
column = sys.argv[3] if len(sys.argv) > 3 else "email"
progress_file = dst + ".progress.json"
with open(src, newline="", encoding="utf-8-sig") as f:
reader = csv.DictReader(f)
fields = list(reader.fieldnames or [])
rows = list(reader)
done = json.load(open(progress_file)) if os.path.exists(progress_file) else {}
todo = sorted({r[column].strip().lower() for r in rows if r.get(column, "").strip()} - done.keys())
print(f"{len(done)} already verified, {len(todo)} to go", file=sys.stderr)
session = requests.Session()
session.headers["Authorization"] = f"Bearer {KEY}"
i = 0
while i < len(todo):
chunk = todo[i : i + 50]
resp = session.post(URL, json={"emails": chunk}, timeout=180)
if resp.status_code == 429:
body = resp.json()
if body.get("error") == "quota_exceeded":
print("daily verification budget used up; run again after 00:00 UTC", file=sys.stderr)
break
time.sleep(float(body.get("retry_after_seconds") or 30))
continue
resp.raise_for_status()
for email, result in zip(chunk, resp.json()["results"]):
done[email] = {k: result.get(k) for k in OUT_COLUMNS}
json.dump(done, open(progress_file, "w"))
i += len(chunk)
print(f"{len(done)} verified", file=sys.stderr)
with open(dst, "w", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=fields + OUT_COLUMNS)
writer.writeheader()
for r in rows:
res = done.get(r.get(column, "").strip().lower(), {})
writer.writerow({**r, **{k: "" if res.get(k) is None else res[k] for k in OUT_COLUMNS}})
print(f"wrote {dst}", file=sys.stderr)
Run it once a day until the "to go" count reaches zero. The output always has every original row; unverified rows just have empty result columns.
One detail: the budget is reserved for the whole batch before any work starts. If you have 20 addresses of budget left and send 50, the call fails with quota_exceeded and nothing is spent. The script stops, and tomorrow's run picks up the same 50.
Planning a larger list
At 300 addresses a day, a 1,500-address list takes five days and a 3,000-address list takes ten. That's fine if you plan for it:
- Start early. Kick off verification a week or two before the send date.
- Verify the oldest segment first. Contacts who haven't opened in a year are most likely to bounce. Recent, engaged subscribers are lower risk and can wait.
- Pre-screen with lookups (step 2) so the verification budget goes only to addresses that might be real.
- Send in waves. Send to each day's
validresults as they come in, rather than waiting for the whole file.
If you routinely need to verify tens of thousands of addresses in one sitting, the Free plan's budget won't fit that job; Enterprise has custom limits and onboarding help. Be realistic about it before you commit to a send date.
Edge cases and limits
- Catch-all domains can't be confirmed. When a server accepts every address, there's no way to tell real mailboxes from fake ones by SMTP. They come back
risky/accept_all, nevervalid. Yahoo and some other providers behave like this. See catch-all email domains. - Some servers refuse to answer. Greylisting, rate limits and blocks produce
unknown. Those answers are cached for one hour, so re-running later gets a fresh attempt. - Heavy concentration on one domain. Mailbox checks to any single company domain are also limited per day to protect the checking server's reputation. A list where hundreds of addresses share one company domain may see some come back
unknown/smtp_unavailable; re-run them the next day. - Spam traps aren't detectable this way. A recycled trap address looks like a valid mailbox. Verification lowers the risk; it doesn't remove it. Removing contacts who haven't engaged in a long time is the usual complement.
- No webhooks, no background jobs from the API. The batch call is synchronous. Your script waits for each batch, which can take a while when servers are slow; the timeout above is generous for that reason.
Next step
Sign in at the dashboard to upload your first 50 rows, or create an API key there and run the script. Request and response fields for both verify endpoints are in the API reference, and you can test a single address in the verification demo. For lists you're about to sequence for sales outreach, verifying cold outreach lists covers the extra checks that matter there.
Questions people ask
- How do I clean an email list before sending?
- Remove duplicates and obvious junk first, then run the rest through an email verification service. Drop invalid addresses, keep valid ones, and decide on risky and unknown ones by segment. Send to the cleanest segment first and watch bounces before sending to the rest.
- Should I delete risky and unknown addresses?
- Not automatically. Risky usually means a catch-all domain where the server accepts every address, and unknown means the server wouldn't answer. Both can be real people. Send to them separately, in smaller batches, after the clean segment has gone out.
- How many addresses can I verify with pingutil per day?
- On the Free plan each account can verify 300 addresses a day and 3,000 a month, shared between the dashboard CSV upload and the verify API. The budget resets at 00:00 UTC. A list of a few thousand addresses therefore takes several days, so start well before the send date.