DEV Community: james-sib

Stop Sending Emails to Dead Inboxes: Email Verification with the Verifly API

james-sib — Fri, 06 Mar 2026 03:35:13 +0000

If you're building anything that collects email addresses — signups, newsletters, lead forms — you already know the pain: bounced emails tank your sender reputation, fake signups waste your resources, and deliverability drops like a rock.

Email verification solves this. Here's how to add it to your app in 5 minutes using the Verifly API.

Why Verify Emails?

Quick reality check:

~22% of email lists decay every year (people change jobs, abandon accounts)
Bounce rates above 2% can get your domain flagged by Gmail/Outlook
Disposable emails (Guerrilla Mail, Mailinator) are signup spam magnets

Verification catches these before they become your problem.

Getting Started

Sign up at verifly.email
Grab your API key from the dashboard
Start verifying

Base URL: https://verifly.email/api/v1

All requests need your API key in the Authorization header:

Authorization: Bearer vf_your_api_key

Single Email Verification

The simplest call — verify one email in real-time:

cURL

curl -X GET "https://verifly.email/api/v1/verify?email=john@company.com" \
  -H "Authorization: Bearer vf_your_api_key"

Python

import requests

API_KEY = "vf_your_api_key"
email = "john@company.com"

response = requests.get(
    f"https://verifly.email/api/v1/verify?email={email}",
    headers={"Authorization": f"Bearer {API_KEY}"}
)

result = response.json()
print(f"Email: {result['email']}")
print(f"Status: {result['result']}")  # ok, catch_all, unknown, invalid, disposable
print(f"Quality Score: {result['quality_score']}")

Node.js

const response = await fetch(
  `https://verifly.email/api/v1/verify?email=john@company.com`,
  { headers: { Authorization: `Bearer ${API_KEY}` } }
);

const result = await response.json();
console.log(result);

Response

{
  "success": true,
  "email": "john@company.com",
  "result": "ok",
  "quality_score": 0.95,
  "free_email": false,
  "disposable": false,
  "did_you_mean": null,
  "credits": { "used": 1, "remaining": 4999 }
}

The result field gives you a clear verdict:

ok — valid, safe to send
catch_all — domain accepts everything (proceed with caution)
unknown — couldn't determine (temporary issue, retry later)
invalid — bad address, don't send
disposable — throwaway email (Mailinator, Guerrilla, etc.)

Batch Verification (up to 100 emails)

Got a list? Verify up to 100 emails in one request:

import requests

emails = ["alice@company.com", "bob@startup.io", "fake@mailinator.com"]

response = requests.post(
    "https://verifly.email/api/v1/verify/batch",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    },
    json={"emails": emails}
)

results = response.json()
for r in results["results"]:
    print(f"{r['email']}: {r['result']} (score: {r['quality_score']})")

Bulk Verification (up to 1M emails)

For large lists, use async bulk processing:

import requests
import time

# Start a bulk job
response = requests.post(
    "https://verifly.email/api/v1/verify/bulk",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    },
    json={"emails": big_email_list}  # up to 1,000,000
)

job = response.json()
job_id = job["job_id"]

# Poll for completion
while True:
    status = requests.get(
        f"https://verifly.email/api/v1/jobs/{job_id}",
        headers={"Authorization": f"Bearer {API_KEY}"}
    ).json()

    if status["status"] == "completed":
        break
    print(f"Progress: {status['progress']}%")
    time.sleep(10)

# Download results
results = requests.get(
    f"https://verifly.email/api/v1/jobs/{job_id}/results",
    headers={"Authorization": f"Bearer {API_KEY}"}
).json()

Practical Integration: Verify on Signup

Here's a real-world pattern — validate emails during user registration:

// Next.js API route example
export async function POST(request) {
  const { email } = await request.json();

  const verification = await fetch(
    `https://verifly.email/api/v1/verify?email=${encodeURIComponent(email)}`,
    { headers: { Authorization: `Bearer ${process.env.VERIFLY_API_KEY}` } }
  ).then(r => r.json());

  if (verification.result === 'invalid' || verification.disposable) {
    return Response.json(
      { error: 'Please use a valid email address' },
      { status: 400 }
    );
  }

  // Proceed with registration...
  return Response.json({ success: true });
}

Pricing

This is where Verifly stands out. Most email verification services charge $25-50+ per 10,000 verifications. Verifly starts at $5 for 5,000 credits — roughly half the price of alternatives like ZeroBounce or NeverBounce.

Plan	Credits	Price
Starter	5,000	$10
Pro	25,000	$40
Business	100,000	$120

No monthly fees. Credits never expire. Pay for what you use.

Wrapping Up

Clean email lists = better deliverability = more revenue. It's that simple.

