Python SDK

pip install deadsimple-email

from deadsimple import DeadSimple

client = DeadSimple(api_key="dse_your_api_key")
inbox = client.inboxes.create(display_name="My Agent")

client.messages.send(
    inbox_id=inbox.inbox_id,
    to="user@example.com",
    subject="Hello from my agent",
    text_body="This email was sent by an AI agent.",
)

from deadsimple import AsyncDeadSimple

client = AsyncDeadSimple(api_key="dse_your_api_key")

inbox = await client.inboxes.create(display_name="Async Agent")
messages = await client.messages.list(inbox_id=inbox.inbox_id)

# authorization_url is the app's "Sign in with Dead Simple" link
# (its /authorize URL with PKCE, state and scopes already set).
result = client.identity.sign_in(inbox.inbox_id, authorization_url)
print(result["redirect_to"], result["final_url"], result["status"])
# follow=False returns redirect_to only, so you can drive the HTTP client yourself.

# Agents that should not hold a full API key: enrol a P-256 public key once,
# then sign a short-lived ES256 assertion at sign-in time.
key = client.identity.enroll_key(inbox.inbox_id, public_key=open("agent.pub.pem").read(), name="worker-7")
print(key["kid"])
client.identity.list_keys(inbox.inbox_id)      # shows last_used_at per key
client.identity.delete_key(inbox.inbox_id, key["kid"])

# Every app the inbox has signed in to, with scope and sign-in counts
client.identity.connections(inbox.inbox_id)

# Create, then invite. Nothing is sent until invite.
event = client.calendar.create(inbox.inbox_id, title="Kickoff",
                              start="2026-09-22T11:00:00", timezone="America/New_York",
                              duration_minutes=30, attendees=["dana@example.com"])
sent = client.calendar.invite(inbox.inbox_id, event["event_id"], text_body="Agenda to follow.")

# Reschedule: update raises sequence, invite again sends a revision, not a duplicate
client.calendar.update(inbox.inbox_id, event["event_id"], start="2026-09-23T11:00:00", timezone="America/New_York")
client.calendar.invite(inbox.inbox_id, event["event_id"])

# Invitations that arrived by email are already on the calendar (source == "inbound")
for ev in client.calendar.list(inbox.inbox_id, status="confirmed")["events"]:
    if ev["source"] == "inbound":
        client.calendar.rsvp(inbox.inbox_id, ev["event_id"], "accepted", comment="See you then.")

# Subscription URLs for Google Calendar, Apple Calendar or Outlook; rotate if the URL leaks
feed = client.calendar.feed(inbox.inbox_id)        # feed["feed_url"], feed["webcal_url"]
client.calendar.rotate_feed(inbox.inbox_id)

# Every event on every inbox the key can see
client.calendar.list_all(start_from="2026-09-21", start_to="2026-09-27")

# Last 30 days, daily buckets (the defaults)
m = client.metrics.get()
print(m.totals.sent, m.totals.received, m.totals.bounced)

# One week, hourly, for two inboxes
m = client.metrics.get(from_="2026-09-10", to="2026-09-17", interval="hour",
                       inbox_ids=[support_id, billing_id])
for bucket in m.series:
    if bucket.webhook_failures or bucket.injection_flagged:
        print(bucket.start, bucket.webhook_failures, bucket.injection_flagged)

# A key for one agent, limited to its own inbox
key = client.api_keys.create("support-agent", permissions=["read", "write"],
                             inbox_ids=[support_id])
print(key.key)          # shown once

# A webhook that only hears that inbox
hook = client.webhooks.create("https://agents.example.com/hooks/support",
                              events=["message.received", "calendar.event.created"],
                              inbox_ids=[support_id])

# Change the scope later; inbox_ids=[] makes it account-wide again
client.webhooks.update(hook.webhook_id, inbox_ids=[support_id, billing_id])
client.webhooks.get(hook.webhook_id)

# LangChain toolkit
pip install deadsimple-email[langchain]

# CrewAI tools
pip install deadsimple-email[crewai]

# OpenAI Agents SDK
pip install deadsimple-email[openai-agents]

# MCP server
pip install deadsimple-email[mcp]

# All framework integrations
pip install deadsimple-email[all]

# Create 10 inboxes at once
inboxes = client.inboxes.bulk_create(
    count=10,
    display_name_prefix="Agent",
)

for inbox in inboxes:
    print(f"{inbox.email} ready")

# Clean up when done
ids = [inbox.inbox_id for inbox in inboxes]
client.inboxes.bulk_delete(inbox_ids=ids)

export DSE_API_KEY=dse_your_api_key

dse inboxes list
dse send --inbox inb_xxx --to user@example.com --subject "Hello" --body "Hi there"
dse usage

import os
from deadsimple import DeadSimple

# Explicit key
client = DeadSimple(api_key="dse_your_api_key")

# Or from environment (reads DSE_API_KEY automatically)
client = DeadSimple()