Email API for AI agents

Purpose-built email accounts to supercharge your agents at scale.

Dead Simple Email gives AI agents their own inboxes with full send, receive, and webhook capabilities. Use the REST API, connect via standard IMAP/SMTP, or both. No Gmail suspensions. No per-seat pricing.

5 inboxes free
5,000 emails / month
No credit card
Inbound Webhook in real time
Outbound Send from your own domain
dse_
API key auth No OAuth
JSON
Threaded inbound Parsed for agents
DNS
Shared or custom Domains in minutes
inbox.json
{
  "name": "support",
  "address": "support@yourco.deadsimple.email",
  "webhook_url": "https://agent.yourco.dev/inbound"
}
What People Are Saying

Teams run the full email loop with Dead Simple.

Dead Simple supports the full send, receive, reply, and webhook notification cycle in real workflows. That kind of end-to-end proof matters when you are choosing infrastructure for production agents.

Customer feedback
Customer proof
Screenshot of a customer post saying the full email integration cycle with Dead Simple Email worked flawlessly.
The problem

Agents need inboxes, not workarounds.

Gmail suspends bot accounts. OAuth requires 200 lines of boilerplate. Mailbox suites charge $7-8 per seat. And self-hosting means managing DNS records, DKIM keys, bounce handling, and reputation yourself. Dead Simple handles all of that — and gives you both a REST API and standard IMAP/SMTP access on every inbox.

No Gmail bans No OAuth dance No pricing cliff
What it replaces

The brittle stack teams build when they outgrow consumer email.

  • Gmail suspensions and Google OAuth boilerplate
  • DIY IMAP polling, MIME parsing, and fragile webhook glue
  • Per-seat mailbox pricing that breaks unit economics
  • Manual SPF, DKIM, DMARC, bounce handling, and DNS setup
What you get

The infrastructure AI SDRs, support agents, and multi-agent apps actually need.

  • Real inboxes on a shared domain or your own custom domains
  • Inbound webhooks with structured JSON and HMAC signing
  • Automatic threading, reply parsing, and bounce handling
  • 5 inboxes free and 100 inboxes for $29/mo when you scale
Built for agents

Everything your agent needs to operate through email.

Not a mailbox suite with an API bolted on. Dead Simple is purpose-built for software that creates, sends, receives, and reacts to email programmatically.

01

Identity

Give each agent, customer, or workflow its own real email address that people can reply to.

  • Shared domain to start instantly — no DNS needed
  • Custom domains with auto SPF/DKIM/DMARC
  • Per-agent or per-tenant inbox creation via API
02

Inbound

Replies arrive as structured JSON via webhooks — or connect via standard IMAP if your workflow needs it. Every inbox supports both.

  • Real-time webhooks and WebSocket streaming
  • Automatic threading and reply parsing
  • Webhooks included on all plans, even Free
03

Scale

Go from 5 inboxes to 500 without per-seat pricing, infrastructure changes, or talking to sales.

  • 100 inboxes for $29/mo, 500 for $99/mo
  • Multi-tenant pods with scoped API keys
  • Bounce handling and deliverability built in
Why teams switch

Built for the way agents actually use email.

Other agent email APIs jump from $20/mo to $200/mo with nothing in between. They paywall webhooks, ship no dashboard, and list features as “coming soon.” Dead Simple includes webhooks and a dashboard on every plan, ships framework integrations for LangChain and CrewAI, and runs on its own mail infrastructure — not resold AWS SES.

No more Gmail hacks

Launch agent inboxes on infrastructure built for automation.

Create inboxes by API, send and receive through real addresses, and react to replies through structured webhooks without OAuth boilerplate or per-seat mailbox pricing.

REST + IMAP/SMTP Webhooks on every plan Shared + custom domains
Agent controls built in

Your agent sends email autonomously. Guardrails keep it from going off-script.

Rate limits Domain restrictions Draft approval Blocklists Action permissions Per-inbox scoping
50-85% cheaper than alternatives

We own our infrastructure — no third-party markup.

100 inboxes
$29/mo vs $200
15 inboxes
$5/mo vs $20
Webhooks
Free tier vs $200 tier
Dashboard
Included vs API-only
How we compare

The pricing cliff others don’t talk about.

Most agent email APIs jump from $20/mo to $200/mo with no plan in between. Dead Simple fills the gap with four tiers from $0 to $99 — and includes webhooks and a dashboard on all of them.

100 inboxes $29/mo on Dead Simple

$200/mo on AgentMail and roughly $700-800/mo on Gmail or Workspace.

Webhooks Included on every plan

No paywall for inbound events, even on Free.

Built for agents API key auth and real inboxes

No OAuth maze, no bot-account suspensions, no API-only dead ends.