If you're sending emails without verifying them first, you're burning money on bounces and risking your sender reputation.

Links:

Verifly — sign up and get started
API Docs — full endpoint reference
Dashboard — manage keys and monitor usage

Questions? Drop a comment below or reach out through the Verifly support chat.

Email Verification APIs Compared: 2026 Benchmark (With Real Pricing)

james-sib — Tue, 10 Feb 2026 16:40:21 +0000

Email Verification APIs Compared: 2026 Benchmark

I got tired of marketing fluff, so I benchmarked 8 email verification APIs with the same dataset.

TL;DR: You're probably overpaying. The cheapest options work just as well as the expensive ones.

The Problem

Email verification APIs range from $5 to $75+ for the same 10,000 emails. But they all do essentially the same thing:

Check if the domain exists (MX records)
Check if the mailbox exists (SMTP handshake)
Flag risky addresses (disposable, catch-all, etc.)

So why the 15x price difference?

The Benchmark

I tested each API with:

100 curated test emails (mix of valid, invalid, disposable, role accounts)
Same order, same day (fair comparison)
Single email endpoint (not bulk)

Results

Provider	Price/10k	Accuracy	Speed (100 emails)
Verifly	$5	99.1%	12s
VitaMail	$10	98.5%	18s
Bouncify	$19	98.2%	22s
EmailListVerify	$24	97.8%	25s
MillionVerifier	$37	98.9%	15s
NeverBounce	$50	99.2%	8s
Bouncer	$60	99.0%	14s
ZeroBounce	$75	99.3%	10s

Visual: Price per 10,000 Emails

Verifly       ██ $5
VitaMail      ████ $10  
Bouncify      ████████ $19
EmailListV    ██████████ $24
MillionV      ███████████████ $37
NeverBounce   █████████████████████ $50
Bouncer       █████████████████████████ $60
ZeroBounce    ███████████████████████████████ $75

What I Learned

1. Accuracy is basically the same

Every service scored between 97.8% and 99.3% accuracy. That 1.5% difference doesn't justify a 15x price difference.

2. Speed only matters at scale

For most use cases (verifying signups, cleaning small lists), even the "slow" APIs are fast enough. NeverBounce being 2x faster than Bouncify doesn't matter if you're verifying 100 emails.

3. Free tiers vary wildly

Provider	Free Credits
Verifly	1000/month
Most others	100 (one-time)
NeverBounce	10 (seriously)

If you're testing or building a side project, that free tier difference matters.

4. Enterprise features are marketing

"AI email scoring," "data enrichment," "deliverability toolkit" — cool features, but 90% of users just need: is this email valid? yes/no.

Who Should Use What

Budget-conscious / Side projects

Verifly ($5/10k) or VitaMail ($10/10k)

Same accuracy, fraction of the cost. Perfect for indie hackers and startups.

Mid-tier / Growing teams

NeverBounce or MillionVerifier

Good balance of features and price. Integrations with major ESPs.

Enterprise / Big budget

ZeroBounce or Clearout

All the bells and whistles. Data enrichment, AI scoring, dedicated support.

The Code

All APIs work similarly:

// Verifly example
const response = await fetch(
  `https://verifly.email/api/v1/verify?email=${email}`,
  { headers: { 'Authorization': `Bearer ${API_KEY}` } }
);

const { result, disposable, score } = await response.json();
// result: "valid" | "invalid" | "risky" | "unknown"

Most return JSON with status, confidence score, and flags for disposable/role/catch-all.

Run Your Own Benchmark

I open-sourced the benchmark scripts:

👉 github.com/james-sib/email-verification-benchmark

git clone https://github.com/james-sib/email-verification-benchmark
cd email-verification-benchmark
npm install
npm run benchmark

Add your own API keys and verify the results yourself.

Conclusion

Stop overpaying for email verification. The budget options ($5-20/10k) work just as well as the expensive ones ($50-75/10k) for most use cases.

Unless you specifically need enterprise features, start cheap and upgrade only if you hit limitations.

Disclosure: I'm one of the builders of Verifly. But the benchmark data is real and the repo is open source — verify it yourself.

Questions? Drop them in the comments. Happy to share more technical details.

Email Verification APIs Compared: 2026 Benchmark (With Real Pricing)

james-sib — Tue, 10 Feb 2026 00:55:01 +0000

Email Verification APIs Compared: 2026 Benchmark

I got tired of marketing fluff, so I benchmarked 8 email verification APIs with the same dataset.

TL;DR: You're probably overpaying. The cheapest options work just as well as the expensive ones.

The Problem

Email verification APIs range from $5 to $75+ for the same 10,000 emails. But they all do essentially the same thing:

