# MailProbe

> Email verification API. Check if email addresses are valid and deliverable, in real time. Hosted in the EU (France, OVHcloud), GDPR-compliant, no result caching at any layer — a result is never reused for a later request.

## What it does
MailProbe verifies email addresses in real time. It checks syntax, DNS (MX records), and mailbox existence via SMTP without sending any email. Three ways to use it: a free public page at https://mailprobe.dev/free-email-verifier/ that checks one address at a time with no account (15 checks per day per network: one IPv4 /24 or IPv6 /56), a REST API for 1 to 20 addresses per synchronous request, and a batch screen in the account where a list is pasted (up to 500) or uploaded as a CSV/TXT file (up to 10 MB and 250,000 addresses per batch) and verified in the background.

## API
- Verify: POST https://mailprobe.dev/api/v1/verify
- Credit balance: GET https://mailprobe.dev/api/v1/credits
- Auth: Bearer token in Authorization header (Authorization: Bearer mp_live_...)
- Keys: up to 10 per account, each with a label and its own usage counters. Only the hash is stored, so a key is displayed once at creation and never again
- Input: JSON body with an "emails" array (1 to 20 entries), and an optional "timeout" in seconds (see Response time)
- Output: JSON array, one entry per address, in input order
- Response time: a request answers within about 95 seconds, however slow or silent the mail servers are. An address that has no verdict yet at that point comes back `unknown` with reason `timeout`, at no charge. To get the answer sooner, add "timeout" to the body, a whole number of seconds from 5 to 95: use it when something in front of your code gives up before 95 seconds (a gateway, a sign-up form, an automation step with a time limit)
- Rate limit: 60 requests per minute per key (a 20-address batch counts as one request), and 300 requests per minute from the same IP address, all keys combined. A 429 response carries a `Retry-After` header: the number of seconds to wait before sending the request again
- n8n: official community node `n8n-nodes-mailprobe` (on a self-hosted n8n: Settings > Community Nodes > Install). It sends items 20 at a time, waits out the rate limit and returns one result per item, in input order; also usable as a tool by the n8n AI Agent
- Zapier: official MailProbe app (https://zapier.com/apps/mailprobe/integrations) with a Verify Email action, one address per run; AI assistants can also call it through Zapier MCP
- MCP: remote Model Context Protocol server at https://mailprobe.dev/mcp (Streamable HTTP), for MCP clients that can send a header, such as Claude Code, Cursor and VS Code. Same API key, in the Authorization header. Two tools: `verify_emails` (1 to 20 addresses, same results, credits and rate limit as the API) and `get_credits`. A call to this server answers within about 55 seconds, because MCP clients give up on a tool call after a minute: an address that has no verdict yet at that point comes back `unknown` with reason `timeout`, at no charge. No OAuth yet, so the Claude and ChatGPT apps reach MailProbe through Zapier MCP instead. For clients that start a server on the computer, such as Claude Desktop: official local server `npx -y mailprobe-mcp` (npm, Node.js 22 or later, key in the `MAILPROBE_API_KEY` environment variable), with the same two tools. In Claude Code, a plugin connects to the remote server and adds an agent skill that tells the assistant how to read a result, what a call costs and how to go through a list: `/plugin marketplace add jamalofski/mailprobe-mcp`, then `/plugin install mailprobe@mailprobe` ([source](https://github.com/jamalofski/mailprobe-mcp))

Each result entry carries:
- `result` — raw SMTP verdict: deliverable | undeliverable | catch-all | unknown
- `status` — actionable rollup, the field most integrations filter on: valid | risky | invalid | unknown
- `score` — deterministic 0-100 confidence value
- `reason` — why the verdict is not plainly deliverable (accept_all, no_mx, greylisting, mailbox_full, provider_blocks_probe, invalid_syntax, timeout, mx_unresolved, policy_rejected…), null otherwise
- `disposable`, `role_based`, `free_provider`, `catch_all` — categorisation flags
- `did_you_mean` — suggested typo fix (gmial.com → gmail.com), or null
- `retry_after`, `smtp_code`, `smtp_enhanced_code`, `syntax`, `mx_found`, `smtp_check`, `mx_records` — the underlying signals behind the verdict (`smtp_enhanced_code` is the RFC 3463 status, e.g. 5.1.1 no such mailbox vs 5.7.1 sender refused)

## Pricing
- Pay-per-use, no subscription. 1 credit per address actually probed: duplicates within a request, syntactically invalid entries and addresses whose server refused our connection are refunded.
- 100 free credits on signup — magic link, no password. A few domains targeted by abuse can only be verified with purchased credits (the API answers 402 `PAID_ONLY_DOMAIN` and names the domain)
- $5 for 1,000 verifications
- $20 for 10,000 verifications
- $90 for 50,000 verifications
- $150 for 100,000 verifications

## Key facts
- No emails are sent during verification
- No verification result is ever reused: every request re-probes live, nothing is cached across requests
- API verification stores nothing — addresses are processed in memory and gone when the response is sent
- Batch verification holds the list and its results only until 24 hours after the batch finishes, then deletes them permanently
- The scoring rubric is published, not a black box — `status` and `score` are derived only from the signals returned in the same response, with no model and no stored data
- Disposable-domain detection merges public blocklists (disposable-email-domains, FakeFilter) with MailProbe's own findings, refreshed daily; a listed domain also covers its subdomains, and known disposable mail servers are recognised by their MX
- API: up to 20 addresses per synchronous request. Batch screen: 500 pasted, or a CSV/TXT file up to 10 MB and 250,000 addresses per batch
- Batch credits are debited up front and any address never attempted is credited back automatically. A credit is also returned for a syntactically invalid address (it stays in the results, as invalid), and when the receiving server refused our connection before evaluating the address (unknown with reason policy_rejected, no_banner, ehlo_rejected or mail_from_rejected)
- The free public verifier needs no account and no key: 15 checks per day per network (one IPv4 /24 or IPv6 /56), no credit consumed, and the address typed is never stored
- Hosted in the EU (France, OVHcloud), GDPR-compliant

## Links
- [Website](https://mailprobe.dev/)
- [Free email verifier](https://mailprobe.dev/free-email-verifier/)
- [API docs](https://mailprobe.dev/api-docs/)
- [OpenAPI 3.0.3 specification](https://mailprobe.dev/openapi.json)
- [Postman collection](https://mailprobe.dev/mailprobe.postman_collection.json)
- [n8n node](https://github.com/jamalofski/n8n-nodes-mailprobe)
- [Zapier app](https://zapier.com/apps/mailprobe/integrations)
- [MCP server setup](https://mailprobe.dev/api-docs/#mcp)
- [MCP server, Claude Code plugin and skill on GitHub](https://github.com/jamalofski/mailprobe-mcp)
- [Pricing](https://mailprobe.dev/pricing/)
- [Blog](https://mailprobe.dev/blog/)
- Publisher: [Iris Digital](https://irisdigital.tech/)