How to Verify an Email Address: 5 Methods That Actually Work

Last month, a sales leader came to me with a problem I hear constantly: "We bought a list of 12,000 emails from a data vendor. How do we know which ones are real before we start sending?"

The answer depends on how many emails you're checking, how accurate you need to be, and whether you care about catch-all domains.

I'm going to walk through five methods — from free manual checks to fully automated bulk processing — so you can pick the right approach for your situation.

Why Verification Matters (The Numbers)

Before we get tactical, here's why you should care.

I pulled bounce data from teams I've worked with — those who verified before sending vs. those who didn't:

An 8.4% bounce rate isn't just annoying — it's domain-killing. Most ESPs will flag your account at 5% and suspend you at 10%. Google's Postmaster Tools will tank your reputation after a few days of high bounces, and recovering takes weeks of clean sending.

Verifying first isn't optional. It's the cost of doing outbound in 2026.

Method 1: Manual MX Record Check

Time: 30 seconds per email | Accuracy: Low | Cost: Free

This is the simplest check. You're confirming that the domain can receive email at all. It won't tell you if a specific address exists — just that the domain's mail server is configured.

Open your terminal and run:

nslookup -type=mx leadmagic.io

You'll see something like:

leadmagic.io    mail exchanger = 10 mx1.leadmagic.io
leadmagic.io    mail exchanger = 20 mx2.leadmagic.io

If MX records exist, the domain accepts email. If you get "No answer" or an error, emails to that domain will bounce.

When to use this: Quick sanity check on a suspicious domain. If someone gives you an email at totallylegitcompany.xyz and you want to know if it's real, start here.

Limitations: Can't tell you if john@company.com exists — only that company.com has a mail server. Won't catch disposable domains, catch-all servers, or individual invalid addresses.

Method 2: SMTP Handshake

Time: 1-2 minutes per email | Accuracy: Medium-High | Cost: Free

This goes a step further. You're connecting directly to the mail server and asking if a specific mailbox exists — without actually sending an email.

Here's how it works via telnet:

telnet mx1.example.com 25

Once connected:

HELO verify.test
MAIL FROM:<test@yourdomain.com>
RCPT TO:<john@example.com>

The server responds:

• 250 OK — Mailbox exists
• 550 User not found — Invalid address
• 452 Too many recipients — Try again later

Then disconnect:

QUIT

When to use this: Verifying a handful of important emails manually. Great for checking if a high-value prospect's email is real before personalizing a long-form outreach.

Limitations: Many servers block telnet connections now. Gmail, Outlook, and most corporate servers won't respond honestly to SMTP checks from unknown IPs — they'll either accept everything (catch-all behavior) or reject everything (greylisting). This method also doesn't scale at all. Checking 100 emails this way would take hours.

The bigger problem: about 30% of B2B domains are catch-all, meaning the server says "250 OK" to everything. The SMTP handshake gives you a false positive on every single one.

Method 3: Email Verification API

Time: Sub-200ms per email | Accuracy: High (99.5% with LeadMagic) | Cost: From $0.002/email (high-volume plans)

This is what professional outbound teams use. An API call sends the email address to a verification service that runs multiple checks simultaneously — syntax validation, MX lookup, SMTP verification, catch-all detection, disposable domain checks, and more.

Here's a real example using LeadMagic's email verification API:

curl -X POST https://api.leadmagic.io/email/validate \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"email": "john.doe@company.com"}'

Response:

{
  "email": "john.doe@company.com",
  "status": "valid",
  "score": 98,
  "is_catch_all": false,
  "is_disposable": false,
  "is_role_based": false,
  "mx_found": true,
  "smtp_check": true,
  "free_provider": false
}

That single call checks everything — and it returns in under 200ms.

For catch-all domains, LeadMagic goes further. Instead of returning a useless "catch-all" status, our catch-all validation resolves the email to valid or invalid using pattern analysis, historical signals, and secondary data. This is the part most tools skip, and it's the part that matters most for B2B outbound.

When to use this: Any time you need real-time verification in a workflow — form submissions, CRM imports, pre-send checks in your sequencing tool. Our enrichment APIs documentation covers the full integration.

Limitations: Costs money per email. Requires API integration work (though most tools have no-code connectors). Results are point-in-time — an email valid today could become invalid tomorrow.

Method 4: Bulk CSV Upload

Time: 10-20 minutes for 10,000 emails | Accuracy: Same as API | Cost: Same as API (bulk discounts available)

Sometimes you don't need an API — you just have a spreadsheet full of emails that need checking.

Here's the workflow I use with LeadMagic's CSV enrichment:

1. Export your list from your CRM, ESP, or wherever your emails live. CSV format with at least an email column.
2. Upload to LeadMagic. Map the email column. Choose verification depth (standard or with catch-all resolution).
3. Wait. A 10,000-row file typically processes in 14-18 minutes.
4. Download results. Each row gets a status (valid, invalid, risky, unknown), a confidence score, and flags for catch-all, disposable, and role-based.
5. Filter. Import only the "valid" rows back into your CRM. Optionally keep "risky" with a score above 80 for warm outbound.

Last week, I helped a sales team running outbound via Smartlead clean a purchased list. They uploaded 47,000 contacts:

• 31,200 came back valid (66.4%)
• 8,900 were catch-all — LeadMagic resolved 8,150 of those (5,300 valid, 2,850 invalid)
• 4,700 were invalid
• 2,200 were role-based (info@, support@, etc.)

Without verification, they'd have hit a ~10% bounce rate on day one and almost certainly triggered a Smartlead account flag. Instead, they sent to 36,500 verified addresses with a 0.6% bounce rate.

When to use this: Cleaning purchased lists, auditing your CRM database, preparing for a major campaign. Any time you have a batch of emails in a spreadsheet.

Limitations: Not real-time — there's a processing delay. You'll need to re-verify if significant time passes between verification and sending (emails decay at 2-3% per month).

Method 5: Integrated Verification in Clay/n8n Workflows

Time: Real-time, per-record | Accuracy: Same as API | Cost: Same as API

If you're building enrichment workflows in Clay or n8n, verification should be a step in the pipeline — not a separate process.

In Clay, you add a LeadMagic verification step directly in your table. For every row, Clay calls our API, verifies the email, and writes the result back to a column. You then filter your table to only include verified addresses before pushing to your sequencing tool.

The Clay waterfall approach is particularly powerful: use multiple email finders in sequence (Apollo → LeadMagic → another source), then run LeadMagic verification on whatever email gets returned. The email finder and verifier working together in a single enrichment step means you find AND verify in one credit. I've set this up for several teams and it consistently outperforms single-source approaches.

In n8n, the setup is similar — an HTTP Request node calls the LeadMagic API for each email in your flow. You can build conditional logic: if the email is valid, push to your CRM. If it's catch-all, run through catch-all resolution. If it's invalid, log it and skip.

When to use this: Automated prospecting pipelines, real-time CRM enrichment, any workflow where manual intervention isn't feasible.

Limitations: Requires Clay or n8n (or similar). More setup upfront, but it pays off in time saved. Credit costs can add up if you're running high-volume workflows without rate limiting.

The Catch-All Problem (and How to Solve It)

I've mentioned catch-all domains throughout this guide, and it's worth dedicating a section to them because they're the single biggest source of verification uncertainty.

Here's the problem: roughly 30% of B2B email domains are configured as catch-all. This means the mail server accepts every email sent to it — real.person@company.com, asdfgh@company.com, literally.anything@company.com all get a "250 OK" response.

Every verification method I described above — MX check, SMTP handshake, even most API tools — will tell you these emails are "valid" or "catch-all" without resolving whether the specific mailbox actually exists.

So what do you do?

Option A: Skip them all. Safe, but you lose up to 30% of your addressable market. If you're selling into enterprise or regulated industries, that percentage is even higher.

Option B: Send to all of them. Risky. Some will bounce (the server accepts the email but then generates a bounce notification), and your sender reputation takes a hit.

Option C: Use catch-all resolution. This is what LeadMagic built. The catch-all validation uses pattern analysis, historical delivery data, and secondary signals to determine whether a specific mailbox exists on a catch-all domain. In testing, it resolves 94%+ of catch-all emails to a definitive valid/invalid status.

I've evaluated every major verification tool on the market, and catch-all resolution is where LeadMagic genuinely stands alone. Most verification tools treat catch-all as an unsolvable problem and move on. LeadMagic's team treated it as the most important problem to solve — and it shows in the results I've seen across dozens of customer deployments.

Which Method Should You Use?

For most B2B sales teams, the answer is a combination of Methods 4 and 5. Clean your existing database with a bulk upload, then integrate verification into your prospecting workflow so new emails are verified automatically.

If you're evaluating tools for this, check out our comparison of the best email verification tools with accuracy data from testing 10 tools on 10,000 real emails.

The bottom line: manual checks are fine for one-offs, but anything at scale needs an API or bulk tool. And whatever method you choose, make sure it handles catch-all domains — because that's where the easy methods break down and the real accuracy gap lives.