MCP Email Verification for AI Agents
By Aria Pramesi, founder of InboxPolicy · Updated July 4, 2026
InboxPolicy ships an MCP server exposing decide_send, verify_email, batch, and usage as agent tools. An agent asks should I email this address and gets back one of five actions (send, send_with_caution, review, retry_later, avoid), a confidence score, SMTP evidence, and the cost, in a single tool call, no dashboard required.
What tools does the InboxPolicy MCP server expose?
Four tools, all callable directly by an agent without a REST client or dashboard:
- decide_send: runs syntax, MX, and live SMTP checks against InboxPolicy's verification engine, then applies a deliverability policy that turns the evidence into one action (
send,send_with_caution,review,retry_later, oravoid), plus a confidence score. - verify_email: returns the raw syntax, MX, and SMTP evidence for one address without the policy layer, for agents that want to apply their own decision logic.
- batch: submits a list of addresses and returns per-item results; async batches scale to 50,000 emails with a signed completion webhook when done.
- usage: reports call counts and remaining credits, so an agent can check its own balance before running a large batch.
How do I connect the MCP server to my agent?
Add InboxPolicy to your agent's mcpServers config block, the same pattern used for any other MCP server:
{
"mcpServers": {
"inboxpolicy": {
"command": "npx",
"args": ["-y", "@inboxpolicy/mcp-server"]
}
}
}Once connected, the agent sees decide_send, verify_email, batch, and usage as first-class tools it can call mid-conversation, no separate API key setup required if it pays per call over x402.
What does an agent get back from a single call?
A decide_send call for one address returns an action, a confidence score, the SMTP evidence behind it, and the cost of that call, for example:
{
"action": "review",
"confidence": 0.62,
"evidence": {
"syntax_valid": true,
"mx_found": true,
"smtp_response": "catch-all domain, mailbox existence unconfirmed"
},
"cost_usd": 0.01
}The agent does not have to parse a status enum and guess what it means for send timing. It gets the decision directly.
How does pricing work for agent calls?
Fresh verifications cost $0.01 each, paid per call over the x402 protocol: USDC on Base, no account and no API key needed. A keyless request gets an HTTP 402 with machine-readable payment requirements, the agent attaches an X-PAYMENT header, and gets its decision plus an on-chain settlement receipt back.
For agents or teams that prefer paying by card up front, prepaid credit packs are available: Starter $5 for 1,000 credits ($5.00/1k), Builder $19 for 5,000 ($3.80/1k), Growth $79 for 25,000 ($3.16/1k). Volume pricing is available on request. Three things are always free regardless of plan: re-verifying the same address within 72 hours (from_cache, 0 credits), rejecting malformed emails before SMTP (0 credits), and retrying with the same idempotency key (never billed twice).
There is no free tier. The $0.01 x402 call is the trial, on purpose, since free tiers tend to attract list-cleaning abuse rather than genuine agent use.
How accurate are the decisions?
On InboxPolicy's prior verification engine, valid-verdict agreement with MillionVerifier was roughly 90% typical across more than 2 million verifications, though this is not a formal recent benchmark and it varies by vertical, dropping as low as 60% in some.
Unknown and catch-all results are never guessed as safe to send, they map to the review action instead. This matters for agents because roughly 30-40% of B2B addresses sit on catch-all domains, where SMTP alone cannot confirm a mailbox exists.
When should an agent use a different tool instead?
InboxPolicy is built for a live send decision inside an agent workflow, not every verification job:
- One-shot cleaning of a huge scraped list at the lowest per-address cost: MillionVerifier's ~$0.59-2.50/1k pricing is built for exactly that.
- Spam-trap and abuse-address detection: ZeroBounce maintains a dedicated spam-trap and abuse database that InboxPolicy does not.
- A dashboard-first marketing suite with CSV uploads and integrations: Kickbox or Emailable are built around that workflow rather than an agent tool call.
| Tool | Entry price | Output format | MCP server | Free tier | Best for |
|---|---|---|---|---|---|
| InboxPolicy | $0.01 per call (x402), or as low as $3.16/1k on Growth credit pack | Action + confidence + SMTP evidence | Yes (decide_send, verify_email, batch, usage) | None (cache, malformed, and idempotent retries are free) | Agent send decisions in real time |
| ZeroBounce | ~$8.00/1k | Status fields | No | 100/mo free | Spam-trap and abuse-address detection |
| Kickbox | ~$10.00/1k | Status fields plus Sendex quality score | No | One-time free credits | Dashboard-first quality scoring |
| MillionVerifier | ~$0.59-2.50/1k | Status fields, resolves unknowns aggressively | No | Yes | One-shot bulk list cleaning at lowest cost |
| Emailable | Not published | Dashboard-based verification suite | No | Not specified | Bulk uploads and marketing integrations |
Frequently asked questions
What is MCP email verification?
MCP (Model Context Protocol) email verification means the verification service exposes its checks as tools an AI agent can call directly, instead of a REST endpoint a developer has to wire up separately. InboxPolicy's MCP server exposes decide_send, verify_email, batch, and usage tools, so an agent can decide whether to send an email using one tool call inside its own workflow.
Which tools does InboxPolicy's MCP server expose?
Four tools: decide_send returns an action plus confidence and evidence for one address, verify_email returns raw syntax, MX, and SMTP checks, batch returns per-item results across a list with async support up to 50,000 emails, and usage reports call counts and remaining credits. Each returns structured data an agent can act on directly.
How much does each agent call cost?
$0.01 per fresh verification through the x402 protocol, paid in USDC on Base with no account or API key needed. Prepaid credit packs are also available by card: Starter $5 for 1,000 credits, Builder $19 for 5,000, Growth $79 for 25,000. Cache hits within 72 hours, malformed-email rejections, and idempotent retries are always free.
Does InboxPolicy have a free tier?
No. The $0.01 per-call x402 price is the trial, deliberately, because free tiers tend to attract list-cleaning abuse. What is actually free: re-verifying the same address within 72 hours (from_cache, 0 credits), rejecting malformed emails before SMTP (0 credits), and retries sent with the same idempotency key, which never bill twice.
How accurate are InboxPolicy's send decisions?
On the prior verification engine, InboxPolicy's valid-verdict agreement with MillionVerifier was roughly 90% typical across more than 2 million verifications, though it varies by vertical and drops as low as 60% in some. Unknown or catch-all results are never guessed as safe, they map to the review action so ambiguity surfaces instead of getting hidden.
When should an agent use a different email verification tool instead of InboxPolicy?
For one-shot cleaning of a large scraped list at the lowest cost, MillionVerifier is the budget option at roughly $0.59-2.50/1k. For spam-trap and abuse-address detection, ZeroBounce carries a dedicated database InboxPolicy doesn't maintain. For a dashboard-first suite built around CSV uploads, Kickbox or Emailable fit better than an agent-first API.