# SadaSend

SadaSend is a transactional email API with a Model Context Protocol (MCP) server and per-key agent guardrails, built for developers who let AI agents send email on their behalf.

## Give your agent email. Not your whole account.

Scoped keys, recipient allowlists, and approval mode. The email API built for agents you don't fully trust yet.

## Built on the rails Gmail actually checks

Since November 2025 Google, Yahoo, Microsoft and Apple reject non-compliant bulk mail outright rather than filtering it. SadaSend enforces the requirements in the product, not in a help article.

- **SPF · DKIM · DMARC**: Verified before your first send is accepted
- **RFC 8058**: One-click unsubscribe headers injected automatically
- **Complaint rate**: Watched per account, throttled before 0.10%
- **Suppression**: Automatic and account-wide on every hard bounce

## Every other email MCP hands your agent the whole account

Read the competition carefully and they all promise the same thing: native access to the full platform. That is a capability claim with no control story — and it is the reason your engineering lead says no. SadaSend puts a ceiling on every key.

### Scoped keys — A key does one job

Every key carries an explicit scope set, its own rate limit, and a mode. An agent gets a key that can send and read — never one that can mint more keys or delete a domain.

Example: an agent attempts `keys.create` → **deny**. Key scope is [send, read]. Minting credentials requires a human in the dashboard.

### Recipient allowlist — Staging can never reach production

Restrict a key to specific addresses or domains. Your development key reaches your own team and nobody else — which prevents the single most expensive mistake in email.

Example: an agent attempts `send → customer@example.com` → **deny**. Key allowlist is [@sadasend.com]. Recipient is outside it.

### Approval mode — A human clears the send

Flag a key and its sends land in pending_approval instead of the queue. Clear them from the dashboard or a webhook. Off by default, on for anything an agent holds.

Example: an agent attempts `send → 4,812 recipients` → **hold**. Queued for approval. Nothing leaves until a human approves it.

### Dry run — Compose without sending

Validate, render and check suppression, then return exactly what would have been sent. Agents self-correct without touching a real mailbox — which makes them markedly better at the job.

Example: an agent attempts `send → dry_run: true` → **allow**. Rendered 4.1 KB. Suppression clear. No mail sent.

## Under ten lines to a delivered email

Install, set a key, send. The TypeScript SDK is hand-written — typed template variables, a real error class per failure mode, and automatic retry with idempotency so a retried send is never a duplicate.

### Bun

```
bun add sadasend

import { SadaSend } from 'sadasend';

const sada = new SadaSend(process.env.SADASEND_KEY!);

await sada.emails.send({
  from: 'you@yourdomain.com',
  to: 'user@example.com',
  subject: 'Welcome aboard',
  html: '<strong>It works.</strong>',
});
```

### Python

```
pip install sadasend

from sadasend import SadaSend

sada = SadaSend(os.environ["SADASEND_KEY"])

sada.emails.send(
    from_="you@yourdomain.com",
    to="user@example.com",
    subject="Welcome aboard",
    html="<strong>It works.</strong>",
)
```

### curl

```
# no install

curl https://api.sadasend.com/emails \
  -H "Authorization: Bearer $SADASEND_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "from": "you@yourdomain.com",
    "to": "user@example.com",
    "subject": "Welcome aboard",
    "html": "<strong>It works.</strong>"
  }'
```

### SMTP

```
# change credentials, not code

host:     smtp.sadasend.com
port:     587
security: STARTTLS
user:     sadasend
pass:     $SADASEND_KEY

# Every guardrail above applies to SMTP too —
# scope, allowlist, suppression, rate limit.
```

## A hosted MCP server with a ceiling

Point your agent at SadaSend and it gets the tools it needs — and none of the ones it should never have. No install required.

```
claude mcp add --transport http sadasend https://mcp.sadasend.com
```

| Tool | Scope | Does |
| --- | --- | --- |
| `send_email` | send | Send one, honouring key mode and allowlist |
| `preview_email` | send | Dry run — render and validate, never send |
| `get_email_status` | read | Delivery state and full event trail |
| `search_emails` | read | Filtered log search — the debugging workhorse |
| `check_domain_setup` | domains | Per-record DNS diagnosis, with the fix |
| `check_suppression` | read | Is this address suppressed, and why |
| `render_template` | read | Preview a template without sending |
| `get_stats` | read | Bounce and complaint rates for a window |

### Deliberately absent

There is no create_api_key, no delete_domain, and no remove_suppression tool. An agent that can mint its own credentials or un-suppress a complainer has no ceiling. Those operations live in the dashboard, where a human is present.

## Deliverability tools that tell you the fix

We are building these on the same verification engine that onboards sending domains. Free, no account, no rate limit, no email capture — launching soon.