Dead Simple AgentMail Gmail / Workspace
100 inboxes$29/mo$200/mo$700–800/mo
15 inboxes$5/mo$20/mo (10 inboxes)$105–120/mo
Pricing tiers$0, $5, $29, $99$0, $20, $200Per-seat
WebhooksAll plans incl. Free$200/mo tierNo
DashboardAll plansAPI-onlyHuman-only UI
Framework integrationsLangChain, CrewAI, AutoGen, Google ADK, MCPNoneNone
InfrastructureOwn (KumoMTA)AWS SESGoogle
Bot account riskNone — built for agentsNoneSuspends bot accounts
Auth complexityAPI key (1 line)API keyOAuth 2.0 (200+ lines)
IMAP/SMTP accessEvery inboxNoYes
How it works

From signup to sending in under 5 minutes.

Sign up, grab your dse_ API key, and start creating inboxes. Every inbox gets a real address on a shared domain instantly — no DNS setup, no domain verification, no provisioning delays.

A

Create inboxes

Call POST /inboxes and your agent gets a real email address like sales@yourco.deadsimple.email. Create one inbox or hundreds via bulk operations. Add custom domains when you need branded addresses.

B

Send and receive

Send outbound email via the API or SMTP — SPF, DKIM, and DMARC are pre-configured either way. When replies come in, they arrive as structured JSON via webhooks with threading, reply parsing, and sender info extracted for you. Need raw access? Every inbox includes IMAP/SMTP credentials too.

C

Automate

Webhook events fire for every inbound message, bounce, open, and click. Your agent can classify, reply, forward, or escalate — with guardrails that limit send rates, restrict domains, and require draft approval before anything goes out.

agent.py
from deadsimple import DeadSimple

client = DeadSimple(api_key="dse_...")
inbox = client.inboxes.create(name="sales")

inbox.send(
    to="buyer@example.com",
    subject="Quick follow-up",
    body="Your agent now has a real inbox."
)

messages = inbox.messages.list()
AI SDR & outreach tools

Teams building AI sales agents

Give each customer deployment its own sending inboxes without per-seat pricing. 100 inboxes for $29/mo instead of $200+ on competing platforms.

AI support platforms

Agents that reply to customers

Full conversation threading, draft approval for human-in-the-loop review, and per-customer inboxes that scale with your business.

Agent frameworks

LangChain, CrewAI, and multi-agent apps

Replace 200 lines of Gmail OAuth boilerplate with a 5-line API call. Simple API key auth, structured responses, and framework integrations.

Pricing Snapshot

Start free. Grow without a pricing cliff.

Move from 5 inboxes to 500 without getting shoved from a starter tier into a $200 plan the moment your product gets traction. Dead Simple keeps the ramp smooth at $5, $29, and $99.

Starter

Free

For experiments, prototypes, and early integrations.

$0 /mo
  • 5 inboxes
  • 5,000 emails / month
  • 500 MB storage
  • Shared domain
  • Webhooks on all events
  • Dashboard included
Get Started Free
Indie

Hobby

For solo builders and small product teams.

$5 /mo
  • 15 inboxes
  • 15,000 emails / month
  • 1 GB storage
  • 1 custom domain
  • Webhooks on all events
  • Dashboard included
Choose Hobby
High Volume

Scale

For large agent deployments and high-volume sending.

$99 /mo
  • 500 inboxes
  • 500,000 emails / month
  • 10 GB storage
  • 25 custom domains
  • Multi-tenant pods
  • Priority support
Choose Scale

Overages on paid plans: $0.40 per extra inbox/mo · $0.20 per 1,000 extra emails · Contact us for Enterprise

Plan feature matrix See every feature across Free, Hobby, Pro, and Scale

Webhooks, dashboard, and structured JSON responses are included on all plans — not paywalled behind expensive tiers.

Show plan features Hide plan features
Feature Free Hobby Pro Scale
Inboxes515100500
Emails / month5,00015,000100,000500,000
Storage500 MB1 GB5 GB10 GB
Custom domains1525
WebhooksAll eventsAll eventsAll eventsAll events
DashboardYesYesYesYes
Threading & reply parsingYesYesYesYes
Drafts & templatesYesYesYesYes
ContactsYesYesYesYes
Open & click trackingYesYesYesYes
Bounce handlingYesYesYesYes
Agent guardrailsYesYesYesYes
Multi-tenant podsYesYes
API rate limit60 / min120 / min300 / min1,000 / min
SDKs (Python, TS, Go)YesYesYesYes
Framework integrationsYesYesYesYes
IMAP/SMTP credentialsYesYesYesYes
SupportCommunityEmailPriority emailDedicated channel
FAQ

Common questions.

AgentMail’s pricing jumps from $20/mo (10 inboxes) to $200/mo (150 inboxes) with no plan in between. They paywall webhooks behind the $200 tier, have no dashboard, no LangChain or CrewAI integrations, and list features like semantic search as “coming soon.” Dead Simple includes webhooks and a full dashboard on every plan including Free, ships integrations for LangChain, CrewAI, AutoGen, and MCP, and runs on its own infrastructure — not resold AWS SES. Our Pro plan gives you 100 inboxes for $29/mo.

