Article

How to Verify Apollo Email Lists Before Sending (Step-by-Step)

By Unlimited Verifier Team ·

Flow diagram showing an Apollo email list moving through deduplication and verification checks before sorting into Valid, Risky and Invalid groups for sending.

Summary

To verify an Apollo email list before sending, export it to CSV, remove duplicates and suppressions, then check every address for syntax, domain, MX and mailbox validity. Send only to addresses marked Valid, hold Risky ones for small monitored tests, and keep hard bounces under 2%.

To verify an Apollo email list before sending, export it to CSV, remove duplicates and suppressions, then run every address through a verifier that checks syntax, domain, MX and SMTP mailbox, and send only to Valid addresses while keeping hard bounces under 2%.

An Apollo export is a prediction, not a guarantee. Before you send, confirm that each mailbox exists, separate confirmed addresses from uncertain ones, and sequence your sends so a weak segment can't damage your sending domain. This guide covers the full process from export to first send, as part of your wider email verification for sales prospecting workflow.

Quick answer

Why can't you trust an Apollo list without verifying it?

You can't rely on an Apollo export without verification because a database record shows what was true when it was collected, not what is true when you send. People change jobs, companies merge or rebrand their domains, and mailboxes close while the contact record survives.

Bounces tend to cluster in predictable places. Watch for four segments:

The practical lesson is that bounce risk is concentrated, so manage it by segment. One bad segment can hurt inbox placement for the rest of your sending, because mailbox providers track how often a sender hits non-existent addresses. For more on how these patterns show up in practice, see why Apollo verified emails bounce.

Bottom line: Treat an Apollo export as a list of candidates. Verification turns it into a list you can defend.

What does email verification actually check?

Verification runs four layers, from cheapest to most authoritative: syntax, domain, mail server and the mailbox itself. Each layer catches a different failure, so skipping one leaves a gap.

The mailbox check does the heavy lifting, and it's also where results get fuzzy. Some servers rate-limit or block verification probes, and catch-all servers accept everything. A verifier that reports these cases as Risky, rather than forcing a yes or no, is giving you honest information.

Bottom line: Syntax and MX checks catch obvious errors. The mailbox check and the catch-all flag catch the bounces that actually hurt your sender reputation.

How do you prepare an Apollo CSV for verification?

Export one row per contact with an email column, keep the raw file untouched, and deduplicate on a normalised email address. Ten minutes of preparation prevents most upload problems and wasted verification capacity.

  1. Keep the raw export unchanged. Audits and disputes need the original file.
  2. Confirm the email column is present and populated. Contacts without an email can't be checked, so remove them from the verification file.
  3. Deduplicate on a normalised email. Trim whitespace and lowercase each address before comparing. The SMTP standard allows case-sensitive local parts, but in practice most mailbox providers treat addresses as case-insensitive, so Jane.Doe@acme.com and jane.doe@acme.com should count as one contact. Keep the original casing in your records.
  4. Remove known suppressions. Unsubscribes, complaints and past hard bounces don't need a verification check. They need to stay off your list.
  5. Log the counts at each step. Record raw rows, duplicates removed, suppressions removed and rows to verify. You'll cite these numbers later.

If your Apollo contacts were enriched in another tool first, verify after enrichment and before any sequence starts. For LinkedIn-sourced data, the Sales Navigator verification workflow covers extra checks. If you enrich inside Clay, see verifying emails in Clay tables.

Column headers can change between export types, so read the header row yourself. Unlimited Verifier detects the email column automatically, but a quick look prevents a silent mismatch from dropping your whole list.

Bottom line: Clean the file before you verify it. Deduplicating and removing suppressions first means every check goes to an address you might actually email.

Which verification method should you use on an Apollo list?

Verify the whole export with a full verifier. Trusting the vendor's own labels, or sending a test campaign to see what bounces, are weaker methods.

