Guide
Bulk Email List Verification Workflow: A Five-Stage Process From Raw CSV to Clean, Suppressed List
By Unlimited Verifier Team ·

Summary
A bulk email list verification workflow is a five-stage process: prepare the file, verify each address (syntax, domain/MX, SMTP), sort results into Valid, Risky and Invalid, act on each bucket, then re-import with suppressions intact. Most failures happen around the tool, not inside it. Common examples are messy CSVs, mailing Risky addresses as if they were Valid, and deleting invalids that later return with the next import.A bulk email list verification workflow is a repeatable five-stage process: prepare the file, verify each address (syntax, domain/MX, SMTP mailbox), sort results into Valid, Risky and Invalid, act on each bucket, then re-import the cleaned list with suppressions intact.
The individual checks are not where most teams go wrong. Most verifiers run broadly similar checks. The damage happens in the steps around the tool: a messy CSV that silently drops rows, a "Risky" bucket that gets mailed like it's "Valid," an invalid address deleted today and re-imported next quarter from another source. This guide is the hub for the whole workflow. Each stage is summarized here and links down to a deep-dive article, and there is a worked example with real arithmetic based on Unlimited Verifier's plan limits.
Quick answer
- Run five stages in order: prepare → verify → read results → act per bucket → re-import and suppress. Skipping preparation is the most common cause of bad results.
- Upload a slim file (a unique ID plus the email address), then join the results back on that ID. This avoids file-size caps and protects your custom fields.
- Mail Valid, quarantine Risky, suppress Invalid. Never delete invalids outright, or they come back with the next import.
- Re-verify on a schedule: new contacts monthly, and any segment you haven't mailed in roughly 90 days before you send to it again.
- Treat bounce rate as your scorecard. Keep hard bounces under about 2% per send (aim for under 1%). Keep spam complaints under Google's 0.3% ceiling.
What is a bulk email list verification workflow?
It is the end-to-end operating procedure for checking thousands of addresses at once and turning the output into a list you can safely mail. It is different from verifying one address at a time.
If you're new to the underlying technology, start with what is email verification. In short, a verifier runs layered checks on every address:
- Syntax. Is the address well-formed? The formal grammar lives in RFC 5322. In practice, verifiers are stricter than the RFC, because exotic-but-legal formats (quoted local parts, for example) are almost never real subscribers.
- Domain and DNS. Does the domain exist?
- MX records. Does the domain publish mail servers that can accept email?
- SMTP mailbox check. The verifier opens an SMTP conversation and asks the server whether it would accept mail for that recipient (the
RCPT TOstep defined in RFC 5321), then disconnects without sending a message. - Catch-all, disposable and role detection. It identifies domains that accept every address, throwaway inbox providers, and role accounts like
info@orsales@.
The "workflow" part covers everything a tool can't do for you. That means deciding what goes into the file, how to treat ambiguous results, and how results flow back into your ESP or CRM. For the full methodology in one checklist, see our step-by-step guide to cleaning a bulk email list. For the conceptual background on every check, read our explainer on how email verification works.
Bottom line: verification is a set of checks; the workflow is the process that makes those checks change what you actually send.
Why does verifying a bulk email list matter?
It protects sender reputation. Mailbox providers judge you on bounces and complaints, and an unverified list is the fastest way to generate both.
Three forces make this urgent:
- Mailbox provider rules have tightened. Google's email sender guidelines require bulk senders (around 5,000+ messages a day to personal Gmail accounts) to authenticate with SPF, DKIM and DMARC and to offer one-click unsubscribe. They also ask senders to keep the spam rate reported in Postmaster Tools below 0.10% and never reach 0.30%. Yahoo's sender requirements set similar expectations. Verification doesn't fix authentication. It does remove the dead addresses that inflate bounces and drag down the engagement signals providers watch.
- Lists decay constantly. People change jobs, abandon inboxes and mistype addresses. Commonly cited industry estimates put annual decay somewhere between a fifth and a third of a list, with B2B lists at the high end because of job turnover. The exact figure varies by audience, but a list that was clean last year is not clean now.
- Bad data costs money twice. Many ESPs bill by contact count, so you pay to store dead addresses. Those addresses then hurt the inbox placement of the good ones. Our breakdown of email marketing ROI shows how list quality compounds into revenue.
What bounce rate is acceptable? Sources disagree. ESPs publish different thresholds, and some enforce stricter internal limits than they publicly state. Practitioners commonly treat a hard bounce rate above about 2% per campaign as a warning sign. We recommend a working target of under 1%, which gives you headroom when a segment turns out worse than expected. For the full picture of how bounces, complaints and authentication interact, see our email deliverability hub.
Bottom line: verification can't make an email wanted, but it removes the addresses that guarantee bounces, and bounces are the signal you control most directly.
What are the five stages of the workflow?
The five stages are prepare, verify, read, act and re-import. Each one has a specific output that feeds the next.
| Stage | Goal | Output | Typical failure if skipped |
|---|---|---|---|
| 1. Prepare | Clean, dedupe and slim the file | One email per row, unique ID column, UTF-8 CSV | Rows silently dropped or wrong column detected |
| 2. Verify | Run syntax, DNS/MX, SMTP and catch-all checks | Status per address | Lists over the size cap fail; results expire unseen |
| 3. Read | Understand statuses and flags | Annotated results file | "Risky" mailed as if "Valid" |
| 4. Act | Decide per bucket | Send / quarantine / suppress segments | Invalids deleted, then re-imported later |
| 5. Re-import | Push results to ESP/CRM | Updated records + suppression list | Custom fields overwritten or lost |
Here is the framework to act on today:
- Export the list from your ESP or CRM, including the record ID.
- Clean and dedupe in a spreadsheet or script.
- Slim the file to
id,email(plus a source-column field if you merged several email columns). - Split the file if it exceeds your tool's per-list or file-size limit.
- Upload and verify each file, or send it through an API.
- Download results immediately. Retention windows can be short.
- Join results back to the master file on the ID.
- Segment into Valid / Risky / Invalid, and keep the sub-flags.
- Re-import status fields into your ESP/CRM, and push Invalids to a suppression list.
- Schedule the next run: new contacts monthly, dormant segments before re-engagement.
Bottom line: if you can name the output of each stage, you can find where any bad result came from.
How do you prepare an email list for verification?
Get the file to one valid-looking email per row, a stable unique ID, no duplicates, and nothing the uploader could misread. Preparation decides whether the verifier sees the right data at all.
Our full guide on preparing a list before you verify it walks through every check. The sub-steps below are where most of the time goes.
Clean the messy CSV first
Exports from CRMs, event platforms and old spreadsheets carry predictable junk:
- Leading or trailing spaces, including non-breaking spaces pasted from web pages. They're invisible in Excel.
mailto:prefixes and angle brackets (<jane@acme.com>).- Several addresses in one cell, separated by
;or,. - Smart quotes, trailing periods, and display names (
"Jane Doe" jane@acme.com). - Encoding damage. Save as UTF-8, or accented names and internationalized domains turn into garbage.
Fix these before upload. A verifier will correctly mark jane@acme.com (with a trailing non-breaking space) as invalid, and you lose a real subscriber. Our walkthrough on cleaning a messy CSV of emails before upload includes the spreadsheet formulas for each fix.
Remove duplicates before verifying
Dedupe on a lowercased, trimmed copy of the address, but keep the original value in the output. RFC 5321 technically allows case-sensitive local parts, yet virtually every real mailbox provider ignores case. That means Jane@Acme.com and jane@acme.com are the same person for practical purposes.
Two reasons to dedupe first:
- You don't waste allowance or time verifying the same address twice.
- When you merge results back, duplicates cause one-to-many joins that scramble statuses.
Don't "normalize" Gmail dots or plus-tags for sending. j.doe+news@gmail.com is how that subscriber chose to sign up. You can flag likely duplicates for review instead. See removing duplicate emails before verifying for the exact method.
Know which file formats the verifier accepts
Most bulk verifiers accept CSV, and many accept Excel (.xlsx). Unlimited Verifier accepts CSV or Excel files up to 10MB, detects the email column automatically, and exports results as CSV, Excel or JSON.
Plain CSV is the safest input. Excel files can hide extra sheets, merged cells and formula results that don't export the way you expect. Details for each format and common rejection causes are in what file formats email verifiers accept.
Handle files with multiple email columns
CRM exports often carry email, work_email and secondary_email. Auto-detection will typically pick one column, so the others go unverified.
The robust fix is to unpivot: stack every email column into one, add a source_column field and keep the record ID. Verify the stacked file, then pivot the statuses back. Our guide to verifying a list with multiple email columns shows the spreadsheet and script versions.
Keep your custom fields safe
Don't upload 40 columns of CRM data to verify one. Upload id,email only, then join results back to your master file on id. This keeps personal data you don't need out of a third-party tool, which is a data-minimization win. It also guarantees your segments, tags and purchase history can't be reordered or truncated. More in keeping custom fields when verifying an email list.
Split large files to fit limits
Two limits matter: rows per list and file size.
On Unlimited Verifier Pro, each list can hold up to 25,000 emails, and files can be up to 10MB. The size limit catches people who upload wide exports. 10MB divided by 25,000 rows is 400 bytes per row. A 30-column CRM row can easily exceed that, so a "25,000-row" file gets rejected. A slim id,email row is typically under 60 bytes, so 25,000 rows come to roughly 1.5MB, well inside the cap.
Split on row count, keep the header row in every file, and name files sequentially (list_part01.csv, list_part02.csv) so the merge is unambiguous. See splitting a large CSV for email verification.
Bottom line: a slim, deduped, UTF-8 file with a unique ID solves 80% of downstream problems before you've verified anything.
How do you upload and run a bulk verification?
Upload the prepared file, confirm the detected email column, run the verification, and download the results before the retention window closes. The tutorial below uses Unlimited Verifier, but the same logic applies to most tools.
Hands-on tutorial: your first bulk verification
- Create an account. The Free plan ($0) gives you 25 lists a month of up to 150 emails each, plus 750 deep verifications a month. Standard verification is unlimited on every plan, so there are no per-email fees.
- Prepare your file using the steps above:
id,email, UTF-8, deduped. - Check the row count against your plan. Free allows 150 per list. Pro allows 25,000 per list. Split if needed.
- Upload and verify a list. Drag in the CSV or Excel file (up to 10MB).
- Confirm the email column. Detection is automatic, but glance at the preview, especially if your file has several address-like columns.
- Start verification. Each address goes through syntax, domain, MX and SMTP mailbox checks, catch-all detection, and disposable and role-based flagging.
- Review the summary. You'll see counts for Valid, Risky and Invalid.
- Export as CSV, Excel or JSON. Use CSV if you'll re-import into an ESP.
- Download immediately. Results are kept 24 hours on Free and 30 days on Pro.
- Join the results to your master file on
idand move to the read-and-act stages.
A practical tip for Free users: 25 lists × 150 emails gives you 3,750 emails a month of capacity. A 3,000-contact newsletter fits as 20 files of 150 (3,000 ÷ 150 = 20), with five list slots to spare for new sign-ups. The full upload walkthrough, with screenshots of what to check, is in how to upload a CSV to an email verifier.
How long does it take to verify 100k emails?
It depends more on the receiving servers than on the verifier. Syntax and DNS checks are near-instant. SMTP checks wait on remote mail servers, and some of those deliberately slow down unfamiliar connections (rate limiting) or reply "try again later" (greylisting, signaled by 4xx temporary codes under RFC 5321).
Consumer-heavy lists dominated by large providers tend to move faster than B2B lists spread across thousands of corporate domains. Plan in hours, not minutes, for six-figure lists, and don't schedule a campaign for the same afternoon.
On Unlimited Verifier Pro, 100,000 emails means at least four lists of up to 25,000, which you can run as parallel uploads. Planning detail is in how long it takes to verify 100k emails.
When should you verify a single address instead?
When the question is about one contact: a high-value lead, a customer reporting missing emails, or a spot-check of a surprising bulk result. The free email checker runs the same kinds of checks on a single address without uploading a file. Use cases and how to interpret one-off results are covered in verifying a single email address quickly.
Can you verify a list from your phone?
Technically yes, since any web-based verifier opens in a mobile browser. Practically, verification from a phone is good for single-address checks and for downloading a results file someone else started. Preparation (dedupe, unpivot, split) is painful on a small screen. Our guide on verifying an email list from your phone covers what works and what to leave for a laptop.
What about catch-all domains?
A catch-all (accept-all) domain says "yes" to every RCPT TO, so an SMTP check can't tell a real mailbox from a made-up one. These are common on corporate domains, which is why B2B lists produce far more Risky results than consumer lists.
Unlimited Verifier detects catch-all domains and offers catch-all email verification for digging into them. Your deep-verification allowance (750/month on Free, 25,000/month on Pro) is the budget to plan around for your most valuable catch-all segments. The company states 99.5% accuracy for deep verification. That is Unlimited Verifier's stated figure, not an independent benchmark.
Bottom line: the upload is the easy part. Respect the per-list cap, confirm the column, and download results the same day.
How do you read an email verification results file?
Read the status first, then the flags. The status tells you what to do, and the flags tell you why, which often changes the decision.
A typical results file contains your original columns (or just id,email if you slimmed it), a status, and detail fields such as catch-all, disposable and role-based indicators. Column names vary by tool, so map them once and save the mapping. Our annotated walkthrough is how to read an email verification results file.
Valid vs Risky vs Invalid, explained
| Status | What it means technically | Typical causes | Default action |
|---|---|---|---|
| Valid | Syntax OK, domain has MX, mailbox accepted at SMTP | Real, active mailbox | Mail normally |
| Risky | Can't be confirmed, or is deliverable but problematic | Catch-all domain, role-based (info@), disposable, temporary server errors |
Quarantine; mail cautiously or re-check |
| Invalid | Will hard-bounce | Bad syntax, nonexistent domain, no MX, mailbox rejected (5xx) | Suppress; never mail |
The key insight is that Risky is not a single risk. A role address at a real company may be perfectly deliverable but likely to generate complaints. A disposable address is deliverable today and gone next week. A catch-all address might be a real VP's inbox.
Treat each sub-type separately. The full taxonomy is in Valid vs Risky vs Invalid results explained.
What about "unknown" results?
"Unknown" means the verifier couldn't get a definitive answer. Usual causes are a timeout, greylisting, or a server that refuses to talk to verification traffic. In a three-bucket model, these belong in the cautious middle rather than being guessed into Valid or Invalid.
A good rule of thumb is to re-verify unknowns after 24–72 hours. Greylisting usually clears on retry, and genuinely dead servers stay dead. Our playbook on handling unknown emails after verification covers the retry logic.
Bottom line: status decides the bucket; flags decide what you do inside it.
What should you do with each result bucket?
Mail Valid normally, handle Risky by sub-type, and move every Invalid to a permanent suppression list. The details matter most in the middle bucket.
Risky emails: treat by sub-type
- Catch-all: send to engaged or high-value contacts first in small batches, and watch bounces. Drop the rest after one cautious send if they show no engagement.
- Role-based: usually fine for transactional or account email. For marketing, they tend to generate more complaints because several people share the inbox and nobody remembers subscribing.
- Disposable: exclude from nurture sequences. For SaaS trials they're often a signal of abuse rather than interest.
- Unknown/temporary: re-verify before deciding.
Our deep dive on handling risky emails after verification includes a batch-size schedule for cautious sends.
Invalid emails: suppress, don't mail
Invalid addresses should never be sent to again. That raises the obvious follow-up: what exactly do you do with the record? See what to do with invalid emails after list cleaning for workflows by ESP type.
Should you delete or suppress invalid emails?
Suppress. If you delete an invalid address, nothing stops it from returning in next quarter's event export, a sales rep's CSV, or a CRM sync. A suppression list (unsubscribes, hard bounces, invalids, complainers) is your memory.
There is a compliance angle too. The FTC's CAN-SPAM compliance guide requires honoring opt-outs within 10 business days. In practice, the only way to keep honoring them is to keep a suppressed record. Our guide on whether to delete or suppress invalid emails explains how to keep suppressions while respecting data-minimization rules, for example by storing a hash.
Segment the list by verification status
Write the status back as a field (verification_status, verification_date). Then build segments: "Valid – active," "Risky – catch-all," "Risky – role," and so on. Field-based segments survive re-imports and let you report bounce rates per segment, which is how you learn whether your Risky policy is too loose or too strict. See segmenting a list by verification status.
Export only the valid emails when that's all you need
For a one-off campaign or a hand-off to a partner, filter the results to Valid and export just those rows as CSV. Watch out for one thing: if you export only Valid and overwrite your master list, you've effectively deleted your Risky and Invalid records, and with them your suppression memory. Export valid-only as a copy. Steps in exporting only valid emails after verification.
Bottom line: the decision you'll get wrong most often is in the Risky bucket, so split it by flag before acting.
How do you get the cleaned list back into your ESP or CRM?
Re-import with an update-by-ID or update-by-email match, write status fields rather than deleting records, and load Invalids into the platform's suppression list.
Unlimited Verifier has no native ESP, CRM or Zapier integrations. The workflow is export a CSV → verify → re-import, or call the API from your own script (covered below). That's the same pattern most teams use anyway, because it gives you a reviewable file at every step.
Re-importing into your ESP
- Map
verification_statusto a custom field. Don't rely on tags you might forget to remove. - Use update existing mode so you don't create duplicates.
- Import Invalids into the ESP's suppression/blocklist, not just as a field value. A field can be ignored by a careless segment; a suppression can't.
- Confirm that re-importing doesn't resubscribe people who previously unsubscribed. Some ESP import flows can change subscription status if you map the wrong column.
Platform-specific notes are in re-importing a cleaned list into your ESP.
Merging results back into a CRM
CRMs are less forgiving than ESPs. Match on the CRM record ID, not email, because email can be duplicated across contacts or leads. Update only the verification fields, and test on 100 records before running the full file. Blank cells in an import can overwrite good data in some CRMs. Full walkthrough: merging verification results back into a CRM.
Bottom line: re-import status, don't re-import a "new" list. Your records and history should survive cleaning untouched.
What does a real bulk verification run look like? (worked example)
Here is an illustrative scenario with the arithmetic shown. The result percentages are hypothetical. Real outcomes depend heavily on list age and source.
Scenario: an agency inherits a client's CRM export of 92,400 rows with three email columns, last mailed 14 months ago. They're on Unlimited Verifier Pro ($29/month, or $25/month billed annually).
Step 1: Prepare
- Unpivot the email columns. Only 6,000 records have a secondary address, so 92,400 rows plus 6,000 secondary addresses gives 98,400 address rows.
- Clean and dedupe on lowercase-trimmed address: 12,100 duplicates and 400 obvious junk entries are removed, leaving 98,400 − 12,100 − 400 = 85,900.
- Slim to
id,source_column,email, about 1.6MB per 25,000 rows, so the 10MB cap is no issue.
Step 2: Split and verify
- 85,900 ÷ 25,000 = 3.44, so 4 lists: 25,000 + 25,000 + 25,000 + 10,900 = 85,900.
- Standard verification is unlimited on Pro, so the 85,900 checks carry no per-email fee.
Step 3: Read (hypothetical results)
| Status | Count | Share |
|---|---|---|
| Valid | 71,300 | 83.0% |
| Risky | 9,450 | 11.0% |
| Invalid | 5,150 | 6.0% |
| Total | 85,900 | 100% |
The hypothetical Risky breakdown is 6,200 catch-all, 2,100 role-based, 450 disposable and 700 unknown (6,200 + 2,100 + 450 + 700 = 9,450).
Step 4: Act
- Invalid (5,150): go to ESP suppression. If they had mailed the raw list, 5,150 ÷ 85,900 = 6.0% hard bounces on the first send, three times the common 2% warning threshold.
- Unknown (700): re-verify after 48 hours.
- Catch-all (6,200): the team has 25,000 deep verifications a month. They spend them on catch-all addresses at the client's top-tier accounts, then mail those cautiously in small batches.
- Role (2,100): excluded from the promotional sequence, kept for account notices.
- Disposable (450): excluded.
Step 5: Re-import
Write verification_status and verification_date back by CRM ID. Load the 5,150 into the suppression list. Mail the 71,300 Valid contacts first, warming up gradually because the list hasn't been mailed in 14 months.
Cost context: with credit-based tools, cost scales with volume and every re-verification is a new charge. As a purely hypothetical illustration, at $4 per 1,000 credits, one pass over 85,900 addresses would be about $344, and the monthly re-checks would add more. On Pro, those standard checks are covered by the flat subscription. Compare models in detail in our email verification pricing glossary entry and the full pricing comparison guide.
Bottom line: the arithmetic that matters is avoiding a 6% bounce on send one, and that is decided by stages 1 and 4, not by the verifier alone.
How do you troubleshoot bad verification results?
Diagnose the source before you act. A high-Invalid list and a high-Risky list have different causes and different fixes.
What if 30% of your list is invalid?
A 30% invalid rate is not a cleaning problem; it's a source problem. Typical causes:
- A purchased or scraped list. Purchased lists are also off-limits under most ESPs' acceptable-use policies.
- Bot sign-ups on an unprotected form.
- A list that's been dormant for years.
Don't mail the "valid" 70% at full volume either. If 30% are dead, the survivors probably include spam traps and disengaged contacts that verification can't fully identify. Verification reduces trap exposure but can't guarantee detection, so pair it with engagement-based sunsetting.
The playbook is in what to do if 30 percent of your list is invalid. It covers re-permission campaigns and slow warm-up.
Why did your verified list come back mostly risky?
Usually one of three reasons:
- B2B domains with catch-all configurations. Many corporate mail gateways accept everything at the SMTP stage and filter later.
- Heavy greylisting or rate limiting, which produces temporary "unknown" results.
- Role-heavy lists, such as a scraped "contact us" address list.
Look at the flags. Catch-all-dominated results call for deeper catch-all checks and cautious sends. Unknown-dominated results call for a retry. See why a verified list comes back mostly risky.
Bottom line: high Invalid points to list origin; high Risky points to domain mix. Fix the right one.
How often should you verify, and how do you automate it?
Verify new contacts monthly (or at capture), and re-verify any segment you haven't mailed in about 90 days before you send to it. Automation makes this a background process instead of a quarterly fire drill.
Verify only new contacts each month
Filter your CRM export by created_date > last_verification_run and verify just that slice. Then add a second slice: anyone whose verification_date is older than 90 days and who you're about to re-engage. This keeps volumes small and results fresh. The 90-day figure is a practitioner rule of thumb, not a standard; B2B lists with high job turnover may justify shorter. Method and filters: verifying only new contacts each month.
Automate with an API
For recurring jobs, an API removes the export-upload-download loop. Unlimited Verifier's REST API uses API keys and supports single-email checks and bulk batches of up to 10,000 emails per request. API access is on Pro, at 100,000 emails a month (10 full batches). You can generate keys from the email verification API page.
Because there are no native integrations, the usual pattern is a scheduled script:
- Pull new or changed contacts from your CRM's own API.
- Batch them in groups of up to 10,000.
- Call the verification endpoint.
- Write the status back by record ID.
The verification engine is open-source on GitHub, so technical teams can inspect exactly how checks are performed. For architecture patterns, see email verification API and automation and the full API automation guide.
Verification for ecommerce and SaaS
Online stores and SaaS products capture addresses at checkout and sign-up, so the best time to verify is at the form. Real-time checks catch typos (gmial.com) before an order confirmation bounces, and flag disposable addresses used to farm free trials.
Bulk verification still matters for the backlog and for addresses captured before real-time checks existed. Industry-specific playbooks are in email verification for ecommerce and SaaS and our ecommerce and SaaS verification guide.
Bottom line: one big clean followed by small, frequent runs beats an annual purge every time.
Which verification method or tool should you use?
Use a bulk upload tool for backlogs, an API for recurring or point-of-capture checks, and ESP bounce handling as a safety net, never as the primary filter.
Methods compared
| Method | Best for | What it catches | Specific weak spot | Effort |
|---|---|---|---|---|
| ESP bounce handling only | Ongoing sends | Addresses that already bounced | Reactive: you take the reputation hit first | Low |
| Spreadsheet/regex cleanup | Pre-upload hygiene | Syntax errors, junk characters | Can't tell if a mailbox exists | Low–medium |
| Self-hosted SMTP checks | Engineering teams | Syntax, MX, SMTP | Many cloud providers restrict outbound port 25 by default; your IP reputation is on the line | High |
| Bulk upload tool | Backlogs, one-off cleans | Full check set incl. catch-all | Manual file handling unless paired with an API | Low |
| Real-time API | Forms, scheduled syncs | Full check set, at capture | Requires developer time to integrate | Medium |
Tools compared
| Tool | Result categories (per public docs) | Pricing model | Notable differentiators | Specific limitation |
|---|---|---|---|---|
| Unlimited Verifier | Valid / Risky / Invalid, with catch-all, disposable and role flags | Flat plans; unlimited standard verification on every plan ($0 Free; Pro $29/mo or $25/mo annually) | Open-source engine on GitHub; REST API with 10,000-email batches; CSV/Excel in, CSV/Excel/JSON out | No native ESP/CRM integrations; 25,000 emails per list on Pro; no API on Free |
| ZeroBounce | valid, invalid, catch-all, unknown, spamtrap, abuse, do_not_mail | Credit-based | Granular statuses including spam-trap and abuse codes; AI scoring offered for catch-alls | Seven-plus statuses need careful mapping before re-import |
| NeverBounce | valid, invalid, disposable, catchall, unknown | Credit-based | Part of ZoomInfo; broad set of native ESP integrations | No dedicated spam-trap status among its five result codes |
| Kickbox | deliverable, undeliverable, risky, unknown | Credit-based | Sendex quality score per address | Broad "risky" bucket; you set your own Sendex cut-offs |
For a fuller field guide with more vendors, see best email verification tools and our ranked comparison of verification tools.
Where Unlimited Verifier fits best
It is a strong fit if you re-verify often, because flat pricing means a monthly re-check doesn't trigger a new bill. It also suits teams that clean many mid-sized lists (agencies, multi-brand marketers), and teams that want a transparent, open-source engine. It is a weaker fit if you need one-click native syncing into a specific ESP. In that case, factor in the CSV round-trip or a small API script.
How we compared (and limitations)
The comparison is based on each vendor's public documentation at the time of writing. We did not run head-to-head accuracy benchmarks. Accuracy claims, including Unlimited Verifier's stated 99.5% for deep verification, are vendor statements, not independent results. Status names, integrations and pricing change frequently, so confirm on each vendor's site before buying.
Bottom line: pick the pricing model that matches how often you verify, because frequency drives total cost more than headline price.
How does verification fit into compliance and list hygiene?
Verification supports compliance. It does not replace consent. It helps you meet data-accuracy and suppression obligations, but it can't make a non-consented list lawful.
- Accuracy. UK and EU GDPR include an accuracy principle (Article 5(1)(d)): personal data should be accurate and kept up to date. The ICO publishes guidance on applying it. Routine verification is a defensible way to show you take accuracy seriously.
- Minimization. Uploading
id,emailinstead of your full CRM export limits what a processor sees. Check the vendor's data-processing terms, and note retention: Unlimited Verifier keeps results for 24 hours on Free and 30 days on Pro. - Suppression. CAN-SPAM opt-out rules (above) and GDPR objections both require you to remember who said no. That's why suppression beats deletion.
- Industry practice. M3AAWG publishes sender best practices that treat list hygiene, bounce processing and permission as connected disciplines.
The full compliance treatment is in email verification compliance and hygiene, with an operational checklist in our compliance and hygiene guide.
Bottom line: verify for accuracy, suppress for compliance, and never use verification to launder a list you didn't have permission to mail.
What are the most common bulk verification mistakes?
The most damaging mistakes happen outside the verifier. They come from file handling, bucket policy and re-import.
- Uploading the full CRM export. Wide files hit size caps (10MB on Unlimited Verifier), expose unnecessary personal data, and risk column mix-ups. Upload
id,email. - Verifying before deduping. This wastes allowance and creates one-to-many joins that assign the wrong status to records.
- Ignoring secondary email columns. Auto-detection picks one column, and the rest go unverified and get mailed anyway.
- Mailing Risky like Valid. Catch-all and role addresses need their own rules, or the bounces and complaints you were trying to prevent come back.
- Deleting invalids. They return in the next import. Suppress instead.
- Letting results expire. On Free, results are kept 24 hours. Download the same day.
- Re-importing in "replace" mode. This can wipe custom fields, or worse, resubscribe unsubscribed contacts.
- Treating verification as permanent. It's a snapshot. Re-verify dormant segments (roughly 90+ days) before re-mailing.
- Expecting verification to fix authentication. SPF, DKIM, DMARC and one-click unsubscribe are separate requirements under Google's and Yahoo's sender rules.
- Blaming the tool for a source problem. A 30% invalid rate means the list's origin is the issue, not the verifier.
Bottom line: almost every failed cleaning project traces back to stage 1 (preparation) or stage 4 (bucket policy). Get those right and the verifier's job is straightforward.
The 5-stage verification workflow
| Stage | Action | Key rule |
|---|---|---|
| 1. Prepare | Export a slim CSV (unique ID + email), dedupe, normalize | Compare row counts before and after |
| 2. Verify | Run syntax, domain, MX, SMTP, catch-all/disposable/role checks | Upload once, track the job |
| 3. Read results | Sort into Valid, Risky, Invalid | Never merge Risky into Valid |
| 4. Act per bucket | Mail Valid, quarantine Risky, suppress Invalid | Suppress, don't delete |
| 5. Re-import | Join results back on ID, keep suppressions active | Re-verify new contacts monthly and segments idle about 90 days |
Frequently asked questions
How often should I verify my email list?
Verify new contacts monthly, and re-verify any segment you haven't mailed in roughly 90 days before sending to it again. Addresses decay steadily as people change jobs and abandon inboxes. Older segments carry the most risk. Verifying at the point of capture, through a signup form check, cuts down how much cleanup you need later.
What should I do with catch-all email addresses?
Treat catch-all addresses as Risky. Don't mail them as Valid. A catch-all domain accepts mail for every address, so an SMTP check can't confirm that a specific mailbox exists. Quarantine them, then send to small batches first and watch the bounce rate. Add them back to your main list only if engagement and bounces stay healthy.
Should I delete invalid email addresses?
No. Suppress invalid addresses instead of deleting them. If you delete an address, it can come back the next time you import from a CRM, event list or partner file, and you'll mail it again. Keep invalids on a suppression list in your ESP so they're blocked automatically, whatever source they arrive from.
What is an acceptable bounce rate after verification?
Keep hard bounces under about 2% per send, and aim for under 1%. Keep spam complaints below Google's 0.3% ceiling for bulk senders, and ideally well under 0.1%. If bounces rise above these levels after verification, check whether Risky or catch-all addresses were mailed as if they were Valid.
Why upload only an ID and email column to a verifier?
A slim file with a unique ID and the email address avoids file-size caps and lowers parsing errors. It also keeps your custom fields from being altered or exposed. Once verification finishes, join the results back to your master list on the ID. This keeps every row accounted for and makes it easy to spot any that went missing.
Does email verification send an email to the address?
No. The verifier opens an SMTP conversation and issues the RCPT TO command to ask whether the server would accept mail for that recipient. It then disconnects before any message is sent. The recipient never gets an email or a notification that their address was checked.
Should I mail role-based addresses like info@ or sales@?
Usually you should quarantine role-based addresses rather than mail them freely. They often go to several people or a shared inbox, so they tend to have lower engagement and higher complaint risk. Keep them only when the relationship is clearly B2B and expected, and watch their complaint rates closely.
Can I verify a list after it has already bounced?
Yes, and you should. Remove or suppress the hard-bounced addresses first, then verify the rest of the list before your next send. Bounce data from your ESP is more reliable than any verifier's prediction, so record those bounces as suppressions. Use verification to catch the bad addresses that haven't bounced yet.
How accurate are bulk email verifiers?
Most reputable verifiers run broadly similar layered checks: syntax, domain, MX, SMTP, and catch-all and disposable detection. They're dependable for definite Valid and Invalid results. Accuracy drops on catch-all domains and on servers that block or greylist verification attempts. That uncertainty is why a Risky bucket exists, and why your workflow should treat it carefully.
What causes rows to go missing during list verification?
Rows usually go missing because of CSV problems. Common causes are inconsistent delimiters, line breaks inside fields, encoding issues and stray quote characters. Clean and normalize the file before you upload it, and compare row counts at every stage. Joining the results back on a unique ID shows exactly which records were dropped.
Cut Bounces and Protect Your Sender Reputation With Unlimited Email Verification
Every invalid address you send to hurts your sender reputation and your inbox placement. Verifying your list before each send means fewer bounces, healthier deliverability, and a predictable cost. With Unlimited Verifier, standard verification is unlimited on every plan, with no per-email fees.
Unlimited Verifier checks syntax, domain, MX records and the SMTP mailbox. It also detects catch-all domains and flags disposable and role-based addresses. Export a CSV from your email platform or CRM, upload and verify the list, then re-import the clean results. You can also automate checks with the email verification API.
| Free | Pro | |
|---|---|---|
| Price | $0 | $29/month ($25/month billed annually) |
| Lists | 25 a month, up to 150 emails each | Unlimited, up to 25,000 emails each |
| Deep verifications | 750 a month | 25,000 a month |
| API access | No | Yes (100,000 emails a month) |
| Result retention | 24 hours | 30 days |
Why teams choose Unlimited Verifier
- Unlimited standard verification on all plans, including Free, with no per-email fees.
- Catch-all detection so you know which domains accept every address.
- Clear Valid / Risky / Invalid results, exportable as CSV, Excel or JSON.
- An open-source verification engine you can inspect on GitHub.
Unlimited Verifier states 99.5% accuracy for deep verification.
Create a free account and verify your next list before you hit send.
Want to test a single address first? Try the free email checker.