Guide

Bulk Email List Verification Workflow: A Five-Stage Process From Raw CSV to Clean, Suppressed List

By Unlimited Verifier Team ·

Flow diagram of a bulk email list verification workflow showing prepare, verify and results stages splitting into Valid, Risky and Invalid buckets before re-imp

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

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:

  1. 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.
  2. Domain and DNS. Does the domain exist?
  3. MX records. Does the domain publish mail servers that can accept email?
  4. SMTP mailbox check. The verifier opens an SMTP conversation and asks the server whether it would accept mail for that recipient (the RCPT TO step defined in RFC 5321), then disconnects without sending a message.
  5. Catch-all, disposable and role detection. It identifies domains that accept every address, throwaway inbox providers, and role accounts like info@ or sales@.

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:

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:

  1. Export the list from your ESP or CRM, including the record ID.
  2. Clean and dedupe in a spreadsheet or script.
  3. Slim the file to id,email (plus a source-column field if you merged several email columns).
  4. Split the file if it exceeds your tool's per-list or file-size limit.
  5. Upload and verify each file, or send it through an API.
  6. Download results immediately. Retention windows can be short.
  7. Join results back to the master file on the ID.
  8. Segment into Valid / Risky / Invalid, and keep the sub-flags.
  9. Re-import status fields into your ESP/CRM, and push Invalids to a suppression list.
  10. 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:

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:

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

  1. 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.
  2. Prepare your file using the steps above: id,email, UTF-8, deduped.
  3. Check the row count against your plan. Free allows 150 per list. Pro allows 25,000 per list. Split if needed.
  4. Upload and verify a list. Drag in the CSV or Excel file (up to 10MB).
  5. Confirm the email column. Detection is automatic, but glance at the preview, especially if your file has several address-like columns.
  6. Start verification. Each address goes through syntax, domain, MX and SMTP mailbox checks, catch-all detection, and disposable and role-based flagging.
  7. Review the summary. You'll see counts for Valid, Risky and Invalid.
  8. Export as CSV, Excel or JSON. Use CSV if you'll re-import into an ESP.
  9. Download immediately. Results are kept 24 hours on Free and 30 days on Pro.
  10. Join the results to your master file on id and 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

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

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

Step 2: Split and verify

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

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:

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:

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:

  1. Pull new or changed contacts from your CRM's own API.
  2. Batch them in groups of up to 10,000.
  3. Call the verification endpoint.
  4. 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.

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.

  1. 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.
  2. Verifying before deduping. This wastes allowance and creates one-to-many joins that assign the wrong status to records.
  3. Ignoring secondary email columns. Auto-detection picks one column, and the rest go unverified and get mailed anyway.
  4. 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.
  5. Deleting invalids. They return in the next import. Suppress instead.
  6. Letting results expire. On Free, results are kept 24 hours. Download the same day.
  7. Re-importing in "replace" mode. This can wipe custom fields, or worse, resubscribe unsubscribed contacts.
  8. Treating verification as permanent. It's a snapshot. Re-verify dormant segments (roughly 90+ days) before re-mailing.
  9. Expecting verification to fix authentication. SPF, DKIM, DMARC and one-click unsubscribe are separate requirements under Google's and Yahoo's sender rules.
  10. 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 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.