Method What it catches What it misses Best use
Trust the vendor's "verified" or confidence label Nothing you can audit Job changes, closed mailboxes, catch-all risk Prioritising which contacts to check first, not deciding what to send
Full verification of the whole export (syntax, domain, MX, SMTP, flags) Invalid addresses, typos, disposable and role addresses, catch-all risk Whether the person wants your email Standard pre-send check for every new export
Deep verification on high-value rows A deeper check on contacts you'd otherwise email blind. The company states 99.5% accuracy for deep verification Still can't prove consent or relevance Enterprise targets, senior contacts, and any catch-all segment you plan to contact
Send a test campaign and see what bounces Bounces, after the reputation hit has happened Everything that doesn't bounce but is still wrong Not recommended as a primary method

For most teams, full verification of the whole export is the right baseline, with deep checks layered on the segments where a bounce would cost the most. Choosing between tools is a separate decision. Our best email verification tools roundup and how to choose an email verifier checklist cover the criteria in depth. Don't confuse the two jobs either: a finder guesses addresses and a verifier checks them. Email finder vs email verifier explains the difference.

Bottom line: Verify the whole export, and reserve deep checks for the rows where a bounce would cost you the most.

How do you verify an Apollo list before sending? A 7-step framework

Work through these steps in order before the first send. Each one produces a number you can check.

  1. Export and deduplicate. Record the raw count and the deduplicated count.
  2. Apply your suppressions. Remove unsubscribes, complaints and previously bounced addresses.
  3. Verify the full remaining list. Use a verifier that runs syntax, domain, MX and SMTP checks and flags catch-all, disposable and role addresses.
  4. Sort into Valid, Risky and Invalid. Remove Invalid addresses permanently. Never send to an Invalid address, even once.
  5. Break Risky down by type. Separate catch-all corporate domains, role addresses and disposable addresses. Each needs a different decision.
  6. Build a staged send plan. Send Valid addresses first, most relevant segment first. Hold Risky addresses for small test batches.
  7. Watch the first send closely. Track hard bounces and spam complaints within hours. Stop and investigate if bounces approach your ceiling.

Our recommended numbers are a 2% total bounce ceiling and a target under 1% for the first send. Platform thresholds differ, and where sources disagree we recommend the tighter number. Amazon SES's documentation describes a 5% bounce rate as a review trigger, but treating 5% as your limit leaves no room for one bad segment. For complaints, Google's sender guidelines describe keeping spam rates below 0.10% and never reaching 0.30%. Our average cold email bounce rate benchmarks article shows how these numbers compare across campaign types.

Bottom line: The framework turns "I think this list is fine" into counts you can check after every send.

How do you verify an Apollo export with Unlimited Verifier?

Upload the CSV, read the three buckets, export the results the same day, and import only the Valid list. This walkthrough uses Unlimited Verifier's web app.

  1. Create an account. Sign up for free. The Free plan covers 25 lists a month of up to 150 emails each, plus 750 deep verifications a month.
  2. Prepare the CSV. Follow the preparation steps above, and keep the email column populated.
  3. Upload the file. Go to upload and verify a list. CSV and Excel files up to 10MB are accepted, and the email column is detected automatically.
  4. Start verification. Each address is checked for syntax, domain, MX records and the SMTP mailbox. Catch-all domains are detected, and disposable and role-based addresses are flagged.
  5. Read the three buckets. Valid addresses form your first-send list. Invalid addresses get removed and suppressed. Risky addresses, including catch-all, disposable and role accounts, are held back.
  6. Export immediately. Results are kept for 24 hours on the Free plan and 30 days on Pro. Export as CSV, Excel or JSON, and save the summary counts for your records.
  7. Import the Valid list into your sending tool. Unlimited Verifier has no native ESP, CRM or Zapier integrations, so this is a manual export and import. Add the Invalid addresses to your suppression list at the same time.
  8. Spot-check the edge cases. For a single high-value contact that came back Risky, use the free email checker to look at that address on its own.

