New Sign in with Dead Simple: OIDC login for agents

Real email inboxes for your AI agents

Create inboxes by API, send from real addresses, and get replies back as structured webhooks — over REST or standard IMAP/SMTP. Every inbound email is scanned for prompt injection, and a real dashboard shows exactly what your agent did. No Gmail suspensions. No OAuth maze.

  • 5 inboxes free
  • 5,000 emails / month
  • No credit card
agent email loop live
Inbound Webhooks in real time
Outbound Send from your own domain
Trustpilot View our reviews
Interactive demo

See how it works.

app.deadsimple.email/dashboard
01 / 09
Dead Simple Email dashboard overview showing plan usage, inbox limits, and today's email activity
Step 1 of 9

1 / 9
What people are saying

Teams run the full email loop with Dead Simple.

Send, receive, reply, webhook — the whole cycle, running in production agent workflows.

Trustpilot View our reviews
Customer proof
Screenshot of a customer post saying the full email integration cycle with Dead Simple Email worked flawlessly.
Bridget, founder of Dead Simple Email $5 credit for attending
Talk to the founder

Thirty minutes with the person who built it.

Book a no-pressure call with Bridget, Dead Simple’s founder. Bring what you’re building, what’s confusing, or what you wish the API did. No pitch, no sales script.

Show up and we add a $5 credit to your account. It applies to your next invoice, on any plan, including free.

Book a call with Bridget 30 min · video call · pick any open slot
How it works

Inboxes, not workarounds.

Gmail suspends bot accounts. OAuth takes 200 lines of boilerplate. Mailbox suites charge $7–8 per seat. Dead Simple replaces that whole brittle stack — from signup to sending in under five minutes.

  1. Create inboxes

    Call POST /inboxes and your agent gets a real address instantly — on a shared domain or your own, with SPF, DKIM, and DMARC pre-configured.

  2. Send & receive

    Send via the API or SMTP. Replies arrive as structured JSON webhooks with automatic threading and reply parsing. Every inbox includes IMAP/SMTP credentials too.

  3. Automate with guardrails

    Events fire for every message, bounce, open, and click — while rate limits, domain restrictions, draft approval, and blocklists keep autonomous sending on-script.

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()
Built for agents

Everything your agent needs to operate through email.

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

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
  • Sign agents up to services autonomously — one call pulls the verification code or magic link
02

Inbound

Replies arrive as structured JSON — or over standard IMAP when a workflow needs it. Every inbox supports both.

  • Real-time delivery: webhooks, WebSocket, and SSE streaming
  • Reads attachments too — PDF, XLSX, DOCX, and CSV extracted to text your agent can use
  • Prompt-injection scanning — every inbound email scored so your agent knows what’s safe to act on
  • Clean reply parsing — quoted history and signatures stripped, threading handled
  • Durable webhooks on every plan: automatic retries, a delivery log, and one-click replay
03

Guardrails & scale

Autonomous sending stays on-script — and 5 inboxes grows to 500 without per-seat pricing or talking to sales.

Rate limits Domain restrictions Draft approval Blocklists Injection scanning Multi-tenant workspaces Scoped API keys
New

An inbox is now a login, a wallet is now an account, and every inbound email arrives labelled.

Three doors into the same product: let an agent sign in to your app with its inbox, let an agent with a wallet use the API with no signup at all, and let your agent know when a stranger is writing to the model instead of to it.

04

Sign in with Dead Simple

A free OpenID Connect provider at id.deadsimple.email where the identity is the agent’s inbox. Any app that accepts a generic OIDC provider can let an agent sign in.

  • Standard OIDC: discovery, JWKS, ES256, PKCE, RFC 7591 registration
  • Agents sign in with the API key they already hold; no key ceremony
  • Your app gets a stable sub, a verified email, agent: true and owner_verified
  • Works with Auth.js, Better Auth, Clerk, Auth0; open clients need no registration
Add it to your app →
05

Pay per request, no API key

Call a priced route with no credentials, get a 402 that says what to pay, pay inline, retry. An agent with a wallet gets an inbox in one HTTP round trip.

  • x402: USDC on Base, Polygon or Solana; Stripe MPP cards on inbox creation
  • $1.00 per inbox (includes 1,000 sends / month), $0.01 per send, $0.005 per read
  • Verified before the work, settled after; a failed call is never charged
  • The first paid inbox returns an API key, so the wallet becomes an account
See prices and headers →
06

Prompt-injection scanning

Inbound email is untrusted input. Every message is scanned before it is stored and comes back with injection_risk and injection_score, so the agent knows what it is reading before it acts.

  • Eight pattern families: instruction overrides, role reassignment, exfiltration requests, chat-template delimiters and more
  • none, low, medium or high, plus a 0.0 to 1.0 score, on the message object
  • Advisory, deterministic, no model in the loop; pairs with guardrails that the API enforces
  • Live on every plan since launch, including Free
See what it catches →
How we compare

More inboxes included at every price.