- **SPF checker** (https://sadasend.com/tools/spf): Resolves every include and counts your lookups against the limit of ten.
- **DKIM validator** (https://sadasend.com/tools/dkim): Fetches the selector, checks the key length, verifies a signature.
- **DMARC checker** (https://sadasend.com/tools/dmarc): Parses your policy and tells you what it actually does to failing mail.
- **MX lookup** (https://sadasend.com/tools/mx): Resolves the chain and flags misconfigurations.
- **Blocklist check** (https://sadasend.com/tools/blocklist): Queries the major blocklists for an IP or domain.
- **Inbox placement test** (https://sadasend.com/tools/inbox): Send one message and see where it lands across major providers.

## Where we win, and where we do not

We are new. Resend and Postmark have years of sending reputation we cannot buy. Here is the real picture — if deliverability track record is your only criterion, choose Postmark and we will not argue.

| Capability | SadaSend | Resend | Postmark | Loops |
| --- | --- | --- | --- | --- |
| Transactional email API | yes | yes | yes | yes |
| MCP server | yes | yes | partial | yes |
| Per-key recipient allowlist | yes | no | no | no |
| Agent approval mode | yes | no | no | no |
| Dry run / preview send | yes | partial | no | no |
| Scoped API keys | yes | partial | partial | partial |
| SMTP relay | yes | yes | yes | no |
| Free deliverability tools | yes | no | partial | no |
| Years of sending reputation | no | yes | yes | partial |
| Marketing campaign suite | no | yes | no | yes |
| Visual email designer | no | yes | no | yes |

## Meter both, sting on neither

Send-based pricing punishes you for growing your list. Contact-based pricing punishes you for talking to it. We meter both, generously, and charge less than either.

### Free — $0/forever

Enough to run a real side project.

- 3,000 emails / month
- 1,000 contacts
- 1 sending domain
- 1-day log retention
- MCP server + all guardrails
- Every free tool

### Pro — $19/month

For a product with paying customers.

- 50,000 emails / month
- 5,000 contacts
- Unlimited domains
- 7-day log retention
- SMTP relay
- Approval mode + webhooks

### Scale — $79/month

When email is load-bearing.

- 150,000 emails / month
- 25,000 contacts
- 30-day log retention
- Priority sending queue
- Provider failover
- Support with an SLA

Plans are not open for sign-up yet — these tiers are the pricing we will launch with, published early so you can plan against them. Usage-based overage above plan. No per-seat pricing, ever — that is a model for sales tools, not developer infrastructure.

## Frequently asked questions

### What is SadaSend?

SadaSend is a transactional email API with a Model Context Protocol (MCP) server and per-key agent guardrails. It is built for developers who let AI agents send email on their behalf and need those agents to have real limits — scoped keys, recipient allowlists, approval mode and dry run.

### How is SadaSend different from Resend?

Resend is an excellent developer email platform with years of sending reputation and a broad marketing suite. SadaSend is narrower and safer: every API key carries a scope set, a rate limit, an optional recipient allowlist, and an optional approval mode, and the MCP server deliberately omits credential-minting and suppression-removal tools. If you want a marketing campaign suite, choose Resend. If you are handing a key to an autonomous agent, choose SadaSend.

### Can an AI agent send email with SadaSend?

Yes. Point any MCP client at the hosted server at mcp.sadasend.com and the agent gets tools for sending, previewing, searching logs, checking domain setup and reading statistics. What it cannot do is create API keys, delete domains, or remove addresses from your suppression list — those require a human in the dashboard.

### How do I stop an agent from emailing real customers by accident?

Give the agent a key with a recipient allowlist restricted to your own domain. Any send to an address outside the allowlist is refused at the API before it reaches the queue. For higher-risk work, additionally set the key to approval mode, which holds every send in a pending state until a human approves it.

### Does SadaSend support SMTP?

Yes. Point any existing mailer at smtp.sadasend.com on port 587 with STARTTLS, using your API key as the password. Every guardrail applies to SMTP exactly as it does to the REST API — scope, recipient allowlist, suppression and rate limit. Most people migrate by changing credentials rather than code.

### What does SadaSend cost?

The free tier is 3,000 emails and 1,000 contacts per month, permanently, including the MCP server and every guardrail. Pro is $19 per month for 50,000 emails and 5,000 contacts. Scale is $79 per month for 150,000 emails and 25,000 contacts. Overage is usage-based, and there is no per-seat pricing.

### Will SadaSend keep my email out of spam?

SadaSend refuses to send from a domain until SPF, DKIM and DMARC verify, injects RFC 8058 one-click unsubscribe headers on marketing mail automatically, suppresses hard bounces and complaints account-wide, and throttles an account before its complaint rate reaches the 0.10% threshold that mailbox providers act on. Deliverability is never guaranteed by anyone, but non-compliant mail is rejected outright by Gmail, Yahoo, Microsoft and Apple, and we do not let you send it.

### Which languages have SDKs?

TypeScript and Python at launch. The TypeScript SDK is hand-written with typed template variables and a distinct error class per failure mode; the Python SDK is generated from the published OpenAPI specification. Both ship automatic retry with backoff, idempotency keys generated by default, and a webhook signature verifier.