Transactional email for AI-native apps

Email for
AI-native apps.

Apimend Mail gives AI-native apps a reliable way to send transactional email. Your application—or an agent acting through it—calls one API, with idempotent retries, sending limits, and signed events.

4,000 transactional emails / month · no card required
agent.ts
import { ApimendMail } from "apimend-mail";

const mail = new ApimendMail({ apiKey: process.env.APIMEND_KEY });

// call this from your agent loop
await mail.send({
  from: "agent@you.com",
  to: "user@example.com",
  subject: "Your weekly report",
  html,
  idempotencyKey: run.id, // deduplicate repeated requests
});
{
  "name": "send_email",
  "description": "Send an email to a user",
  "parameters": {
    "type": "object",
    "properties": {
      "to": { "type": "string" },
      "subject": { "type": "string" },
      "html": { "type": "string" }
    },
    "required": ["to", "subject", "html"]
  }
}
curl https://app.apimend.com/v1/send \
  -H "Authorization: Bearer $APIMEND_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $RUN_ID" \
  -d '{
    "from": "agent@you.com",
    "to": "user@example.com",
    "subject": "Your weekly report",
    "html": "<h1>Report ready</h1>"
  }'
OpenAI tool callsAnthropic tool useLangChainVercel AI SDKMCP serverAny HTTP client
For agent builders

Turn an agent result into the right email.

Let your agent do the work. Keep delivery policy, credentials, and guardrails in your application—not in the model prompt.

Close the loop

Send a clear summary when an agent finishes a research, support, or analysis task.

result → recipient

Request a human decision

Send an approval request with the context a person needs before your workflow continues.

action → approval

Alert on what matters

Notify the right person when an agent finds an exception, deadline, or change worth acting on.

signal → action
Illustrative workflows · your app controls when and to whom the agent can send
The problem

Agents act fast. Email punishes that.

An agent that retries a failed call should not send the same email twice. An agent that loops should not spam your users. Most email APIs were not built for this.

01

Retries become duplicates

Agents retry on timeouts. Without idempotency, your user gets the same email five times.

02

Runaway sends

A buggy loop, a bad prompt, or a stuck job can email your whole list before you notice.

03

No audit trail

When an agent acts, you need to know what it sent, to whom, and what happened next.

How it works

Give your agent a safe way to send.

A scoped key, a verified domain, and one tool call from your agent workflow.

01

Create a workspace

Sign up and get a scoped API key for each agent. The free tier works immediately.

am_live_ 8f3c0d...
02

Verify your domain

Prove ownership, add the SES identity and DKIM records, then check verification status.

_apimend-verification TXT
03

Give the agent the tool

Drop in the JSON schema or call the SDK. Pass a run id as the idempotency key.

POST /v1/send
Features

Built for agents, not just humans

01

Send API

Send transactional email with one JSON request. The API queues your message and returns an ID you can use to check its status.

Explore the send API →
02

Idempotent sends

Pass a stable key to deduplicate repeated requests. Uncertain provider outcomes are not automatically resent.

03

Guardrails on

Suppressions, plan caps, a daily send cap, and per-key rate limits keep a runaway loop in check.

04

Audit every action

A searchable log of every send with status, provider, and error. Know what your agent did.

05

Signed events

Signed send, failure, open, and click events. SES delivery receipts are available in email details.

06

Templates

Build reusable transactional emails in the visual editor or HTML, preview variables, and restore earlier revisions.

Explore templates →
07

Sending domains

Prove ownership and follow guided SES identity and DKIM setup before sending from your domain.

Explore domain setup →
08

Suppressions

Keep bounced, complained, and unsubscribed addresses out of future sends.

Explore suppressions →
09

Scoped keys

One key per agent. Revoke and rotate without touching the rest of your stack.

Under the hood

Reliability your agent can lean on

Boring infrastructure, done well, so the agent never has to care.

Safer retries and clear outcomes

Requests are queued for a worker. Repeated requests with the same idempotency key return the original result; uncertain provider outcomes require review.

  • Idempotency keys per account
  • Postgres-backed queue with skip-locked claiming
  • Explicit throttling retries with backoff
agent calls send (run_42)202 accepted
agent retries send (run_42)same id
worker sends oncesent
webhook email.sentprovider accepted

Guardrails that stop runaway agents

Set a daily cap and per-key rate limits. Suppressed addresses are blocked before a job is even queued, so a loop cannot reach people who opted out.

  • Daily send cap per account
  • Per-key rate limiting
  • Suppression checked before queue
queued today612 / 1,000
rate limit600 / min
suppressedblocked

Events your agent can act on

Every outgoing webhook is signed with t=<unix>,v1=<hmac>. The SDK provides a verifier; your application must verify the signature and timestamp before acting.

  • HMAC-SHA256 over the raw body
  • Timestamp tolerance for replay protection
  • Rotate a secret from the dashboard
import { verifyWebhook } from "apimend-mail";

const ok = verifyWebhook({
  secret: process.env.WH_SECRET,
  payload: rawBody,
  signature: req.headers["x-apimend-signature"],
});
// reject if false
Compare

Why agent teams pick Apimend

A modern email API built for automation, not 2012.

DIY SMTPLegacy ESPApimend
Tool-ready callbuild itpartialyes
Idempotent retriesbuild itnobuilt in
Guardrails and capsbuild itpartialyes
Signed webhook eventsbuild itpartialyes
Audit log of sendslogsyessearchable
Guided domain setupmanualyesguided
202
accepted in milliseconds
idem
deduplicate repeated requests
HMAC
signed event stream
caps
daily, per-key, per-plan
Pricing

Email infrastructure for growing teams.