We run our own email infrastructure — dedicated mail transfer agents and inbound servers — rather than reselling third-party services at a markup. This gives us direct control over deliverability and costs, which we pass on as lower pricing. We're also intentionally priced for teams that need lots of inboxes, not enterprise contracts.

Yes. Dead Simple is fully bidirectional. Inbound emails arrive as structured JSON via real-time webhooks (HMAC-signed) or WebSocket streaming, so your agent can react instantly. WebSockets work behind firewalls with no public URL needed. You also get automatic threading, reply parsing (quoted text is stripped), and conversation history — all through the API. Every inbox also comes with standard IMAP credentials, so you can connect with any email client or library if your workflow needs it.

Yes. Every inbox comes with standard IMAP and SMTP credentials, available via the GET /inboxes/{id}/credentials endpoint. Connect with any email client (Thunderbird, Apple Mail, Outlook), use Python’s imaplib, or plug into legacy tools that speak IMAP/SMTP. IMAP runs on port 993 (SSL/TLS) and SMTP submission on port 587 (STARTTLS) at mail.deadsimple.email. Use the REST API, IMAP/SMTP, or both — it’s your choice.

SPF, DKIM, and DMARC are configured automatically for every inbox — on shared domains and custom domains. We handle bounce classification, automatic suppression of hard-bouncing addresses, and domain reputation management. You don't need to configure any DNS records to start sending on the shared domain. When you add a custom domain, we generate the required DNS records and verify them for you.

When you sign up, you get a subdomain like yourco.deadsimple.email. Inboxes you create get addresses like support@yourco.deadsimple.email. No DNS configuration needed — it works instantly. Custom domains are available on Hobby ($5/mo) and above.

Both. You get a full web dashboard for visual inbox management, message viewing, webhook configuration, domain setup, and usage monitoring — included on all plans, even Free. Most competing agent email APIs are API-only with no visual interface at all.

Yes. Multi-tenant pods let you create isolated namespaces for each of your customers, with scoped API keys that only access their own inboxes. Pods are available on Pro ($29/mo) and Scale ($99/mo). You can also use bulk inbox creation to provision many inboxes at once. Competitors typically charge $200/mo or more for multi-tenant isolation.

Yes. The drafts API lets your agent compose an email and save it for human review before sending. You can also set up agent guardrails per inbox — rate limits, allowed/blocked domains, required draft approval, and action permissions — so you stay in control of what your agent sends.

We provide typed, async-ready SDKs for Python, TypeScript, and Go, plus a CLI tool. For agent frameworks, we have drop-in integrations for LangChain, CrewAI, AutoGen, OpenAI Agents SDK, and LlamaIndex. We also have an MCP server for Claude and Cursor, compatible with Google ADK. Most competing APIs don't ship any framework integrations at all.

Gmail and Outlook actively suspend accounts that send programmatically — it's a violation of their terms of service. Google OAuth requires 200+ lines of boilerplate and constant token management. And per-seat pricing ($7-8/mailbox/month) makes 100 mailboxes cost $700-800/mo. Dead Simple gives you 100 inboxes for $29/mo with simple API key auth and no suspension risk.

Yes. You can enable open tracking (via tracking pixel) and click tracking (via redirect URLs) per message. Tracking events fire webhooks (message.opened, message.link_clicked) so your agent can react to engagement in real time. Stats are also available via the API and dashboard.

Plans are billed monthly via Stripe. If you exceed your plan limits on paid tiers, overages are metered at $0.40 per extra inbox/month and $0.20 per 1,000 extra emails. No sudden shutdowns. On the Free tier, sending pauses until the next cycle, but inbound mail still works. You can upgrade or downgrade at any time — upgrades are prorated, downgrades take effect at the end of the billing period.

The Free tier is your trial. It includes 5 inboxes, 5,000 emails per month, webhooks, and dashboard access with no time limit. Build and test your full integration before you need to scale. No credit card required.

Yes. Dead Simple uses standard REST patterns and API key authentication, so switching from another provider is straightforward. Our SDKs cover all endpoints with typed methods. If you're coming from a provider that charges $200/mo for 150 inboxes, you could save $101-171/mo on our Pro or Scale plans while getting features like a dashboard and webhooks that may have been paywalled before.

You can create reusable email templates with {{variable}} placeholders and render them with dynamic data at send time. Templates are managed through the API and dashboard, making it easy for your agents to send consistent, personalized messages without constructing HTML from scratch.

Enterprise includes unlimited inboxes, unlimited emails, dedicated sending infrastructure, custom retention policies, SLA guarantees, SSO, and a dedicated support channel. Contact us to discuss your needs.

Start free

Give your agents email that just works.

Start with 5 inboxes and 5,000 emails per month. No credit card required. Upgrade when you're ready to scale.