DeliverabilityUpdated · 7 min read

How We Verified 50,000 Email Probes Without Paying $400/mo

Why finding 10,000 real B2B emails actually takes ~50,000 SMTP email verification probes — and the paced, domain-cached architecture that cuts cost dramatically.

MT
Mailbase Team
smtp email verification
On this page · 9 sections

Overview

If you build B2B prospecting or lead-enrichment software, you hit an uncomfortable math problem almost immediately: verifying 10,000 business contacts rarely means running 10,000 checks. When you resolve a company website and test candidate personal address patterns (first.last@, f.last@, first@, last@, contact@), you easily run **5 checks per contact — 50,000 probes to land 10,000 verified emails**.

At typical instant verification API rates ($0.008 to $0.01 per address), 50,000 checks cost **$400 to $500 per run**. Paying that much makes affordable B2B prospecting impossible. Here is the exact cascade, domain-fact cache, and slow-pacing architecture we built to run 50,000 SMTP probes reliably at minimal cost — without burning our sending IP.

Step 1: Eliminate 40% of dead work before opening a single socket

Every unnecessary TCP connection to port 25 wastes time and burns IP goodwill. Our verifier runs a strict cheap-to-expensive cascade before any remote mail server is ever touched:

First, syntax validation and disposable/placeholder filtering discard malformed strings and template garbage (contact@yoursite.com). Second, a cached DNS MX lookup discards expired or non-receiving domains (NXDOMAIN or RFC 7505 null MX 0 .) in milliseconds for zero cost. Third — and this is the piece most naive scripts miss — we consult a persistent **domain-facts table** before probing.

A domain's mail configuration rarely changes overnight. If we already proved a domain is a **catch-all**, we cache that fact for **30 days** and never probe guessed patterns on it again (a 250 OK on a catch-all proves nothing). If a mail server was unreachable or refused connections, we cache that cooldown for **6 hours** instead of hammering it on the next 40 rows.

Cascade StageCost / LatencyWhat It Eliminates or Caches
1. Syntax + placeholder filter0 ms · local CPUTypos, spaces, theme placeholders, disposable domains
2. Cached DNS MX lookup~15 ms · free DNSExpired domains, parked sites, null MX (0 .)
3. Domain-facts cache~2 ms · PostgresKnown catch-all (30d TTL) & unreachable hosts (6h TTL)
4. Single-session SMTP probe1 socket per domainControl address + up to 5 candidate RCPT TO checks in one session

Step 2: One SMTP session per domain + random control mailbox first

When you test five name permutations at acme.example, opening five separate TCP connections looks like a dictionary attack and gets your IP throttled immediately. Instead, open **one** SMTP conversation per domain: EHLO → MAIL FROM → send RCPT TO for a random impossible control address (zz-nonexistent-9f3a@acme.example) → then send RCPT TO for each candidate → close cleanly with QUIT before DATA.

That single control check is what separates honest verification from false positives. If the MX server returns 250 to the impossible address, the domain is a **catch-all**: mark all guessed permutations as unknown (never verified), and only accept an address on that domain if it was explicitly published on the company's own site. If the control returns 550 5.1.1 and alice.martin@acme.example returns 250, you have a genuine, high-confidence verified personal mailbox.

Step 3: Why slow pacing (~5 probes/min) beats instant APIs on economics

Why do commercial email verification APIs charge $8–$10 per 1,000 checks? Because customers demand sub-second synchronous responses at huge concurrency, which requires maintaining large rotating IP pools, residential/ISP partnerships, and constant blocklist remediation.

Flip the product constraint: **most B2B lists and nightly hygiene jobs do not need an answer in 400 milliseconds — they need an accurate answer by tomorrow morning.** By isolating SMTP verification onto a dedicated probe server with clean reverse DNS (completely separate from our Amazon SES sending infrastructure) and pacing probes slowly — around **5 addresses per minute**, respecting greylisting (450/451) and backing off automatically on policy refusals — a batch of 50,000 probes completes quietly over a day or two without tripping provider defenses and without $400/month verification bills.

The takeaway for SaaS builders: before paying enterprise API rates for synchronous speed you do not actually need, ask whether an asynchronous, gently paced queue changes the math by an order of magnitude. And whichever verifier you use, always keep hard bounces below Amazon SES's 5% review threshold — see our guide on email bounce management.

Common mistakes

  • Skipping SPF, DKIM, and DMARC, or assuming they're a one-time setup.
  • Sending real volume from a brand-new, un-warmed domain.
  • Reusing a stale list without re-verifying, so bounces spike.
  • Ignoring complaint rate until a single bad campaign sinks the domain.

Sources and further reading

Official docs for current setup details, pricing, and API behavior — verify specifics there, since they change.

Related guides

More on smtp email verification and the surrounding deliverability workflow:

Questions

About this page.

Why does verifying 10,000 B2B prospects require ~50,000 SMTP probes?
When a company website does not publish a named personal email, enrichment tests 4 to 5 common address patterns (first.last@, f.last@, first@, etc.) plus a random catch-all control check. Across 10,000 prospects, that easily totals 50,000 RCPT TO probes.
Should SMTP verification ever run from your email sending IP?
Never. Always isolate port 25 verification probes on a completely separate IP with its own reverse DNS, away from your transactional or campaign sending infrastructure (such as Amazon SES), so probe throttling can never touch real email delivery.
How do you detect a catch-all domain during SMTP verification?
Probe a random, impossible mailbox on the same domain inside the same SMTP session. If the mail server answers 250 OK to that nonexistent address, it is a catch-all — meaning 250 OK on a guessed address proves nothing.
Why is slow async SMTP verification so much less expensive than instant APIs?
Instant APIs must maintain massive rotating IP pools to absorb high-concurrency bursts without getting rate-limited. Pacing probes gently (~5 per minute) in an async background queue respects remote MX servers and eliminates most of that infrastructure overhead.