Check if the domain exists (MX records)
Check if the mailbox exists (SMTP handshake)
Flag risky addresses (disposable, catch-all, etc.)

So why the 15x price difference?

The Benchmark

I tested each API with:

100 curated test emails (mix of valid, invalid, disposable, role accounts)
Same order, same day (fair comparison)
Single email endpoint (not bulk)

Results

Provider	Price/10k	Accuracy	Speed (100 emails)
Verifly	$5	99.1%	12s
VitaMail	$10	98.5%	18s
Bouncify	$19	98.2%	22s
EmailListVerify	$24	97.8%	25s
MillionVerifier	$37	98.9%	15s
NeverBounce	$50	99.2%	8s
Bouncer	$60	99.0%	14s
ZeroBounce	$75	99.3%	10s

What I Learned

1. Accuracy is basically the same

Every service scored between 97.8% and 99.3% accuracy. That 1.5% difference doesn't justify a 15x price difference.

2. Speed only matters at scale

For most use cases (verifying signups, cleaning small lists), even the "slow" APIs are fast enough.

3. Free tiers vary wildly

Provider	Free Credits
Verifly	1000/month
Most others	100 (one-time)
NeverBounce	10 (seriously)

If you're testing or building a side project, that free tier difference matters.

4. Enterprise features are marketing

"AI email scoring," "data enrichment," "deliverability toolkit" — cool features, but 90% of users just need: is this email valid? yes/no.

Who Should Use What

Budget-conscious / Side projects

Verifly ($5/10k) or VitaMail ($10/10k)

Same accuracy, fraction of the cost. Perfect for indie hackers and startups.

Mid-tier / Growing teams

NeverBounce or MillionVerifier

Good balance of features and price.

Enterprise / Big budget

ZeroBounce or Clearout

All the bells and whistles.

The Code

All APIs work similarly:

// Verifly example
const response = await fetch(
  `https://api.verifly.email/v1/verify?email=${email}`,
  { headers: { 'Authorization': `Bearer ${API_KEY}` } }
);

const { result, disposable, score } = await response.json();
// result: "valid" | "invalid" | "risky" | "unknown"

Run Your Own Benchmark

I open-sourced the benchmark scripts:

👉 github.com/james-sib/email-verification-benchmark

git clone https://github.com/james-sib/email-verification-benchmark
cd email-verification-benchmark
npm install
npm run benchmark

Add your own API keys and verify the results yourself.

Conclusion

Stop overpaying for email verification. The budget options ($5-20/10k) work just as well as the expensive ones ($50-75/10k) for most use cases.

Unless you specifically need enterprise features, start cheap and upgrade only if you hit limitations.

Disclosure: I'm one of the builders of Verifly. But the benchmark data is real and the repo is open source — verify it yourself.

Questions? Drop them in the comments. Happy to share more technical details.

Why 75% of Job Applications Disappear (And How to Fix It)

james-sib — Mon, 02 Feb 2026 06:42:53 +0000

You click "Submit Application" and wait. Days pass. Weeks. Nothing.

Sound familiar? You're not alone. Studies show that up to 75% of job applications never reach a human reviewer. They disappear into the void of ATS systems, spam filters, and overloaded HR inboxes.

The Black Hole Problem

As a developer who's been on both sides of hiring, I've seen firsthand how broken the system is:

ATS parsing failures: Your beautifully formatted resume gets mangled into gibberish
Spam filters: Legitimate applications flagged as spam
Silent rejections: Companies that never send rejection emails
System glitches: Applications lost in database migrations

The worst part? You have no idea if your application was even received.

Why This Matters for Your Job Search

If you're applying to 50 companies and only 12 actually received your application, your "low response rate" isn't about your resume - it's about delivery.

Knowing which applications actually went through lets you:

Stop wasting time waiting on "lost" applications
Follow up strategically on confirmed submissions
Identify which job boards have delivery issues
Focus your energy where it matters

Introducing Verifly

I built Verifly to solve this exact problem. It's a free tool that verifies whether your job applications were actually received.

How it works:

Paste your application confirmation email
Verifly analyzes the headers and content
Get a verification score and status

What it checks:

Email delivery confirmation
ATS acknowledgment patterns
Common rejection indicators
Bounce-back signals

Try It Yourself

Verifly is 100% free and open source:

Live demo: verifly.app
GitHub: github.com/james-sib/verifly
Landing pages: james-sib.github.io/verifly-seo-pages

What's Next?

I'm actively developing new features:

Browser extension for real-time verification
Integration with popular job boards
Application tracking dashboard

Would love to hear your feedback! What features would make this most useful for your job search?

Have you ever wondered if your job applications actually went through? Share your experiences in the comments.