The 24-hour retention on the Free plan matters. If you verify on Free, export the results the same day, or you'll have to run the list again.

Bottom line: Upload, read the three buckets, export the same day, and import only the Valid list.

How does a 12,000-row Apollo export work out in practice?

A 12,000-row export becomes an audited, staged send in one working session. The numbers below are illustrative, but the plan limits and arithmetic are real.

A B2B team exports 12,000 contacts from Apollo across three segments and wants to start a cold sequence within the week.

Step 1: Deduplicate and suppress

Step 2: Check plan fit

Free Pro
Lists 25 a month, up to 150 emails each Unlimited lists, up to 25,000 emails each
Capacity per month 3,750 emails (25 × 150) 11,250 emails fit in one list
Deep verifications 750 a month 25,000 a month
Results kept 24 hours 30 days
API access Not included Included, 100,000 emails a month
Price $0 $29/month, or $25/month billed annually

On Free, 11,250 addresses would take three months of list allowance, and the results would expire within a day. Pro handles the whole file in one list.

Step 3: Calculate cost

Standard verification is unlimited on every plan, so the subscription is the main cost. When you compare email verification pricing across tools, use cost per verified address, not the headline price.

Step 4: Results (illustrative)

Result Count Share
Valid 8,100 72%
Risky 2,250 20%
Invalid 900 8%

Step 5: Break Risky down by segment

Segment Rows Valid Risky Invalid
A: Mid-market SaaS domains 4,500 4,100 150 250
B: Enterprise domains (mixed server setups) 3,000 1,500 1,200 300
C: Agencies and small firms 3,750 2,500 900 350
Total 11,250 8,100 2,250 900

Most of Segment B's Risky result comes from catch-all domains, where the server accepts every address and the verifier can't confirm the individual mailbox. That's a property of the domain, not proof the list is bad.

Step 6: Staged send plan

If Wave 1 crosses 2%, stop and re-check the Valid list before Wave 2. That's the point where a list problem becomes a reputation problem.

Bottom line: A 12,000-row export becomes an audited, staged send, and the Risky segment gets a measured test instead of a blind send.

How should you handle Risky and catch-all addresses?

Send to Risky and catch-all addresses last, in small tests, and only after your Valid sends show clean results. A catch-all domain can't confirm individual mailboxes, so those addresses carry more uncertainty than a confirmed Valid address.

If you sequence through a tool with built-in checks, compare its results with an external verifier before you rely on either. Built-in verification in sequencing tools versus an external verifier covers that tradeoff.

Bottom line: Treat Risky as "unproven," not "bad." Test it in small batches and let the bounce rate decide.

How do you verify Apollo lists automatically through the API?

Use the API when exports repeat often enough that manual uploads become the bottleneck. The REST API supports single-email checks and bulk batches of up to 10,000 emails per request. It's part of email verification API and automation workflows, and it's available on Pro, which includes 100,000 API emails a month. The Free plan has no API access.

The arithmetic is simple: 100,000 emails ÷ 10,000 per request = 10 full batches a month before you hit the included allowance.

A typical script for a team that exports from Apollo regularly looks like this:

  1. Export the CSV from Apollo.
  2. Read the file and send it to the API in batches of up to 10,000 emails.
  3. Write the Valid, Risky and Invalid results to separate files.
  4. Import only the Valid file into your sending tool.

Get your key from the email verification API page. Because there are no native integrations, the script is the bridge between Apollo and your sending tool.

Bottom line: For regular exports, a short script that calls the API removes the manual upload step.

What do verification results not prove?

Verification shows that a mailbox probably exists and accepts mail. It doesn't show that the person consented to receive your email, or that your message is relevant to them.

