Email Verification API: Check Any Address, Billed per Call
Verify one email address or a whole list through an API: what each check returns, how to loop it, and where a verifier stops helping.

Check whether an email address is real before you send to it, in one prompt. Paste this into your agent:
Set up https://monid.ai/SKILL.md, and then use Monid to verify jane@gmial.com and tell me whether it is deliverable, whether the domain is disposable, and what address I probably meant.
One prompt checks an address. 1 min setup · 12-24 hrs saved.
You have an address, or a list of them, and you want to know whether mail to it will land before you pay for the bounce. This guide covers the quick way to get an email verification API into your agent, how to run it over a list, what a result contains (we ran one live on 2026-10-16), and the two things a verifier does not tell you. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.
What is the easiest way to use an email verification API?
Monid. Install it once, add a key, and your agent calls a verification endpoint with an address and gets typed JSON back, with no verifier account to open, no credit pack to size and no dashboard to log in to.
- Pay per call. One check is billed on its own: $0.03564 for the syntax, MX, disposable and typo check, or $0.01225 for a full SMTP-level verdict (Verified 2026-10-16 on the people enrichment tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills.
- One install, every tool. The same key and the same balance call the verifiers and every other tool on Monid, so an address check is one more line in a pipeline, not another vendor.
- Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tool is there whenever your agent needs it, on demand, with nothing to keep running. Your agent reads
SKILL.mdand learns the rest, so setup is about a minute.
There is no single official email verification API to apply for: verification is sold by many vendors, each with its own key and billing. At those prices, checking 100 addresses costs about $3.56 with the first endpoint and about $1.23 with the second (Verified 2026-10-16).
How do you verify a list of email addresses with an API?
Call a verification endpoint once per address and loop it over your list. Two endpoints on Monid do the job at different depths, and a third sits between them on price.
| Route | What you get | Cost shape | Fits |
|---|---|---|---|
| Upload a CSV to a verifier dashboard | A cleaned file | Credit pack or subscription | A person cleaning a big list on a schedule |
| Write the checks yourself | Whatever your rules cover | Your hours | An engineer who wants no vendor |
Monid, Strale email-validate | Syntax, MX, disposable, role and typo check as JSON | Pay per call | Capture-time gating, agents, small lists |
Monid, Hunter email-verifier | Status, score and SMTP-level breakdown | Pay per definitive verdict | Pre-send cleaning of addresses you will mail |
Monid fits a list because the work is one call repeated, and you pay for the addresses you check and nothing between runs.
For agents
Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:
set up https://monid.ai/SKILL.md
It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.
For humans
npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main
Inspect, then run one
monid inspect -p api.strale.io -e /x402/email-validate
monid run -p api.strale.io -e /x402/email-validate \
--query '{"email":"jane@gmial.com"}'
For the deeper check, the Hunter verifier takes the same input:
monid run -p hunterio -e /email-verifier -w --query '{"email": "someone@example.com"}'
Loop it over your list
Put one address per line in emails.txt and write one file per address:
mkdir -p out
while read -r e; do
monid run -p hunterio -e /email-verifier -w --query "{\"email\": \"$e\"}" > "out/$e.json"
done < emails.txt
Each address bills one call. If you would rather keep the credit-pack route for a large scheduled scrub, the ZeroBounce and NeverBounce comparison lays out when a pack beats a loop like this.
Can you verify emails yourself with Python?
Yes, and the first version is an afternoon. You check the syntax with a regular expression, look up the domain's MX records with a DNS library, compare the domain with a list of disposable providers, and flag role addresses such as info@ and sales@. Python libraries and GitHub repositories cover each step.
What takes the time is everything after the first version. A syntax check and an MX lookup tell you the domain can receive mail, not that the mailbox exists. To learn that you open an SMTP conversation with the mail server, and probing from your own IP address can get that address distrusted by mail providers, which is the reputation you are trying to protect. Catch-all servers accept every address, so a naive probe reports a valid mailbox that is not there. The disposable-domain list and the role patterns need new entries all the time. You end up maintaining a small verification product.
The Monid route removes that maintenance. The Strale endpoint checks syntax, MX records, 5,361 disposable domains and 35 role patterns and suggests a corrected address for a typo, at $0.03564 a call (Verified 2026-10-16). The Hunter endpoint runs the mailbox-level check for $0.01225 a verdict (Verified 2026-10-16), so the SMTP conversation does not come from your IP. A hand-written script is fine for a single signup form you will keep for years; it is the wrong tool for a list you verify every month.
What does an email verification result look like, and what can you build with it?
A verification result is a short record that says whether the address is deliverable and why. We ran the Strale endpoint on 2026-10-16 against a deliberately mistyped address, jane@gmial.com, so the fields below are what came back.
The response
{ "valid": false,
"email": "jane@gmial.com",
"format_valid": true,
"domain": "gmial.com",
"has_mx_records": false,
"mx_records": [],
"is_disposable": true,
"is_role_address": false,
"is_free_provider": false,
"did_you_mean": "jane@gmail.com",
"_meta": { "capability": "email-validate", "latency_ms": 22,
"provenance": { "source": "algorithmic+dns", "fetched_at": "2026-10-17T04:05:33.461Z" } } }
valid is the verdict. format_valid says the syntax parses, and the two together are the useful shape: the address is well formed and still undeliverable, which is the case a regular expression waves through. has_mx_records and mx_records say whether the domain can receive mail at all, is_disposable, is_role_address and is_free_provider are three flags on the domain and the local part, and did_you_mean carries the corrected address. The call returned in 22 milliseconds by its own clock and about 2.2 seconds on the wall clock of the whole run.
The Hunter and ContactOut verifiers return a status instead of a set of flags. The Hunter listing names valid, invalid, accept_all, webmail, disposable and unknown, a score from 0 to 100, and the checks behind them: syntax, MX, SMTP server, mailbox and accept-all.
What you can build with it
- A signup gate. Check the address when the form is submitted, offer
did_you_meanback to the visitor, and refuse disposable domains. The pattern is written out in an email verification gate for a signup form. - A pre-send filter. Run the verifier over a list, keep the
validrows, and drop the rest before the campaign instead of after the bounces. - A cheap-first pipeline. Use the Strale check at capture, then the Hunter verifier on the addresses you are about to mail.
What goes wrong when a verifier says an email is fine?
Three things show up once you read results instead of counting them. The first is from our 2026-10-16 run, the other two are properties of how mail works.
Why did a typo domain come back as disposable?
Because the flags describe the domain, and gmial.com is a typo domain, not a mailbox provider. In our run is_disposable was true for it, has_mx_records was false and valid was false. Read valid and has_mx_records for the verdict, and treat is_disposable as a reason to block rather than a label to report. When did_you_mean is present, offer the corrected address to the visitor before you refuse the original.
Why does a "valid" address still bounce or hit a trap?
Because a verifier checks whether mail can be delivered, and some addresses that accept mail should not be mailed. A spam trap is a real or once-real address that accepts mail so that mail providers can see who sends to unengaged lists, so a deliverability check reports it as valid. Verification removes the addresses that do not exist; it does not make an old or purchased list safe. The only trap-adjacent signal a verifier gives you is the role-address flag, since info@ and admin@ are rarely worth mailing anyway. The rest is list hygiene: do not mail purchased lists, drop addresses that have not engaged in months, and verify at capture so a bad address never enters. Bounce rates and spam traps goes through that split in detail.
Why does an accept-all domain make the answer weak?
Because a catch-all mail server says yes to every address, so the SMTP step cannot tell a real mailbox from an invented one. That is why the Hunter and ContactOut statuses include accept_all as a verdict of its own. Keep those rows apart from valid and decide per campaign whether to send. Both endpoints bill only a definitive verdict: unknown results and disposable addresses are free on Hunter and on ContactOut.
Which endpoint should I use for which job?
Use the Strale check at capture, a mailbox-level verifier before a send, and the deliverability check when the question is about a domain.
| Endpoint | Job | Input | Billing shape | Price (Verified 2026-10-16) |
|---|---|---|---|---|
api.strale.io/x402/email-validate | Syntax, MX, disposable, role and typo check | An email | Per call | $0.03564 |
hunterio/email-verifier | Mailbox-level verdict with score and breakdown | An email | Per definitive verdict | $0.01225 |
contactout/v1/email/verify | Deliverability verdict | An email | Per definitive verdict | $0.01 |
api.strale.io/x402/email-deliverability-check | SPF, DKIM, DMARC, MX and blacklist check with a 0-100 score | A domain | Per call | $0.0594 |
Prices Verified 2026-10-16 with monid inspect. The first three take an address and differ in depth and price. The last takes a domain, so it answers whether your own sending domain is set up to land in the inbox, not whether a prospect's address exists. Its listing says it checks SPF, DKIM, DMARC, MX records and blacklist status; inspect it for free, then spend one call on your own domain before you build on it.
When is another route a better fit?
You clean very large lists on a schedule. A dedicated verifier sells volume tiers and a dashboard built for that job. A loop of single calls is the wrong shape for millions of addresses, and a credit pack is the better fit.
You want a dashboard for a non-engineer. Monid is an API and a CLI. If the person doing the cleaning drags in a CSV and downloads a file, give them a tool made for that.
You need a contractual accuracy guarantee. A verifier that publishes accuracy rates and signs paper is the route when your buyer asks for that. Monid resells the endpoints above and the guarantee is the provider's.
You need the SMTP result on every address. The Strale endpoint reads syntax and DNS; it does not open a conversation with the mailbox. For addresses you are about to mail in bulk, use the Hunter verifier or ContactOut.
And the disclosure: we resell these endpoints. The most useful habit in this post is independent of who you buy from. Run any verifier against fifty addresses whose answer you already know before you trust it with a send, and read the reason fields instead of the verdict alone.
Conclusion
The quickest way to verify an email address from an agent is one call through Monid: $0.03564 for the syntax, MX and typo check or $0.01225 for a mailbox-level verdict (Verified 2026-10-16), one key for this and every other tool, about a minute to set up and ready inside your agent whenever you need it. Writing your own checks works for a single form and costs hours of rules and reputation upkeep; Monid keeps the checks maintained.
Two things matter more than the endpoint you pick. A verifier removes addresses that do not exist, not addresses that should not be mailed, so list hygiene stays your job. And verification at capture is cheaper than cleaning later, because a corrected typo is a lead you keep, as in measuring a bounce rate before and after.
How we estimated the time saved: building your own verifier is roughly 6 to 12 hours for syntax, MX, disposable and role rules plus an SMTP layer, and 6 to 12 hours for the first quarter of upkeep as lists and providers change. That is 12 to 24 hours. The 1 minute is the install, key and first call once you already have a Monid key.
Free next step: run monid discover -q "verify email address", then monid inspect -p api.strale.io -e /x402/email-validate, and make one call on an address whose answer you already know.
FAQ
Is there a free email verification API?
Not free, but cheap for small jobs: through Monid a check costs $0.01225 on the Hunter verifier or $0.01 on ContactOut (Verified 2026-10-16), with no monthly plan and no minimum. Discovery and inspection cost nothing, and unknown results are not billed on either.
How do I verify a list of email addresses?
Call a verification endpoint once per address with the loop above, then keep the rows whose status is valid. Each address is one billed call, so the cost tracks the size of the list and nothing is charged between runs.
Does email verification stop spam traps?
No. A spam trap accepts mail, so a deliverability check reports it as valid. Verification removes addresses that do not exist; avoiding traps takes list hygiene: no purchased lists, and no re-mailing addresses that have not engaged in months.
Can I just write the email check in Python myself?
Yes, for syntax, MX lookups, disposable domains and role addresses. The mailbox-level SMTP check is the hard part, because probing from your own IP can damage its reputation and catch-all servers accept every address.
What does the typo suggestion do?
It returns a corrected address when the domain looks like a mistyped common provider. For jane@gmial.com the Strale endpoint returned did_you_mean: jane@gmail.com on 2026-10-16, which lets a signup form ask the visitor to confirm the fix.
Published July 2026.


