Vrfymail vs Emailable: Pricing, Free Tier, Latency (2026)

By Adrian Crismaru · Founder, vrfymail · Published 2026-05-16

Emailable is the verifier that PAYG-curious founders end up on after their second “I need credits that don’t expire” search. Pay-as-you-go from 250 free signup credits, “unknown” verdicts don’t bill, credits roll over forever — the pricing model is the product. Their accuracy benchmarks are competitive, and the team has been quietly shipping since 2017.

For everyone else — indie SaaS founders running vrfymail behind a Resend webhook, growth engineers wiring real-time signup gating in a Next.js form, ESP operators chasing a free-tier that survives past the demo — the math runs through monthly cost and architecture, not credit packs. We’ll cover the five things that actually decide which API ships: pricing, p50 latency, verdict semantics, disposable-domain freshness, and bounce-feedback handling. Then a clear “pick this if” section and an FAQ.

This is a side-by-side, not a hit piece. Skip to “Where Emailable still wins” if PAYG-no-subscription is your hard requirement.

Pricing: monthly free tier vs lifetime sample

Emailable is PAYG-first, with an optional 15%-discount subscription.

Vrfymail is subscription-only.

Run the comparable bands:

• At 5,000 verifies, first month: Emailable $30. Vrfymail $0 (free tier covers it).
• At 10,000 verifies/month, ongoing: Emailable $48 (or ~$41 on subscription). Vrfymail $9.
• At 50,000 verifies/month: Emailable $200 (or ~$170 on subscription). Vrfymail $29.
• At 250,000 verifies/month: Emailable $750 (or ~$638 on subscription). Vrfymail $99.
• At 500,000 one-shot bulk cleanup: Emailable $1,250. Vrfymail charges the Business plan + overage; total ~$224 — assuming you only need the 500k in a single month, then drop back.

Parity points:

• Unknown verdicts don’t bill on either. Emailable explicitly: “Unknown results are free.” Vrfymail’s refundUsage() does the same. Parity.
• Both offer duplicate refunds. Emailable on bulk lists; vrfymail through per-customer 24h caching (same address from same key = one billable call). Parity.

The free tier is where the two diverge most. Emailable gives 250 verifies once. That’s a demo allowance — enough to test the API, not enough to gate a real signup form for a real product. Vrfymail’s 5,000/month, no card, every month, is a workable production tier for an indie SaaS through its first six months. First 100 vrfymail signups get 2× free quota (10,000/month) for life.

Latency: edge vs unspecified

Emailable doesn’t publish a p50 latency number. Their docs describe the API as fast without committing to a measurable target. Independent testing puts Emailable’s real-time API in the 200-400ms range — normal for regional infrastructure, slower than edge.

Vrfymail’s /v1/check returns in ~50ms p50 (cache hit) and ~250ms p99 (cold path with MX lookup + Spamhaus DBL probe in parallel). It runs on Cloudflare Workers in 300+ POPs with no cold starts. The hot path is D1 reads only — no DNS, no DBL probe — for any address already seen by your customer or by the global cache.

For real-time signup gating, 50ms is invisible inside a form submit; 400ms is a perceptible pause. The mechanical reason for the delta: vrfymail parallelizes the MX and DBL probes on cold paths instead of serializing them. Parallel-worst-case is shorter than sum.

For bulk list cleaning at 100k+ addresses, the latency gap is invisible — both APIs handle the workload concurrently and the wall-clock is dominated by request fan-out, not per-verify time.

Verdict semantics: similar shapes

Both APIs return a verdict with a reason code.

Vrfymail returns one of deliverable | undeliverable | risky | unknown with a machine-readable reason (e.g., role_account, plus_addressing_rejected, disposable, previously_bounced) and a pre-mapped reason_message you can show users verbatim.

Emailable returns deliverable | undeliverable | risky | unknown plus their own reason taxonomy. Functionally similar; the handler logic translates verbatim.

Where vrfymail extends the surface: strict mode for B2C signup gating. Opt-in via strict: true, returns a decomposed flag set on the local-part (plus_alias, gmail_dot_alias, throwaway_local, sequential_run, repeated_char_run, all_digits_local, very_short_local, high_digit_ratio). Catches ada+throwaway@gmail.com, qwerty@gmail.com, test@gmail.com — the patterns disposable lists miss because they live in the local-part, not the domain.

Emailable’s equivalent is a broader low_quality heuristic. Single flag, similar territory, less granular handling.

Disposable detection: similar baselines, different freshness loops

Both APIs catch the disposable-domain baseline. The difference is in the live-update model.

Emailable maintains their own disposable list with reasonable refresh cadence. Like every verifier in this space, they catch new providers as they show up in customer traffic. They’ve been at it since 2017, so the coverage is mature.

Vrfymail’s domains table is five overlapping channels:

1. Bundled seed — ~121k entries from the disposable-email-domains npm package.
2. Daily scrapers — 1secmail / mail.tm / mail.gw public APIs hand out daily inbox domains; we capture them.
3. Spamhaus DBL (live) — every verify call that hits DBL persists the domain.
4. Customer consensus — ≥3 distinct customers POSTing hard_bounce or spam_complaint on the same domain in 30 days promotes it to is_spam_trap=1. Free-mail excluded.
5. CT-log scanner — hourly polls of crt.sh for newly-issued TLS certs matching throwaway-mail patterns.

Total today: 238K+ entries, growing daily.

The practical difference: a brand-new throwaway domain registered yesterday and issued a TLS cert this morning is in vrfymail’s database by tonight (CT-log scanner). Emailable’s coverage catches up over weeks as the domain shows up in customer-traffic and gets added.

For B2C signup gating where the next disposable provider launches tomorrow, that lag matters.

Bounce-webhook handling: per-customer overlay

This is the architectural difference that compounds over time.

Vrfymail’s /v1/report-bounce is a per-customer overlay. Forward your ESP’s bounce webhook (Resend, Postmark, SendGrid, Mailchimp, Mailgun, Loops, customer.io) once, and from then on every /v1/check from your key checks the address against YOUR bounce history before scoring. The signal is scoped to your api_key_id. Your bounces don’t leak to other customers; their bounces don’t show up in your checks.

Emailable doesn’t have an equivalent endpoint. Their model is verify-on-demand: post an address, get a verdict, the verifier doesn’t remember your previous bounces unless you maintain that data on your side. Plenty of teams do exactly that — keep a local bounce table, check it before calling the verifier — but it’s work you write yourself instead of an API endpoint.

For B2B SaaS with steady signup traffic and an active ESP relationship, the overlay is the meaningful feature. Your verifier gets smarter from your sends. Without the loop, the verifier is stateless.

Where Emailable still wins

Three scenarios where Emailable is the right pick:

• Bursty PAYG with no monthly commit. If your verify volume is genuinely sporadic — clean a list every six months, no signup form running continuously — Emailable’s credits-never-expire model is the right shape. Vrfymail’s subscription bills monthly whether you use it or not.
• One-shot 500k+ list cleanup. At 500k+ credits, Emailable’s per-email rate drops to ~$0.0025 — competitive with the bottom of the PAYG market. Vrfymail’s monthly subscription model isn’t designed for this — you’d buy the Business plan ($99 for 250k) and pay overage for the remaining 250k. The total comes out lower in $ terms but you’re committing to the subscription month, not buying a credit pack.
• Established product, mature integration list. Emailable has been shipping since 2017 and has more pre-built ESP/CRM connectors than vrfymail. If you need a one-click Klaviyo or HubSpot integration today and don’t want to write the webhook glue, Emailable might save 30 minutes.

For real-time signup gating, ESP-integrated bounce-feedback, free-tier-for-indie-SaaS, sub-100ms latency budgets, the math points to vrfymail.

When to pick which

FAQ

Is Emailable’s free tier enough to start with?

250 verifies, one-time, intended for testing the API shape. Not enough to gate a real signup form for any product with actual traffic. Vrfymail’s free tier is 5,000/month, every month, no card — workable for production through the first six months of an indie SaaS.

Do unknowns bill on Emailable?

No. Emailable explicitly doesn’t bill unknown verdicts. Vrfymail’s refundUsage() does the same. Parity on this — both verifiers refund when the pipeline can’t reach a verdict.

Which is cheaper at 10,000 verifies a month?

Emailable $48 PAYG (or ~$41 on subscription). Vrfymail $9. The math holds at every band up to ~500k/month, after which Emailable’s bottom PAYG rate gets competitive with vrfymail’s Enterprise quote.

Does Emailable have a real-time API or is it just bulk?

Both. Their real-time API endpoint handles per-call verification; the bulk UI handles list cleanup. Real-time latency isn’t published, sits in the 200-400ms range in independent testing.

Will my ESP bounce webhook work with Emailable?

Emailable integrates with several ESPs for bulk-list-cleaning workflows. They don’t have a per-customer bounce-overlay endpoint — bounce events don’t feed back into the verifier as a “remember this for next time” signal. If that loop matters, vrfymail’s /v1/report-bounce is the closer fit.

Can I switch from Emailable to vrfymail mid-project?

Yes. Both APIs return a four-state verdict with reason codes; the handler logic translates directly. Plan on ~30 minutes of code change (endpoint URL, auth header, body shape) plus your ESP webhook re-pointed at /v1/report-bounce.

When the math points to vrfymail

At 5,000 verifies/month you’re free on vrfymail and paying $30 on Emailable. At 50k you’re paying $29 vs $200. At 250k it’s $99 vs $750. The latency advantage compounds — synchronous signup-gating becomes practical at 50ms; at 400ms you start engineering around it.

Try vrfymail free — 5,000 verifies/month, no card. Get an API key →

Updated 2026-05-16