Today we're releasing something we've wanted to do for a long time: a completely free, open source email verification tool.

No API keys. No usage limits. No monthly fees. Just clone the repo, run it, and verify as many emails as you want.

Why Open Source?

Email verification shouldn't be gatekept behind expensive SaaS subscriptions for basic use cases.

If you're a developer who needs to verify emails in a side project, you shouldn't have to pay $50/month. If you're a startup validating signups, you shouldn't need to worry about per-email costs eating into your runway.

We built Unlimited Verifier as a business, but we also believe the core verification logic should be accessible to everyone.

What's Included

The open source version includes everything you need for production-grade email verification:

Syntax Validation

Proper RFC 5322 compliant email syntax checking. Not just regex—actual parsing that handles edge cases like:

Quoted local parts ("john.doe"@example.com)
Plus addressing (user+tag@example.com)
International domain names (IDN support)
Subaddressing detection

DNS & MX Verification

Full DNS resolution including:

MX record lookup with priority ordering
Fallback to A/AAAA records when no MX exists
DNS timeout handling
DNSSEC validation support

SMTP Verification

Real SMTP handshake verification:

Connection to mail server
HELO/EHLO negotiation
MAIL FROM command
RCPT TO verification
Proper response code handling (250, 450, 550, etc.)

Catch-All Detection

Identify domains configured as catch-all by testing with a known-invalid address pattern. Know when SMTP verification can't give you a definitive answer.

Disposable Email Detection

Built-in database of known disposable email providers (Mailinator, Guerrilla Mail, 10MinuteMail, etc.) with regular updates.

Role-Based Address Detection

Identify role-based addresses like info@, sales@, support@ that might have different deliverability characteristics.

What's NOT Included

To be transparent, here's what the open source version doesn't include:

True-Send verification — Our catch-all verification via actual email delivery
Deep Verification — Advanced techniques for stubborn mail servers
Managed infrastructure — You host it yourself
Bounce processing — Real-time bounce handling
Dashboard & UI — It's a library/CLI, not a full application

These features require significant infrastructure and ongoing maintenance, which is why they're part of our paid service. But for 80%+ of email verification use cases, the open source version is all you need.

Getting Started

Installation

# Clone the repository
git clone https://github.com/unlimitedverifier/email-verifier

# Install dependencies
cd email-verifier
pip install -r requirements.txt

# Or with npm for the Node.js version
npm install @unlimitedverifier/email-verifier

Basic Usage (Python)

from email_verifier import verify_email

result = verify_email("test@example.com")

print(result.is_valid)        # True/False
print(result.is_deliverable)  # True/False/None (unknown)
print(result.is_catch_all)    # True/False
print(result.is_disposable)   # True/False
print(result.is_role_based)   # True/False
print(result.mx_records)      # List of MX records
print(result.smtp_response)   # Raw SMTP response code

Basic Usage (Node.js)

import { verifyEmail } from '@unlimitedverifier/email-verifier';

const result = await verifyEmail('test@example.com');

console.log(result.isValid);
console.log(result.isDeliverable);
console.log(result.isCatchAll);
console.log(result.isDisposable);
console.log(result.isRoleBased);

Bulk Verification

from email_verifier import verify_emails

emails = [
    "valid@gmail.com",
    "invalid@nonexistent-domain-xyz.com",
    "test@company.com"
]

results = verify_emails(emails, concurrency=10)

for email, result in results.items():
    print(f"{email}: {result.is_deliverable}")

CLI Usage

# Verify single email
email-verify check user@example.com

# Verify from file
email-verify bulk emails.txt --output results.csv

# With options
email-verify bulk emails.txt \
  --concurrency 20 \
  --timeout 10 \
  --output results.json \
  --format json

Configuration

SMTP Settings

from email_verifier import EmailVerifier

verifier = EmailVerifier(
    from_email="verify@yourdomain.com",  # Your sending domain
    helo_host="mail.yourdomain.com",     # HELO hostname
    timeout=10,                           # Connection timeout
    retries=2,                           # Retry attempts
)

Proxy Support

For high-volume verification, you might need to use proxies to avoid rate limiting:

verifier = EmailVerifier(
    proxy="socks5://user:pass@proxy.example.com:1080"
)

Custom Disposable List

Add your own disposable domains:

verifier = EmailVerifier(
    custom_disposable_domains=["tempmail.xyz", "fakeinbox.com"]
)

Self-Hosting Considerations

Running your own email verification has some nuances:

IP Reputation

Mail servers track who's connecting to them. If you verify too aggressively from a single IP, you might get rate limited or blocked.

Recommendations:

Use dedicated IPs with clean reputation
Implement rate limiting (we suggest 1-2 verifications per second per IP)
Rotate IPs for high-volume verification
Consider residential proxies for sensitive domains

DNS Caching

MX lookups can be slow. Implement caching:

from email_verifier import EmailVerifier
from email_verifier.cache import RedisCache

cache = RedisCache(host="localhost", port=6379)
verifier = EmailVerifier(cache=cache, cache_ttl=3600)

Greylisting

Some servers temporarily reject new senders. The library handles this automatically with configurable retry logic:

verifier = EmailVerifier(
    greylist_retries=3,
    greylist_delay=300  # 5 minutes between retries
)

Logging

Enable detailed logging for debugging:

import logging
logging.basicConfig(level=logging.DEBUG)

# Or to file
verifier = EmailVerifier(
    log_file="/var/log/email-verifier.log",
    log_level="INFO"
)

Performance Benchmarks

On a decent server (4 cores, 8GB RAM), expect:

| Concurrency | Emails/Second | Emails/Hour | |-------------|---------------|-------------| | 1 | 2-5 | 7,200-18,000 | | 10 | 15-40 | 54,000-144,000 | | 50 | 50-120 | 180,000-432,000 | | 100 | 80-180 | 288,000-648,000 |

Actual throughput depends on target server response times and your network latency.

Accuracy

The open source verifier achieves:

99.9% accuracy on syntax validation
99%+ accuracy on domain/MX verification
95-98% accuracy on SMTP verification (for non-catch-all)
100% catch-all detection (but can't verify individual addresses)

For catch-all domains, you'll get is_deliverable: None indicating we can't determine validity via SMTP. That's where our paid True-Send service comes in.

Contributing

We welcome contributions! Areas we'd love help with:

Additional disposable email providers
Improved international domain handling
Performance optimizations
Documentation and examples
Language bindings (Ruby, Go, PHP, etc.)

See CONTRIBUTING.md for guidelines.

When to Use the Paid Service

The open source verifier is great for:

Development and testing
Low-volume verification
Self-hosted infrastructure requirements
Learning how email verification works
Building custom verification pipelines

Consider Unlimited Verifier (paid) when you need:

Catch-all verification — True-Send actually delivers test emails
Managed infrastructure — We handle IPs, reputation, and scaling
Higher accuracy — Deep Verification for edge cases
Speed — Distributed verification across multiple servers
Support — Help when things go wrong

License

The open source email verifier is released under the MIT License. Use it however you want—personal projects, commercial applications, whatever.

We just ask that if you find it useful, consider starring the repo and spreading the word.

Get Started

Ready to verify emails without limits?

Open Source: github.com/unlimitedverifier/email-verifier

Managed Service: unlimitedverifier.com

Happy verifying.

Open Source Email Verifier