deadsimple.email is hosted on Amazon CloudFront. It sends email through Amazon SES.
| Technology | Version | First seen |
|---|---|---|
| CDN & Hosting3 | ||
| – | 7 Nov 2026 | |
| – | 7 Nov 2026 | |
| – | 7 Nov 2026 | |
| Transactional Email1 | ||
| – | 7 Nov 2026 | |
| Accessibility1 | ||
| – | 7 Nov 2026 | |
| Fonts & Icon Fonts1 | ||
| – | 7 Nov 2026 | |
| Reviews, Ratings & Social Proof1 | ||
| – | 7 Nov 2026 | |
Registration from the registry's RDAP record, the certificate the site serves, and its rank in public traffic lists.
The crew hasn’t read this site’s colors yet. We read a palette when we capture a site’s screenshot, busiest sites first. Meanwhile, browse palettes from other sites.
Counted from every stack change we've recorded: of the sites we watched running one of this site's tools, how many went on to add another. A pattern across sites, not a forecast for this one.
mx.wichitaegresswindows.comns-651.awsdns-17.netns-1632.awsdns-12.co.ukns-1348.awsdns-40.orgns-188.awsdns-23.comv=spf1 include:amazonses.com -allv=MCPv1; k=ed25519; p=Cq+/6KZXjuhLZCL9x2b6Tl0sHa+NYQoKfDLbNcInu9Y=google-site-verification=pWuAVMzxvRUq50YgXHYXUrciIc08RA8r262udOdvMfEv=DMARC1; p=reject; rua=mailto:dmarc-reports@deadsimple.emailUser-agent: * Allow: / Sitemap: https://deadsimple.email/sitemap.xml # AI crawlers welcome User-agent: GPTBot Allow: / User-agent: ChatGPT-User Allow: / User-agent: Google-Extended Allow: / User-agent: anthropic-ai Allow: / User-agent: ClaudeBot Allow: / User-agent: PerplexityBot Allow: / User-agent: Bytespider Allow: / User-agent: CCBot Allow: / User-agent: OAI-SearchBot Allow: / User-agent: Amazonbot Allow: / User-agent: Applebot-Extended Allow: / User-agent: cohere-ai Allow: /
# Dead Simple Email
> Email infrastructure for AI agents. Create inboxes, send and receive messages, get real-time webhooks — all through a simple REST API.
Dead Simple Email provides email-as-a-service specifically designed for AI agents and automation. Developers can create fully functional email inboxes via API, send and receive messages, and get real-time webhook notifications when emails arrive.
## Key Features
- **Instant Inboxes**: Create email inboxes via API — no DNS setup required
- **Send & Receive**: Full two-way email through a REST API
- **Durable Webhooks**: HMAC-signed on every plan, with automatic exponential-backoff retries, a per-webhook delivery log, and one-click replay — failed deliveries are never silently dropped
- **Real-Time Delivery**: Webhooks, WebSocket, and Server-Sent Events (SSE) streaming — including for sandboxed agents that can't host a webhook endpoint
- **Attachment Text Extraction**: Inbound PDF, XLSX, DOCX, and CSV attachments are automatically extracted to text your agent can read — no separate parser needed
- **Agent Self-Onboarding**: One call — `GET /v1/inboxes/{id}/verification` (or `wait_for_verification` in the SDK, `get_verification_code`/`wait_for_email` in the MCP server) — waits for an inbound email and returns the OTP, 2FA code, or magic link, so agents can sign themselves up to services autonomously from any language
- **Prompt-Injection Scanning**: Every inbound email is scanned before it is stored (pattern-based, deterministic, no model in the loop) and returned with `injection_risk` (none/low/medium/high) and `injection_score` (0.0 to 1.0) on the message object from `GET /v1/inboxes/{inbox_id}/messages/{message_id}` and the list endpoint. Eight pattern families: instruction overrides, system-prompt extraction, role reassignment, exfiltration requests naming an address or URL, chat-template delimiters ([SYSTEM], [INST], <|im_start|>), authority/urgency framing, execution requests, jailbreak vocabulary. High matches add 0.4, medium 0.15, capped at 1.0. Advisory: the message is stored and the `message.received` webhook fires regardless (the webhook payload does not carry the verdict; fetch the message). Pair with inbox guardrails (`require_draft_approval`, `allowed_domains`, `blocked_domains`, `can_forward`, `max_sends_per_hour`) which the API enforces on outbound actions. Live on every plan since launch, including Free. Docs: https://deadsimple.email/prompt-injection-scanning.html
- **Clean Reply Parsing**: Quoted history and signatures are stripped from replies (text and HTML), with automatic threading
- **Custom Domains**: Bring your own domain or use a shared subdomain
- **Pre-configured Deliverability**: SPF, DKIM, and DMARC handled automatically
- **IMAP/SMTP Access**: Every inbox includes standard IMAP (port 993) and SMTP (port 587) credentials — connect with any email client or library
- **Python & TypeScript SDKs**: Full-coverage SDKs (drafts, filters, templates, webhooks, streaming, identity, calendar, metrics) plus an MCP server exposing 19 tools
- **OpenAI dots and MCP Events**: Dots (OpenAI's always-on agents in ChatGPT) have no email address of their own at launch. Add https://api.deadsimple.email/mcp in ChatGPT as a custom MCP server with OAuth and the dot owns a Dead Simple inbox. The server speaks MCP 2026-07-28 and supports OpenAI MCP Events: `message.received` (optional filters `inbox_id`, `from_contains`, `subject_contains`; payload `inbox_id`, `message_id`, `thread_id`, `from`, `to`, `subject`, `snippet`, `received_at`) and `message.bounced` (optional `inbox_id`). ChatGPT calls `events/subscribe` with a callback URL and `whsec_` secret; deliveries are signed with Standard Webhooks HMAC, so new mail wakes the dot with no polling. Guide: https://deadsimple.email/integrations/dots.html
- **MCP OAuth 2.1**: The hosted MCP server (https://api.deadsimple.email/mcp) supports OAuth 2.1 — discovery (RFC 8414/9728), dynamic client registration (RFC 7591), PKCE S256 — so Claude, Cursor, Grok Bot, and grok.com connectors get one-click, no-key-paste installs; tokens are scoped to email operations only (no billing/admin), access 7 days, refresh 90 days with rotation, revocable via RFC 7009
- **Agent calendar (every inbox)**: Each inbox has a calendar. Create events (`POST /v1/inboxes/{inbox_id}/calendar/events`), send them as real iCalendar invitations with managed SEQUENCE so a reschedule updates rather than duplicates (`POST .../calendar/events/{event_id}/invite`, METHOD:REQUEST or CANCEL), answer invitations that arrived by email (`POST .../calendar/events/{event_id}/rsvp`, METHOD:REPLY, accepted/declined/tentative), list per inbox or across the account (`GET /v1/calendar/events`), and hand a human a subscribable feed (`GET .../calendar/feed` returns `feed_url` https and `webcal_url`; `POST .../calendar/feed/rotate` rotates the token; `GET .../calendar.ics?token=` is the feed, no API key). Inbound invitations, updates, cancellations and replies are ingested automatically: the message carries a `calendar_event` summary with `action` (created/updated/cancelled/replied/unchanged) and webhooks `calendar.event.created`, `calendar.event.updated`, `calendar.event.cancelled` fire. SDK: `client.calendar` (create, list, list_all, get, update, delete, invite, rsvp, feed, rotate_feed; camelCase in Node). MCP tools: `list_calendar_events`, `create_calendar_event`. No booking page yet (Nylas has Scheduler; AgentMail has no calendar). Docs: https://deadsimple.email/calendar.html
- **Metrics time series**: `GET /v1/metrics?from=&to=&interval=day|hour&inbox_id=` returns buckets of `sent`, `received`, `bounced`, `complained`, `opened`, `clicked`, `webhook_deliveries`, `webhook_failures`, `injection_flagged` plus totals; windows up to 92 days, hourly buckets for windows of 7 days or less; honours workspace and inbox-scoped keys. SDK: `client.metrics.get(from_=, to=, interval=, inbox_ids=)` / `client.metrics.get({ from, to, interval, inboxIds })`
- **Inbox-scoped API keys and webhooks**: `POST /v1/api-keys` accepts `inbox_ids` (max 100); a scoped key sees only those inboxes (any other inbox answers 404), account-wide listings are filtered to them, it cannot create inboxes, and it can only mint keys scoped to a subset of its own inboxes. `POST /v1/webhooks` and `PATCH /v1/webhooks/{id}` accept `inbox_ids` so a webhook fires only for events on those inboxes (`inbox_ids: []` clears the scope); `GET /v1/webhooks/{id}` shows it. SDK: `inbox_ids=` / `inboxIds` on `api_keys.create`, `webhooks.create`, `webhooks.update`
- **Sign in with Dead Simple (agent identity)**: A free OpenID Connect provider at https://id.deadsimple.email where the identity is an agent's inbox. Standard OIDC (discovery, JWKS, ES256 id_tokens, PKCE S256, RFC 7591 registration at /register, RFC 7009 revocation). Open clients need no registration (client_id is the app's https origin); registered clients can request `owner_email` (userinfo only) and `org`. An agent signs in with just its API key plus `inbox_id`, or an ES256 assertion from an enrolled P-256 key, or a human picks an inbox on the dashboard consent page. One-call helper: `POST /v1/inboxes/{inbox_id}/identity/sign-in` (`identity.sign_in` in the SDKs, `sign_in_with_inbox` in the MCP server). Claims: `sub` = inbox_id, `email`, `email_verified`, `name`, `agent: true`, `owner_verified`
- **Pay per request, no API key**: Twelve priced routes answer HTTP 402 when called with no credentials. Pay inline with x402 (USDC on Base eip155:8453, Polygon eip155:137, or Solana mainnet; `exact` scheme; PayAI facilitator; retry with `PAYMENT-SIGNATURE` or `X-PAYMENT`) or, on inbox creation, with Stripe's Machine Payments Protocol (`WWW-Authenticate: Payment`, retry with `Authorization: Payment <credential>`). Prices: inbox $1.00, send/reply/forward $0.01, reads $0.005. x402 is verified before the work and settled after; MPP refunds if the work fails. The paying wallet keys a Pay as you go account and the first paid inbox returns `credentials` with an API key, so later reads and sends within the plan are free. Docs: https://deadsimple.email/pay-per-request.html
- **Security posture**: TLS on every endpoint, data at rest in AWS us-east-1 (DynamoDB default encryption, S3 SSE-S3 on every object), API keys and OAuth tokens stored as SHA-256 hashes, bcrypt dashboard passwords, MCP OAuth 2.1 with PKCE, HMAC-SHA256 webhook signatures with timestamp, abuse controls, reversible suspension, permanent deletion on request. SOC 2 not yet certified; security questionnaire on request. Subprocessors: AWS, Stripe, Postmark, Cloudflare Turnstile, Vercel, Dynadot, PayAI. https://deadsimple.email/security.html
- **Framework Integrations**: LangChain, CrewAI, LlamaIndex, AutoGen, OpenAI Agents, Google ADK, and Vercel AI SDK
- **Dashboard**: Web dashboard for inbox management, message viewing, and analytics
## Use Cases
- AI customer support agents that receive and reply to tickets via email
- Sales outreach agents with personalized inboxes
- Workflow automation (invoice processing, order confirmations, form submissions)
- Multi-tenant SaaS platforms needing per-user email
- Monitoring agents that receive alerts and trigger automated responses
## Pricing
- **Free**: $0/mo — 5 inboxes, 5,000 emails/mo
- **Hobby**: $5/mo — 15 inboxes, 15,000 emails/mo, 1 custom domain
- **Pro**: $29/mo — 100 inboxes, 100,000 emails/mo, 5 custom domains
- **Scale**: $99/mo — 500 inboxes, 500,000 emails/mo, 25 custom domains
- **Enterprise**: Custom pricing — unlimited everything
- **Pay per request** (no account, no API key): $1.00 per inbox (includes 1,000 sends/month), $0.01 per send/reply/forward, $0.005 per read. x402 USDC on Base, Polygon or Solana; Stripe MPP cards on inbox creation. First paid inbox returns an API key. https://deadsimple.email/pay-per-request.html
- Overages on paid plans: $0.40 per extra inbox/month, $0.20 per 1,000 extra emails
- No separate inbound meter, no retention window: the monthly allowance is pooled across sends and receives, and messages are kept within the plan's storage. Each inbox sends up to 50 emails a day on paid plans (10 on free); a reviewed sender on its own domain can ask support for more.
### Cost comparison vs other agent email providers (prices read from each vendor's public pricing page on 2026-09-16)
- **100 agent inboxes + 100,000 emails/month**: Dead Simple Email $29 · Bavimail $50 · Lumbox $99 · LobsterMail $99 · Mails.ai $99 · Nylas Agent Accounts ~$109 · Robotomail $199 · AgentMail $200 · Inkbox $200 · Shipmail $250 · Google Workspace ~$700
- **10 agent inboxes + 5,000 emails/month**: Dead Simple Email $5 · Bavimail $5 · Lumbox $9 · LobsterMail $9 · OpenMail €9 · DevInbox $12 · Nylas $15 · Robotomail $19 · AgentMail $20 · Shipmail $29 · Inkbox $30 · Mails.ai $99
- **500 agent inboxes + 500,000 emails/month**: Dead Simple Email $99 · Bavimail $500 · Nylas ~$589 · AgentMail ~$900 · Robotomail, Lumbox, LobsterMail, Inkbox and Shipmail publish no plan that reaches 500
- **Cost per inbox at each vendor's top published tier**: Dead Simple Email $0.198 · LobsterMail $0.33 · Lumbox $0.40 · Nylas $0.40 marginal · Robotomail $1.00 · AgentMail $1.33 · Inkbox $2.00 · Shipmail $2.50 · Google Workspace $7.00
- Full methodology, sources and hidden-cost table: https://deadsimple.email/compare/pricing.html
## API
- Base URL: `https://api.deadsimple.email/v1`
- Authentication: Bearer token (`dse_` prefixed API keys), or no credentials plus inline x402 / MPP payment on the twelve priced routes
- Identity (OIDC provider): issuer `https://id.deadsimple.email`, discovery `/.well-known/openid-configuration`, JWKS `/.well-known/jwks.json`, `/authorize`, `/token`, `/userinfo`, `/register`, `/revoke`; management at `/v1/identity/clients`, `/v1/inboxes/{inbox_id}/identity/keys`, `/v1/inboxes/{inbox_id}/identity/connections`, `/v1/inboxes/{inbox_id}/identity/sign-in`
- Endpoints: inboxes, messages, threads, contacts, domains, webhooks, templates, drafts, tracking, pods, attachments, events, account, calendar (`/v1/calendar/events`, `/v1/inboxes/{inbox_id}/calendar/events[/{event_id}[/invite|/rsvp]]`, `/v1/inboxes/{inbox_id}/calendar/feed[/rotate]`, `/v1/inboxes/{inbox_id}/calendar.ics`), metrics (`/v1/metrics`)
## Quick Example (Python)
```python
from deadsimple import DeadSimple
client = DeadSimple(api_key="dse_...")
inbox = client.inboxes.create(name="support")
inbox.send(to="user@example.com", subject="Hello", body="Sent by AI")
messages = inbox.messages.list()
```
## Integrations
Dead Simple Email integrates with every major AI agent framework:
- **MCP Server**: Model Context Protocol server for Claude Desktop, Cursor, Windsurf — https://deadsimple.email/integrations/mcp.html
- **Cursor Plugin**: Official Cursor marketplace plugin, `/add-plugin deadsimple-email`, 8 skills and 14 tools over OAuth — https://deadsimple.email/integrations/cursor.html
- **Grok & Grok Bot**: grok mcp add for Grok Bot, or grok-4.6 function calling on the xAI API — https://deadsimple.email/integrations/grok.html
- **OpenAI dots**: Add the remote MCP server as a custom MCP server in ChatGPT (OAuth, no key); the dot gets its own inbox and new mail wakes it through MCP Events (`message.received`, `message.bounced`): https://deadsimple.email/integrations/dots.html
- **Meta Muse**: Muse builds a custom connector from the brief at https://deadsimple.email/connectors/muse.md; Muse Code uses the remote MCP server — https://deadsimple.email/integrations/muse.html
- **LangChain**: Drop-in toolkit with 6 email tools — https://deadsimple.email/integrations/langchain.html
- **CrewAI**: @tool-decorated functions for multi-agent crews — https://deadsimple.email/integrations/crewai.html
- **OpenAI Agents SDK**: FunctionTool wrappers and raw function definitions — https://deadsimple.email/integrations/openai-agents.html
- **Google ADK**: Connect via MCP to give Gemini agents email — https://deadsimple.email/integrations/google-adk.html
- **AutoGen**: Annotated tools with one-line registration — https://deadsimple.email/integrations/autogen.html
- **LlamaIndex**: ToolSpec for agents plus document reader for RAG — https://deadsimple.email/integrations/llamaindex.html
- **Vercel AI SDK**: Zod-validated tool definitions for TypeScript — https://deadsimple.email/integrations/vercel-ai.html
- **Python SDK**: Fully typed, sync + async — https://deadsimple.email/integrations/python-sdk.html
- **TypeScript SDK**: Promise-based with full types — https://deadsimple.email/integrations/typescript-sdk.html
- **Go SDK**: Idiomatic Go client — https://deadsimple.email/integrations/go-sdk.html
- **CLI**: Terminal tool for inbox management — https://deadsimple.email/integrations/cli.html
- **OpenClaw**: MCP-based integration for OpenClaw agents — https://deadsimple.email/integrations/openclaw.html
- **Hermes Agent**: MCP-based integration for Nous Research's self-improving agent — https://deadsimple.email/integrations/hermes.html
- **Replit**: Use Dead Simple Email from Replit Agent projects — https://deadsimple.email/integrations/replit.html
- **Microsoft Agent Framework**: MCP toolset for the AutoGen + Semantic Kernel successor — https://deadsimple.email/integrations/microsoft-agent-framework.html
- **Claude Agent SDK**: Email tools for agents built on Anthropic's Claude Agent SDK — https://deadsimple.email/integrations/claude-agent-sdk.html
- **Pydantic AI**: Type-safe email tools for Pydantic AI agents — https://deadsimple.email/integrations/pydantic-ai.html
- **Mastra**: Email tools for Mastra agents and workflows in TypeScript — https://deadsimple.email/integrations/mastra.html
- **Strands Agents**: Email for AWS Strands Agents via MCP and custom tools — https://deadsimple.email/integrations/strands.html
- **Agno**: Give Agno agents inboxes, sending, and OTP extraction — https://deadsimple.email/integrations/agno.html
- **Browser Use**: Real inboxes for Browser Use signup and OTP flows — https://deadsimple.email/integrations/browser-use.html
- **LiveKit Agents**: Voice agents that send the follow-up email via @function_tool or MCP — https://deadsimple.email/integrations/livekit.html
- **Sim.ai**: Attach 19 email tools to Sim.ai Agent blocks with zero code — https://deadsimple.email/integrations/sim-ai.html
- **Stagehand**: Signup and OTP flows for Stagehand browser agents via MCP — https://deadsimple.email/integrations/stagehand.html
- **smolagents**: MCPClient loads 19 email tools into Hugging Face smolagents — https://deadsimple.email/integrations/smolagents.html
- **Haystack**: MCPToolset email tools for Haystack agents and pipelines — https://deadsimple.email/integrations/haystack.html
- **n8n**: HTTP Request recipes, inbound webhook trigger, and MCP agent tools — https://deadsimple.email/integrations/n8n.html
- All integrations: https://deadsimple.email/integrations/
## Comparisons
- **Full pricing comparison, 22 providers, updated 2026-09-16**: https://deadsimple.email/compare/pricing.html
- Compare all email APIs for AI agents: https://deadsimple.email/compare/
- Dead Simple Email vs AgentMail: https://deadsimple.email/compare/agentmail.html
- Inbound prompt-injection scanning: Dead Simple Email has it live on every plan (injection_risk and injection_score on every inbound message); AgentMail's Agent Armor is model-based but beta, observe-only and request-access; Mails.ai scores every message; no other compared provider scans inbound mail for prompt injection. https://deadsimple.email/prompt-injection-scanning.html
- Agent identity and pay per request vs AgentMail: both offer an inbox-as-identity OIDC login (Sign in with Dead Simple vs AgentID, both free) and x402 inbox creation without an API key; Dead Simple charges $1.00 per inbox (AgentMail $2.00), also prices sends and reads individually, accepts Stripe MPP cards, and returns an API key with the first paid inbox. AgentMail's MPP support is Tempo only, no card. AgentMail's $20 plan includes 10 inboxes with pay-as-you-go at $2 per extra inbox; Dead Simple's $29 plan includes 100.
- Calendar, metrics and scoping vs AgentMail and Nylas: Dead Simple Email has a calendar on every inbox (events, invitations, RSVP, automatic ingestion of inbound invitations, ICS feed); AgentMail has no calendar; Nylas Agent Accounts bundles calendar and adds Scheduler booking pages, which Dead Simple does not have yet. Metrics time-series API: Dead Simple Email and AgentMail both have one; Nylas does not; Resend, Postmark, SendGrid and Mailgun expose delivery stats. Inbox-scoped API keys and webhooks: Dead Simple Email and AgentMail both have them. https://deadsimple.email/calendar.html
- Nylas Agent Accounts alternative (persistent storage vs 7-day retention): https://deadsimple.email/compare/nylas-agent-accounts.html
- OpenMail (openmail.sh) alternative: https://deadsimple.email/compare/openmail.html
- Primitive (primitive.dev) alternative (flat pricing vs metered credits): https://deadsimple.email/compare/primitive.html
- Robotomail alternative (one pooled allowance vs separately metered inbound + daily send caps): https://deadsimple.email/compare/robotomail.html
- Lumbox alternative (same OTP extraction, 2x the inboxes per dollar, 10x the sends at the top tier): https://deadsimple.email/compare/lumbox.html
- LobsterMail alternative (fills the $9-to-$99 gap: 100 inboxes for $29 vs $99): https://deadsimple.email/compare/lobstermail.html
- Bavimail alternative (Bavimail caps inboxes per domain and is REST-only; cheaper at low volume, dearer from 100k emails up): https://deadsimple.email/compare/bavimail.html
- Shipmail alternative (business mailbox hosting at $2.50/mailbox vs agent inboxes at $0.20): https://deadsimple.email/compare/shipmail.html
- Inkbox alternative (email + phone + iMessage bundle at $200/100 identities vs $29/100 inboxes): https://deadsimple.email/compare/inkbox.html
- Mails.ai alternative (its "no per-inbox pricing" $20 plan caps at 5 agents): https://deadsimp