This MCP server lets AI agents create disposable email inboxes and retrieve verification emails with OTPs and magic links already extracted.
Generate disposable inboxes instantly and locally, with an optional name prefix.
Block and wait for a matching email, filtering by sender, subject, OTP presence, or magic-link presence, with a configurable timeout up to 120 seconds.
Check an inbox non-blockingly for recent emails and already-extracted OTPs/magic links.
Support end-to-end testing of signup, login, OTP verification, magic-link, and password-reset flows.
Enable QA automation where agents drive real email-based auth flows without parsing HTML or regexing message bodies.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@zerodrop-mcp generate an inbox and wait for the OTP email from noreply@myapp.com"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Email verification for AI agents — an MCP server that gives Claude, Cursor, Claude Code, and any MCP client disposable email inboxes with auto-extracted OTPs and magic links.
Your agent tests your app's signup. The app sends a verification code. Without an inbox it can read, the agent is stuck. With zerodrop-mcp:
Agent: generate_inbox()
→ swift-x7k29ab@zerodrop-sandbox.online
Agent: [fills the signup form with that address]
Agent: wait_for_email(inbox, require_otp: true)
→ { "otp": "847291", "subject": "Verify your email", ... }
Agent: [enters 847291 — flow complete]No Docker. No SMTP. No signup to try: without an API key, one sender can reach 5 different inboxes a day. A free key lifts that.
claude mcp add zerodrop -- npx -y zerodrop-mcpAdd to claude_desktop_config.json:
{
"mcpServers": {
"zerodrop": {
"command": "npx",
"args": ["-y", "zerodrop-mcp"]
}
}
}Add to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):
{
"mcpServers": {
"zerodrop": {
"command": "npx",
"args": ["-y", "zerodrop-mcp"]
}
}
}Related MCP server: courier-mcp
generate_inboxCreates a disposable email address. Local and instant — no network request.
Param | Type | Description |
| string, optional | Prefix for the inbox name, e.g. your app name |
Returns the inbox address. With a key from zerodrop.dev/keys in ZERODROP_API_KEY, the name starts with your key's prefix (k7x2-myapp-swift-x7k29ab) and only your key can read it. Without one, a prefix whose part before the first hyphen is four letters and digits, at least one of each (app1, app1-web), goes after the adjective instead (swift-app1-web-x7k29ab), so the inbox can't fall under someone's account.
wait_for_emailBlocks until a matching email arrives, then returns it with the OTP and magic link already extracted — the agent never parses HTML or regexes a body.
Param | Type | Description |
| string | Address from |
| number, optional | Default 30, max 120 |
| string, optional | Filter by sender |
| string, optional | Filter by subject |
| boolean, optional | Only match emails with an OTP |
| boolean, optional | Only match emails with a magic link |
Returns:
{
"from": "noreply@yourapp.com",
"subject": "Your verification code",
"received_at": "2026-07-18T12:34:56Z",
"otp": "847291",
"magic_link": null,
"body_preview": "Your code is: 847291..."
}Without an API key, one sender can reach 5 different inboxes a day. If ZeroDrop held the email because its sender passed that, wait_for_email returns at once (0.3.0 or later) with an error instead of waiting for the timeout:
{ "error": "held", "message": "ZeroDrop held an email from yourapp.com to this inbox. The email was not stored. …" }check_inboxNon-blocking snapshot of the inbox — recent emails with extracted fields, or an empty list. A notice that ZeroDrop held an email appears as { "held": true, "received_at": "…", "message": "…" }.
Testing auth flows end to end — signup → OTP → verified, driven entirely by the agent
QA automation — Claude Code writing and running Playwright tests that need real inboxes
Development — "sign up for my own app and tell me if the verification email works"
Emails sent to a generated inbox are caught at Cloudflare's edge by ZeroDrop's open-source worker. OTPs and magic links are extracted at the edge before your agent reads them. On the free tier, an inbox is deleted 30 minutes after its latest email.
Environment variables (set in your MCP client config):
Variable | Default | Description |
| — | Free key from zerodrop.dev/keys. Inbox names then start with your key's prefix, only your key can read them, and mail to them isn't limited. Without it, inboxes are public and one sender can reach 5 different inboxes a day; past that, the inbox gets a notice from |
|
| Self-hosted instance URL |
{
"mcpServers": {
"zerodrop": {
"command": "npx",
"args": ["-y", "zerodrop-mcp"],
"env": { "ZERODROP_API_KEY": "your-key" }
}
}
}If you're generating test code rather than driving flows live, use the SDKs directly:
npm · PyPI · Go · RubyGems · Packagist · JitPack · GitHub Action
AI coding assistant context: docs.zerodrop.dev/ai-coding
The server makes requests only to ZERODROP_BASE_URL (zerodrop.dev by default) — nothing else
Inbox generation is fully local
Two runtime dependencies: the official MCP SDK and zod
Report issues: founder@zerodrop.dev
MIT — zerodrop.dev
Check a ZeroDrop inbox right now without waiting. Returns the most recent emails with OTPs and magic links already extracted, or an empty list if nothing has arrived yet.
| Name | Required | Description | Default |
|---|---|---|---|
| inbox | Yes | The inbox address (or name) returned by generate_inbox |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description provides key behavioral traits: it is non-waiting, returns extracted data, and returns empty if no emails. Additional details like error handling are absent but acceptable for a simple check tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, first sentence states action, second defines result. No wasted words, front-loaded with critical info.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one parameter and no output schema, the description adequately explains return format and usage. It is sufficient given the sibling context, though lacks details on handling non-existent inboxes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the schema already describes the single required parameter. The tool description adds no extra detail about the parameter beyond repurposing the tool's context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks a ZeroDrop inbox and returns recent emails with extracted OTPs/magic links or an empty list, distinguishing it from siblings like generate_inbox and wait_for_email.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies use for immediate polling ('right now without waiting'), which contrasts with the likely waiting behavior of sibling wait_for_email, but does not explicitly state when not to use or mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a disposable email inbox for testing signups, OTP verification, magic links, and password resets. Instant and local — no network request. Use the returned address wherever an email is required, then call wait_for_email to read what arrives. Free tier: 30-minute retention, no signup needed.
| Name | Required | Description | Default |
|---|---|---|---|
| prefix | No | Optional prefix for the inbox name, e.g. your app or test name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses key behaviors: instant, local, no network request, and free tier limits. This provides good transparency for a simple tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences that front-load purpose and provide essential usage guidance. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description still explains how to use the result (call wait_for_email) and mentions limitations (30-minute retention). Could explicitly state return format but is sufficient for a simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one optional parameter 'prefix' with schema description. The tool description does not add extra meaning beyond the schema. Since schema coverage is 100%, baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool generates a disposable email inbox for testing signups, OTP verification, etc. It distinguishes from sibling tools by indicating that after generating, one should call wait_for_email to read what arrives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use it (testing signups, etc.) and explicitly references wait_for_email for reading. It also mentions free tier details (30-minute retention, no signup). It does not explicitly state when not to use it, but context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Wait for an email to arrive in a ZeroDrop inbox and return it with the OTP and magic link already extracted — no parsing needed. Blocks until an email matching the filters arrives or the timeout is reached. Use after triggering a signup, login, or password-reset flow.
| Name | Required | Description | Default |
|---|---|---|---|
| inbox | Yes | The inbox address (or name) returned by generate_inbox | |
| require_otp | No | Only match emails with an extracted OTP code | |
| from_contains | No | Only match emails whose sender contains this text | |
| timeout_seconds | No | How long to wait before giving up (default 30, max 120) | |
| subject_contains | No | Only match emails whose subject contains this text | |
| require_magic_link | No | Only match emails with an extracted magic link |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description carries full burden. It discloses blocking behavior, email extraction, and timeout, providing full transparency for an agent to predict behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, no fluff, front-loaded with core functionality. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, but description explains return value (email with extracted OTP/magic link). Also covers blocking and timeout, making it complete for a polling tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. Description adds value by noting return behavior (OTP/magic link extraction) but does not elaborate on individual parameters beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool waits for an email, returns it with OTP and magic link extracted, and distinguishes itself from siblings like check_inbox (non-blocking) and generate_inbox (creation).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use after triggering a signup, login, or password-reset flow', providing clear context. It implies blocking behavior and mentions timeout, but does not explicitly state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.2check_inboxgenerate_inboxwait_for_emailScored across 3 tools
Each tool has a clearly distinct purpose: generate_inbox creates an inbox, wait_for_email blocks for incoming emails, and check_inbox polls immediately. There is no overlap in functionality.
Tools generally follow a verb_noun pattern (generate_inbox, check_inbox), but wait_for_email deviates slightly with a preposition. Overall, names are intuitive and consistent in style.
Three tools is well-scoped for a disposable email service. It covers creation, polling, and blocking waiting without unnecessary extras.
The set covers the essential lifecycle for email testing: create an inbox, wait for an email, and check for emails instantly. Missing operations like deletion are handled automatically by the service, so no gaps.
Real email inboxes for AI agents: create inboxes, catch verification codes, extract OTPs, reply.
Disposable email inboxes for AI agents: create an address, wait for mail, read OTP codes and links.
Disposable email inboxes for AI agents: create an address, wait for the OTP or verify link.
Disposable email inboxes for AI agents — read messages and verification codes.
