Article
Best Open Source Email Verification Tools in 2026 (Compared)
By Unlimited Verifier Team ·

Summary
Unlimited Verifier is the best open source email verification option for most teams, because its engine is published on GitHub while SMTP checks run on its hosted service. Self-hosters can use Reacher (check-if-email-exists), and code libraries like Truemail, AfterShip's email-verifier, and email-validator cover different layers of the job.Unlimited Verifier is the best open source email verification option for most teams, because its verification engine is published on GitHub while the SMTP mailbox checks run on its hosted service, so you can audit the code without operating mail-probing infrastructure yourself. If you need a self-hosted mailbox checker instead, Reacher's check-if-email-exists is the most direct option in this list, and the libraries below each cover a different layer of the job.
This guide is for engineers, list owners, agencies and SaaS teams who want open source email verification. It explains what "open source" actually buys you, what self-hosting costs in practice, and where each option falls short.
Quick answer
- Best overall: Unlimited Verifier. Its engine is published on GitHub, and standard verification is unlimited on every plan, including Free.
- Best self-hosted mailbox checker: Reacher (check-if-email-exists), a Rust project. Check its AGPL-3.0 licence before you modify it or run it as a network service.
- Best code libraries: Truemail (Ruby), AfterShip's email-verifier (Go), email-validator (Python) and validator.js (JavaScript). Truemail and AfterShip can run SMTP checks; email-validator stops at syntax and DNS; validator.js checks syntax only.
- The hidden cost: running SMTP probes yourself means managing port 25 access, throttling and sending reputation. That operational work usually costs more than the software.
Quick picks
- Best hosted option with an open-source engine: Unlimited Verifier
- Best self-hosted SMTP checker: Reacher
- Best for Ruby or Rails signup validation: Truemail
- Best for Go services: AfterShip email-verifier
- Best for Python pipelines (syntax and DNS only): email-validator
- Best for browser and Node form checks: validator.js
- Best if you have engineering time and need full control: a DIY checker built on smtplib and dnspython
| Tool | Starting price | Free tier | Catch-all handling | Best for |
|---|---|---|---|---|
| Unlimited Verifier | $0; Pro $29/mo ($25/mo billed annually) | Yes: 25 lists/mo × 150 emails, plus 750 deep verifications | Detects catch-alls and sorts them into the three-bucket output | Open-source transparency without running SMTP infrastructure |
| Reacher (check-if-email-exists) | Free to self-host; hosted option varies | Open-source use | Varies (check the project's current output fields) | Self-hosted mailbox checks |
| Truemail | Free (open source) | N/A (library) | Varies (depends on configuration) | Ruby and Rails signup validation |
| AfterShip email-verifier | Free (open source) | N/A (library) | Varies (check the README) | Go backends |
| email-validator | Free (open source) | N/A (library) | None (no mailbox check) | Python syntax and DNS checks |
| validator.js | Free (open source) | N/A (library) | None (syntax only) | Browser and Node syntax checks |
| DIY smtplib + dnspython | Your servers and engineering time | N/A | Only what you build | Full control for engineering teams |
Bottom line: open source gives you readable code and no licence fee. It does not give you free mailbox verification at scale.
How we compared (and limitations)
Every option was judged on the same criteria:
- Layers checked: syntax, domain/MX, SMTP mailbox, disposable and role-based flags, and catch-all handling.
- Operational burden: what you must host, throttle, monitor and maintain yourself.
- Licence: whether you can use the code commercially and what obligations apply if you modify it or run it as a service.
- Workflow fit: whether it handles a batch file, a signup form or a backend service.
- Honest limits: what it cannot tell you about a mailbox.
Limitations. This comparison is based on public documentation, repository READMEs and vendor-published information. We have not benchmarked these tools or measured their accuracy on any list. Where a vendor publishes a figure, we present it as that vendor's claim. Repositories, licences and feature lists change, so confirm current details before you depend on a tool. Open source tells you how a check works, not how accurate it is.
Bottom line: use this list to build a shortlist, then test any tool against a labeled sample of your own list.
What does open source actually buy you in email verification?
Open source means you can read and modify the checks. It does not make results more accurate, and it does not make mailbox checks free to run at scale. Email verification has three layers. Syntax is defined by address standards. Domain checks look up MX records. The mailbox check opens an SMTP session and asks the receiving server whether it would accept a recipient, using the RCPT TO command described in RFC 5321.
The first two layers are deterministic, so open source code handles them well. The third depends on each receiving server's policies. A 250 reply means accepted, a 5xx reply means rejected, and a 4xx reply is temporary and should be retried later. A 250 from a catch-all domain proves only that the server accepts everything, not that your specific mailbox exists. Large consumer providers, Gmail among them, generally do not give reliable RCPT TO answers to outside probes. No open source code can change that.
Licences matter as much as code. MIT-style licences allow commercial use with few conditions. AGPL requires you to share modified source code if users interact with it over a network. Check the licence before you build a product on a tool.
Cost also moves rather than disappears. Removing the licence fee shifts spending to servers, IP reputation and engineering time. If you're comparing that against hosted per-check pricing, email verification pricing models explain how the two add up over a year.
Bottom line: open source buys transparency and control. Accuracy still depends on the mail servers you probe, and self-hosting moves the cost to your team.
What are the best open source email verification tools?
1. Unlimited Verifier (best overall)
Unlimited Verifier is a hosted bulk verifier whose verification engine is published on GitHub. You can read how the checks are implemented, and you don't have to host the SMTP probing yourself. You upload a CSV or Excel file of up to 10MB, the email column is detected automatically, and every address is sorted into Valid, Risky or Invalid. Catch-all detection is part of the check, so catch-all addresses are treated as a segment to review rather than as confirmed mailboxes.
Key features
- Standard verification unlimited on every plan, including Free
- Syntax, domain, MX and SMTP mailbox checks, with catch-all detection
- Disposable and role-based flagging
- Export as CSV, Excel or JSON
- REST API with API keys: single checks, and bulk batches of up to 10,000 emails per request (Pro)
- Free single-email checker and free domain blacklist checker
Pros
- The engine is auditable, and you don't have to run probes from your own IP
- The three-bucket output maps to send, segment and suppress decisions
- The Free plan can handle a small weekly delta: 25 lists × 150 emails is 3,750 emails a month
Cons
- No native ESP, CRM or Zapier integrations; the workflow is export, verify and re-import, or call the API
- Free results are kept for 24 hours and Pro results for 30 days, so download exports promptly
- The Free plan has no API access
- Per-list caps of 150 emails on Free and 25,000 on Pro mean large lists must be split
Best for: teams that want open-source transparency without operating mail-probing infrastructure.
Where it falls short: teams that need control over the probing itself, such as which sending IP is used, how timing is managed, or data that must stay on their own servers.
Pricing: Free ($0) includes 25 lists a month of up to 150 emails each, plus 750 deep verifications. Pro is $29/month, or $25/month billed annually, and includes unlimited lists of up to 25,000 emails each, 25,000 deep verifications a month, and API access for 100,000 emails a month. The company states 99.5% accuracy for deep verification. That is Unlimited Verifier's own claim, so test it on your own list.
Worked example. A 60,000-address list on Pro splits into three files: 25,000 + 25,000 + 10,000. Four quarterly full-list passes come to 240,000 standard checks. Adding 700 weekly signups (700 × 52 = 36,400) gives 276,400 checks a year. Standard verification is unlimited, so the annual cost is $25 × 12 = $300. Save deep verifications for the Risky bucket, where they change decisions.
Bottom line: the most practical route to open-source transparency without running a mail-probing service.
2. Reacher (check-if-email-exists)
Reacher's check-if-email-exists is a Rust project that performs syntax, MX and SMTP-level checks and returns a reachability verdict for each address. Its output also includes disposable and role-based indicators, per the project's documentation. Its maintainers also offer a hosted option, so check current terms if you outgrow self-hosting.
Key features
- Self-hostable SMTP-level mailbox checks
- Syntax, MX and SMTP verification
- A per-address reachability verdict
- Disposable and role-based indicators, per its documentation
Pros
- Deep SMTP-level checking in a self-hosted tool
- Rust suits concurrent network work, so it can run many checks efficiently
- A hosted option from the same project if you'd rather not run it yourself
Cons
- The repository is licensed under AGPL-3.0. If you modify it and offer it over a network, you must share your source. Confirm with counsel.
- Your server's IP and HELO identity become your sending reputation with mail servers
- Catch-all and unknown results need your own interpretation rules
Best for: engineering teams that want a self-hosted SMTP checker.
Where it falls short: teams without anyone to operate, monitor and tune a probing service.
Pricing: free to use under its open-source licence. Infrastructure costs and any hosted plan are separate; check current terms.
Tip: label about 200 addresses from your own bounce history, then run them through the tool. Count the false "valid" results first. A false valid becomes a bounce, which is the outcome you're trying to prevent.
Bottom line: the most direct self-hosted mailbox checker, if you can run it responsibly.
3. Truemail
Truemail is a Ruby gem, published under the MIT licence per its repository, for validating addresses inside Ruby applications. It runs layered validation covering format, MX, blacklists and SMTP, and you choose which layers run. That configurability is what makes it practical for Rails signup forms and background jobs.
Key features
- Configurable validation layers
- Blacklist and disposable-domain filtering
- Ruby and Rails integration
- MIT licence, per its repository
Pros
- You can balance cost, speed and strictness by enabling or disabling layers
- Permissive licence with few obligations
- Fits signup validation inside an existing Rails codebase
Cons
- It is a library, not a bulk CSV tool. You build the batch runner yourself.
- The SMTP layer inherits port 25 and reputation issues from any self-hosted probe
- Ruby-only, so it doesn't help a mixed-language stack
Best for: Ruby and Rails apps validating addresses at signup.
Where it falls short: marketers cleaning a spreadsheet.
Pricing: free as open source.
Tip: order the layers from cheapest to most expensive: format, then MX, then blacklist, then SMTP. Addresses that fail early never reach the probe, which cuts both load and throttling risk.
Bottom line: a clean fit for Rails signup flows. For cleaning a list, use a batch tool instead.
4. AfterShip email-verifier (Go)
AfterShip's email-verifier is a Go library that performs syntax, MX and SMTP checks and includes disposable and role-based detection, per its README. It suits Go backends that need signup-time or batch checks inside an existing service, rather than a separate verification server.
Key features
- Go library for syntax, MX and SMTP checks
- Disposable and role-based detection, per its README
- Designed to be called from application code
Pros
- Go's concurrency model suits batch checking inside a service
- Compiles into your existing backend, so there's no separate process to run
- Easy to wrap with your own caching and retry logic
Cons
- You own retries, rate limits and handling of temporary (4xx) failures
- Confirm the current checks and licence in the repository before embedding it in commercial code
- Useful only if your team already operates Go services
Best for: Go backends that need signup-time and batch verification.
Where it falls short: teams without Go skills or a backend to host it.
Pricing: free as open source. Hosting and engineering time are the real costs.
Tip: cache MX lookups per domain. Most consumer lists are dominated by a handful of large domains, so a per-domain cache removes a large share of DNS queries.
Bottom line: a practical backend library when the checks belong inside your own Go service.
5. email-validator (Python)
email-validator is a Python package that checks address syntax against the relevant standards, normalizes addresses and supports internationalized domain names. With its deliverability option enabled, it also checks DNS. It does not open an SMTP session to confirm a mailbox.
Key features
- Standards-based syntax validation
- Address normalization
- Internationalized domain support
- Optional DNS deliverability check
Pros
- Reliable syntax and DNS checks for data pipelines
- No probing of third-party mail servers, so no sending-reputation risk
- Lightweight to add to an existing Python job
Cons
- No mailbox check: a well-formed address at a real domain can still be dead
- No catch-all detection
- You need a second layer to make the Valid/Risky decision
Best for: Python pipelines that need syntax and domain existence checked before a send.
Where it falls short: confirming that a specific mailbox exists.
Pricing: free as open source.
Tip: normalize and deduplicate before you run any mailbox-level check. Every duplicate you remove is a probe you don't pay for and a bounce you don't risk.
Bottom line: a safe, low-risk first filter, not a full verifier.
6. validator.js
validator.js is a widely used JavaScript library. Its isEmail() function checks whether a string is a well-formed address, with options such as requiring a top-level domain. It runs in browsers and in Node and makes no network calls.
Key features
- Syntax-only email validation
- Options such as requiring a top-level domain
- Runs in browsers and Node.js
- MIT licence
Pros
- No network calls, so no probing and no reputation impact
- Ideal for instant feedback on forms
- Easy to add to any JavaScript signup form
Cons
- Syntax only: "valid" means well-formed, not deliverable
- Typos at real domains, such as gmial.com, pass the syntax check
- No DNS, MX or mailbox information
Best for: instant syntax feedback on signup and contact forms.
Where it falls short: anything after syntax.
Pricing: free as open source.
Tip: pair the syntax check with a short map of common domain typos and suggest corrections. That catches the mistake a syntax check misses. For broader form-level patterns, see real-time email validation. If your forms run on WordPress, WordPress plugins for email validation covers the options.
Bottom line: the right first line of defense on a form, never the only one.
7. DIY SMTP checker with smtplib and dnspython
You can build a mailbox checker with Python's standard smtplib and the dnspython package. The method: resolve the domain's MX records, connect to the highest-priority server, send EHLO, MAIL FROM and RCPT TO, read the reply code, then QUIT without sending any message. Per RFC 5321, 250 means accepted, 5xx means rejected, and 4xx means retry later.
Catch-all detection uses a standard approach: probe a random local part at the same domain. If that is also accepted, the domain accepts everything, and its addresses belong in Risky.
Practical problems you will hit
- Many cloud hosts restrict outbound port 25 by default, so you may need an exemption or a different host.
- Large providers often throttle, greylist or return ambiguous replies to unfamiliar senders.
- Your IP and HELO identity build a reputation. A burst of probes can get you listed or blocked.
- Throughput is the constraint. At an assumed rate of one address per second from one IP (an illustration, not a benchmark), 60,000 addresses take about 16.7 hours (60,000 ÷ 3,600).
Pros: full control, no per-check fee, and data stays on your infrastructure.
Cons: you own probing reputation, catch-all logic, retries and ongoing maintenance.
Best for: engineering teams with strict data-residency needs and the capacity to run the service.
Where it falls short: anyone without operations capacity.
Pricing: no licence cost. The costs are servers, IP reputation management and engineering time.
Tip: build a 500-address prototype first, then compare its output with a hosted tool on the same addresses. The differences show you what a hosted verifier does for you. To check MX records by hand while debugging, see free MX record lookup tools.
Bottom line: the best way to learn how verification works, and an expensive way to run it at scale.
How do you verify a list with Unlimited Verifier?
This workflow cleans a full list once, then keeps new signups clean each week. It works with any ESP because it uses plain CSV files. For the broader practice, see email list maintenance best practices.
- Export your full list from your ESP as CSV, with the email column and any tags you want to keep.
- Split the file if needed. On Free, keep each file to 150 rows or fewer. On Pro, keep each file to 25,000 rows or fewer and under 10MB.
- Sign up. The Free plan is enough for a small list.
- Upload and verify each file. The email column is detected automatically.
- Review the three buckets. Keep Valid active, suppress Invalid, and segment Risky.
- Spend deep verifications on Risky only. Free includes 750 a month and Pro includes 25,000.
- Export as CSV, Excel or JSON and save the file immediately. Free results expire after 24 hours.
- Re-import to your ESP. Mark Valid as active, add Invalid to suppression and tag Risky.
- For signups in code, generate keys on the email verification API page. The API is available on Pro, with bulk batches of up to 10,000 emails per request. For email verification API and automation patterns, start with single checks at signup and batch weekly deltas.
- For one-off checks, the free email checker is quicker than a file upload.
Bottom line: one full pass, then small weekly deltas, with the Risky bucket handled deliberately.
Which open source email verifier should you choose?
| Your situation | Pick | Why |
|---|---|---|
| Want open-source code without running probes | Unlimited Verifier | Published engine, hosted SMTP checks |
| Engineers who must run probing in-house | Reacher or a DIY checker | Full control, but you own the reputation |
| Ruby on Rails signup forms | Truemail | Configurable layers, MIT licence |
| Go backend | AfterShip email-verifier | Native library |
| Python pipeline, syntax and DNS only | email-validator | No probing risk |
| Browser or form feedback | validator.js | Instant, no network calls |
| Data must never leave your servers | Reacher or DIY, plus a data processing review | Data stays with you |
If you're still weighing paid and free options, read our guide on how to choose an email verifier and the broader roundup of best email verification tools. For smaller volumes, email verification tools for low-volume senders covers the cheaper hosted options. Teams that mainly want free plans should start with free and cheap email verifiers. If you're comparing free allowances, Hunter's free plan limits and top email verifiers with free monthly credits are useful reference points.
Bottom line: choose the open source tool that matches the layer you need and the operations your team can staff.
What mistakes do teams make with open source email verification?
- Treating open source as accuracy. Readable code does not make mailbox results correct. Test any tool on your own labeled sample.
- Probing from a shared cloud IP without checking port 25 access and reputation first.
- Marking temporary failures as invalid. A 4xx reply means retry later, not a dead address. Teams that do this lose good subscribers. For how refund policies treat unknown results, see verifiers that refund unknown results.
- Sending probes in bursts. Bursts get your IP greylisted or blocked, so throttle and spread checks over time.
- Deleting every Risky address. Catch-alls often include real, engaged readers. Segment them by recent engagement instead.
- Forgetting suppression on re-import. Invalid addresses return on the next import unless they are suppressed in your ESP.
- Assuming self-hosting removes obligations. Your data handling duties remain. Review the FTC's CAN-SPAM compliance guide for US email rules and the ICO for UK data protection, as part of your email verification compliance and hygiene process.
- Ignoring sender requirements. Google's sender guidelines and M3AAWG best practices set expectations for bulk senders, however you verify.
Bottom line: most open source failures come from operations and process, not from the code.
Verdict
For most teams, the best open source email verification choice is Unlimited Verifier. You get a published engine, unlimited standard verification on every plan including Free, Valid/Risky/Invalid sorting with catch-all detection, and no need to run SMTP probes from your own infrastructure. Its main trade-off is the lack of native ESP integrations, which a CSV round-trip or the API covers.
Choose Reacher or a DIY checker only if your engineers can own the probing, the sending reputation and the licence obligations. Choose the libraries when the checks belong inside code you already maintain, and treat syntax-only libraries as a first filter rather than a verifier.
Bottom line: start with a free Unlimited Verifier list check this week, and keep the open source libraries for the parts of your stack that need code.
Layered verification checklist
Run each address through these layers in order:
- Syntax: reject malformed addresses (validator.js, email-validator).
- Domain / MX: confirm the domain has mail servers.
- SMTP mailbox: ask the server whether the mailbox exists (Reacher, Truemail, AfterShip, or hosted Unlimited Verifier).
- Flags: mark disposable and role-based addresses (for example info@ or sales@).
- Catch-all: sort catch-all domains into a review bucket instead of marking them valid.
- Decide: deliver, review or remove.
A library that stops at step 2 is useful for signup forms but cannot clean an existing list.
Frequently asked questions
What is the best open source email verification tool?
Unlimited Verifier is the best open source option for most teams. Its verification engine is published on GitHub, and standard verification is unlimited on every plan, including Free. SMTP mailbox checks run on its hosted service, so you avoid operating mail-probing infrastructure yourself. Self-hosters who want full control should look at Reacher.
Is open source email verification really free?
The software is free to use, but running it at scale is not. Self-hosted SMTP checks require port 25 access, throttling, IP reputation management and ongoing maintenance. Those engineering and infrastructure costs usually exceed any licence fee. Libraries like email-validator and validator.js are free, but they check only syntax or DNS, not whether a mailbox exists.
Can I self-host an email verification tool?
Yes. Reacher (check-if-email-exists) is a Rust project you can run yourself and performs direct SMTP mailbox checks. Before modifying it or running it as a network service, review its AGPL-3.0 licence, which has obligations for network use. Expect to manage port 25 access, rate limits and sending reputation, since these determine how accurate your results are.
What is the difference between email syntax validation and mailbox verification?
Syntax validation checks that an address follows the correct format, such as one @ symbol and a valid domain pattern. Mailbox verification goes further by asking the receiving mail server whether that specific mailbox exists, usually via an SMTP check. Syntax checks like validator.js are fast and free but cannot tell you whether an address receives mail.
What is a catch-all domain and why does it matter?
A catch-all domain accepts mail for any address at that domain, even ones that do not exist. This makes it hard to confirm a specific mailbox through SMTP alone. Tools that detect catch-alls can flag these addresses separately instead of marking them as valid, which reduces bounces and protects sender reputation.
Which open source library is best for Ruby or Rails?
Truemail is the most direct choice for Ruby and Rails signup validation. It is open source and can run SMTP checks, depending on how you configure it. Because its results depend on your configuration and network setup, test it against your own sample list before relying on it in production.
Do open source email verifiers work for Python or Go projects?
Yes, with different depth. For Python, email-validator covers syntax and DNS checks but has no mailbox check, so it suits pipelines that only need format and domain validation. For Go backends, AfterShip's email-verifier can run SMTP checks, though you should review its README for current capabilities and configuration.
Should I build my own email verification checker?
Only if you have engineering time and a specific need for full control. A DIY checker built on smtplib and dnspython gives you complete control, but you must handle port 25 access, throttling, retries, catch-all logic and sending reputation yourself. For most list owners, a hosted engine with an open-source core is more practical.
Cut Bounces and Protect Your Sender Reputation With Unlimited Email Verification
Every invalid address you send to hurts your sender reputation and your inbox placement. Verifying your list before each send means fewer bounces, healthier deliverability, and a predictable cost. With Unlimited Verifier, standard verification is unlimited on every plan, with no per-email fees.
Unlimited Verifier checks syntax, domain, MX records and the SMTP mailbox. It also detects catch-all domains and flags disposable and role-based addresses. Export a CSV from your email platform or CRM, upload and verify the list, then re-import the clean results. You can also automate checks with the email verification API.
| Free | Pro | |
|---|---|---|
| Price | $0 | $29/month ($25/month billed annually) |
| Lists | 25 a month, up to 150 emails each | Unlimited, up to 25,000 emails each |
| Deep verifications | 750 a month | 25,000 a month |
| API access | No | Yes (100,000 emails a month) |
| Result retention | 24 hours | 30 days |
Why teams choose Unlimited Verifier
- Unlimited standard verification on all plans, including Free, with no per-email fees.
- Catch-all detection so you know which domains accept every address.
- Clear Valid / Risky / Invalid results, exportable as CSV, Excel or JSON.
- An open-source verification engine you can inspect on GitHub.
Unlimited Verifier states 99.5% accuracy for deep verification.
Create a free account and verify your next list before you hit send.
Want to test a single address first? Try the free email checker.