In the US, the FTC's CAN-SPAM compliance guide sets the baseline. Your email needs accurate header information, a clear identification that it's an advertisement, a valid physical postal address, and a working opt-out that you honour within 10 business days. In the UK, the Information Commissioner's Office regulates electronic marketing under the Privacy and Electronic Communications Regulations. Those rules require consent for marketing to individuals, while corporate subscribers are covered by a different and lighter standard. Check the ICO guidance for your recipients. This article is not legal advice, so confirm the rules that apply to your contacts with counsel.

Verification supports good email verification compliance and hygiene practice, because removing bad addresses reduces complaints and misdirected mail. It doesn't replace an opt-out, a suppression list or a lawful basis for contacting people.

Bottom line: Verification tells you whether the mailbox exists. Compliance tells you whether you're allowed to write to it.

What are the most common mistakes when verifying Apollo lists?

Most failures come from skipping a step, not from the tool.

Bottom line: Build checks into the workflow so a skipped step can't reach a live send.

How we compared (and limitations)

This guide draws on public documentation: RFC 5321 and RFC 3463 for address and status-code standards, Google's sender guidelines, Amazon SES's published bounce thresholds, and the FTC and ICO guidance on electronic marketing. We haven't run controlled tests against Apollo's exports or labels, or compared verification providers head to head.

Unlimited Verifier's figures come from the company's published plan details. It states 99.5% accuracy for deep verification. That's the company's own figure, not an independent benchmark. The worked example uses illustrative counts. The plan limits and arithmetic are real, but your Valid, Risky and Invalid split will depend on your data.

Thresholds and timelines differ across platforms and change over time, so check your sending platform's current guidance before setting your own limits.

Bottom line: Use the framework and the arithmetic, then measure your own results on the first send.

Pre-send verification framework

  1. Export the Apollo list to CSV.
  2. Remove duplicate addresses.
  3. Remove suppressed addresses (unsubscribes, past hard bounces).
  4. Run syntax, domain, MX and SMTP mailbox checks.
  5. Sort results into Valid, Risky and Invalid.
  6. Drop Invalid addresses.
  7. Send to Valid first, in batches.
  8. Test Risky addresses in small monitored batches.
  9. Stop and review if hard bounces approach 2%.

Frequently asked questions

Is Apollo's email verification enough on its own?

Treat Apollo's labels as the vendor's claim, not a final check. Run your own verification on the full export before sending, because job changes, domain moves and closed mailboxes can make any database record stale. An independent verifier gives you a consistent standard across every source.

What does a Risky email mean?

A Risky result usually means the verifier could not confirm the mailbox either way. Catch-all domains are the most common cause, since the server accepts every address. Hold Risky addresses out of your main send and test them in small, monitored batches.

What is a catch-all domain?

A catch-all domain is one whose mail server accepts mail for any address, real or not. Verification cannot confirm individual mailboxes on these domains. Handle them as their own segment with lower volume and close bounce monitoring.

What bounce rate is considered safe?

Keep hard bounces under 2% across any send, and aim for under 1% on the first send to a new list. This ceiling is a practical recommendation rather than an official mailbox provider threshold, but it limits damage to your sending reputation.

Should I remove duplicates before verifying?

Yes. Deduplicate first so you do not pay to verify the same address twice or send it two emails. Also remove suppressed addresses such as previous unsubscribes and hard bounces before any new verification run.

Do I need to verify role addresses like info@ or sales@?

Verify them, but treat them separately. They usually route to shared inboxes that may not be monitored, so they often produce low replies and complaints. Consider excluding them from cold sequences or routing them to a different workflow.

What is SMTP mailbox verification?

SMTP mailbox verification connects to the recipient's mail server and checks whether it will accept mail for that address, without sending a message. Many servers limit or disguise these responses, so results are probabilistic rather than guaranteed.

How often should an Apollo list be re-verified?

Re-verify before each campaign if the list is more than a few weeks old, since people change jobs and mailboxes close over time. Lists that have been sitting unused should be checked again before any new send.

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.