Straightforward plans based on transactional email volume. Account creation is not open yet.

4,00050,000100,000200,000500,0001M1.5M2.5M3M+
Tool schemaFunction calling out of the box
Idempotent sendsDeduplicate repeated requests
GuardrailsDaily caps and plan rate limits
Signed eventsHMAC for agent loops
Included on every plan.
Recommended
Free
$0 /mo
4,000 emails / mo
  • ✓ Full API, SDK, and tool schema
  • ✓ Idempotent agent sends
  • ✓ Per-agent API keys
  • ✓ Signed webhooks and tracking
  • ✓ Suppression lists
  • ✓ 60 requests / min
  • ✕ Priority support
Request early access
Recommended
Starter
$15 /mo
60,000 emails / mo
  • ✓ All Free features
  • ✓ 300 requests / min
  • ✓ Email support
  • ✕ Priority support
Request early access
Recommended
Growth
$60 /mo
300,000 emails / mo
  • ✓ All Starter features
  • ✓ 600 requests / min
  • ✓ Priority support
Request early access
Recommended
Scale
$180 /mo
1,200,000 emails / mo
  • ✓ All Growth features
  • ✓ 1,200 requests / min
  • ✓ Priority queue
  • ✓ Dedicated support
Request early access
Send-based pricing with no automatic overage charges. Need more than 1.2M emails? Talk to us.
FAQ

Straight answers

What is Apimend Mail?

Apimend Mail is an email API for AI-native apps. Your product calls one endpoint to send receipts, alerts, and digests, and we handle queueing, retries, domain verification, and delivery events.

Is Apimend Mail a transactional email API?

Yes. It is built for app-triggered email like password resets, receipts, notifications, and digests. You send through an HTTP API or the TypeScript SDK.

How is Apimend different from SendGrid, Mailgun, or Postmark?

Those are established email providers. Apimend focuses on a small, modern API for AI-first teams, with idempotent retries, guardrails, and signed webhooks in one place. Under the hood we send through Amazon SES, so you get reliable delivery without managing it.

How is Apimend different from Resend?

Both are developer-focused email APIs. Apimend is built around agent workloads: idempotency for retries, daily caps and rate limits, and a tool schema for function calling. If you want marketing email or a large template editor, Resend is a better fit today.

Can an LLM or agent send email with this?

Yes. The API is one JSON call, and the tool schema works with any function-calling framework. Your agent calls send_email and the worker handles delivery.

How do you stop duplicate sends when an agent retries?

Pass an idempotency key, like your run id. A repeated request with the same key returns the original email instead of sending again.

What guardrails keep a runaway agent in check?

Suppressions are checked before a job is queued, per-key rate limits apply, and you can set a daily send cap and a monthly plan limit. A loop hits a wall instead of your users.

Is there a tool or function schema?

Yes. A JSON schema for a send_email tool is on this page and in the SDK. It works with OpenAI, Anthropic, and other frameworks.

Do you support MCP or LangChain?

Apimend Mail includes a local MCP server with tools to queue an email and check its status. LangChain and other agents can call the API using their standard tool or HTTP integrations. Your application remains responsible for recipient permissions and approval policy.

Do I need my own domain, and how do I verify it?

Add your domain, publish the ownership TXT record, then add the SES identity and DKIM records shown in the console. Apimend checks ownership and reports SES verification status.

What are DKIM, SPF, and DMARC?

They are email authentication records. DKIM signs your mail, SPF lists the servers allowed to send for your domain, and DMARC tells receivers what to do when authentication fails. Together they keep your email out of spam.

Which languages and frameworks are supported?

There is an official TypeScript SDK for Node. Any language that can make an HTTP request can use the API, including Python, Go, Ruby, and PHP.

Can I send email from a Next.js or Node app?

Yes. Install the SDK, add your API key, and call mail.send() from a server action or route handler. Keep the key on the server, never in the browser.

Do you support webhooks?

Yes. Subscribe to email.sent and email.failed or all events. Every outgoing webhook is signed with HMAC-SHA256 and retried with backoff.

How do I verify webhooks?

Use the verifyWebhook() helper in the SDK. It checks the HMAC and the timestamp, so you can reject forged or replayed events.

Do you support templates?

Yes. Create templates with {{tokens}}, keep the structure under your control, and let your app or agent fill the data.

How does open and click tracking work?

A small pixel records opens, and rewritten links record clicks. Counts show per email. You can disable tracking per send with track: false.

What happens to bounces and complaints?

Bounced, complained, and unsubscribed addresses are added to suppressions automatically and are blocked before a send. That protects your sending reputation.

Can I schedule or batch emails?

Yes. Set scheduledAt to delay a send, and use the batch endpoint to send up to 100 emails in one request.

How do I migrate from another provider?

Point your sending code at the Apimend API, add your domain, and run a test send. The SDK is small, so migration is usually a few lines.

Is there a free plan?

Yes. The free plan includes 4,000 emails per month, one domain, the API and SDK, and signed webhooks. No card required.

How is email usage counted?

Each recipient counts as one email toward your monthly allowance. Accepted sends count toward usage even if delivery later fails. Requests that exceed your remaining allowance are rejected; there are no automatic overage charges.

Do you support SMTP?

Not yet. Apimend is an HTTP API with an official TypeScript SDK. SMTP is on the roadmap.

How is my data handled?

API keys are hashed, webhook secrets are encrypted at rest, and webhook URLs are checked to block private addresses. You can export or delete your workspace data at any time.

Give your agent a reliable send action.

Connect a tool-calling agent to transactional email with the guardrails your app needs.

Request early access
Account creation is not open yet.
Request early access