Other agent email APIs include 10 inboxes at $20/mo and bill $2 for every extra one. Dead Simple includes 100 inboxes at $29/mo on a $0, $5, $29, $99 ladder, with a full dashboard on every plan. And deliverability isn't a black box: every message runs through infrastructure we build and actively manage for inbox placement, with per-inbox reporting so you can see exactly what's landing.

100 inboxes $29/mo on Dead Simple

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

Inbound security Prompt-injection scanning built in

Every inbound email is scored before your agent acts on it. Nobody else does this.

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$30/mo ($20 + 5 extra at $2)$105–120/mo
Pricing tiers$0, $5, $29, $99$0, $20, $200, plus $2 per extra inboxPer-seat
Agent identity (OIDC sign-in)Sign in with Dead Simple, free on every planAgentIDNo
Pay per request, no API keyx402 USDC or Stripe card, $1.00 per inboxx402 at $2.00 per inbox; MPP on Tempo onlyNo
Webhook reliabilityRetries + delivery log + one-click replaySigned + retries, no log UINo webhooks
Real-time deliveryWebhooks, WebSocket & SSEWebhooks & WebSocketPolling
Reads attachments as textPDF, XLSX, DOCX, CSVYesManual
Prompt-injection scanningEvery inbound email, scoredNoNo
Verification code / OTP extractionAuto-parsed on every messageYesManual
DashboardAll plansAPI-onlyHuman-only UI
Deliverability reportingPer-inbox delivery, bounce & spam insightLimited visibilityNone
Framework integrationsLangChain, CrewAI, AutoGen, LlamaIndex, OpenAI Agents, MCPOpenAI Agents, Vercel AI, MCP — no CrewAI or AutoGenNone
DeliverabilityPurpose-built & actively managedShared environmentConsumer reputation
Bot account riskNone — built for agentsNoneSuspends bot accounts
Auth complexityAPI key (1 line)API keyOAuth 2.0 (200+ lines)
IMAP/SMTP accessEvery inboxYesYes
Pricing

Start free. Grow without a pricing cliff.

Move from 5 inboxes to 500 on published tiers, with 100 inboxes included at $29 instead of paying per extra inbox on top of a starter plan.

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 workspaces
  • Priority support
Choose Scale
No account, no API key

Pay per request

For agents that hold a wallet. Call a priced route, get a 402, pay inline with USDC over x402 (Base, Polygon, Solana) or a Stripe card over MPP, and retry. The first paid inbox returns an API key.

  • $1.00 per inbox, includes 1,000 sends / month
  • $0.01 per send, reply or forward
  • $0.005 per read
See pay per request

Overages on paid plans: $0.40 per extra inbox/mo, charged when created and at renewal · $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 workspacesYesYes
API rate limit60 / min120 / min300 / min1,000 / min
SDKs (Python, TS, Go)YesYesYesYes
Framework integrationsYesYesYesYes
IMAP/SMTP credentialsYesYesYesYes
SupportCommunityEmailPriority emailDedicated channel
FAQ

Common questions.

Three things. First, a real dashboard on every plan including Free; most agent email APIs are API-only, so you can’t see what your agent actually did. Second, built-in security: every inbound email is scanned for prompt injection and scored before your agent acts on it, and nobody else does this. Third, included capacity: Dead Simple’s $29 Pro plan includes 100 inboxes, while AgentMail’s $20 plan includes 10 and bills $2 per extra inbox on top, so 100 inboxes there runs about $200. Dead Simple’s ladder is $0, $5, $29, and $99. We also ship drop-in tools for LangChain, CrewAI, AutoGen, LlamaIndex, and the OpenAI Agents SDK, and deliverability is actively managed with per-inbox reporting, not a shared black box.

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. Deliverability is our focus, not an afterthought: sender reputation is actively managed for inbox placement, and you get per-inbox reporting on delivery, bounces, complaints, and spam placement so you can see exactly what’s landing. We handle bounce classification and automatic suppression of hard-bouncing addresses for you. 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.

Yes. Multi-tenant workspaces let you create isolated namespaces for each of your customers, with scoped API keys that only access their own inboxes. Workspaces 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.

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.

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. Sign in with Dead Simple is a free OpenID Connect provider at id.deadsimple.email where the identity is the agent’s inbox. Any app that accepts a generic OIDC provider (Auth.js, Better Auth, Clerk, Auth0) can let an agent sign up and sign in, and the agent authenticates with the API key it already holds, so there is no key ceremony. The app receives a stable sub, a verified email address, agent: true and owner_verified. Included on every plan, including Free.

Yes. Call a priced route with no credentials and it answers 402 with a price. Pay inline with x402 (USDC on Base, Polygon or Solana) or, for inbox creation, with a Stripe card via the Machine Payments Protocol, then retry. An inbox costs $1.00 and includes 1,000 sends per month, a send is $0.01, and a read is $0.005. The first paid inbox returns an API key, so the wallet becomes an account. See pay per request.

More questions? See the full FAQ or email us.

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.