Best transactional email API in 2026: seven providers compared, every cell sourced

It sends one email to one person when something happens in your application: a sign-up, a password reset, an order. Your code makes one HTTPS request. The service signs the message for your domain with DKIM, delivers it, keeps a suppression list of addresses that bounced or complained, and reports what happened to each message as a webhook event. Nobody logs in to read mail there; it is not a mailbox.

The rows below use the glossary’s terms: inbound email, signed webhooks, idempotent sends and dedicated IPs. Replay means sending a past event to your endpoint again after you fix the handler that dropped it; versioned templates keep earlier designs so a bad edit can be rolled back.

Every provider here also runs an SMTP relay. Use the API when you can change the code that sends; use the relay when you can’t, as with a CMS or an auth service that only takes SMTP settings (email API vs SMTP). Ours is smtp.rasket.com on port 465 or 587, with the username rasket and an API key as the password.

The arrow beside each cell opens the page it quotes. Not published means the vendor’s pages do not say; it is not a No. Best for is our reading, not a quotation. DKIM key size is left to the per-vendor pages, because none of the six competitors states it.

The assumptions: transactional email only, no marketing contacts, no add-ons, US dollars, paying monthly, and the cheapest combination of plan and per-email overage each price list allows, so a figure is often a larger tier rather than overage on a smaller one. Rasket’s row is computed by the calculator on the pricing page.

• Under 10,000 a month, Rasket and Resend are free up to 3,000 (100 emails a day). Past that, MailerSend ($7), Brevo (free while no day passes 300, then $9 for 5,000), Postmark and Mailgun ($15) all cost less than Rasket’s $20.
• At 50,000 the range is $19.95 (SendGrid) to $56 (Brevo); at 100,000 it is $34.95 (SendGrid) to $115 (Postmark). SendGrid’s free trial sends 100 a day and ends after 60 days, so its figure is always a paid plan.
• At 1,000,000, published prices run from $600 (Rasket and MailerSend) to $999 (Brevo). Raw cloud sending services charge less per email at this volume and leave bounce handling, webhooks and templates to you; they are not compared here.
• What counts as an email differs. Resend counts each received email toward the monthly quota, and Postmark prices plans by emails sent and received. If you receive a lot of mail, add it to your volume first.

* By default a Rasket project stops sending at 10 times its plan’s monthly emails, receipts and password resets included, until you raise its cap; you are warned as it gets close. So this is the cheapest month with room to spare. The rate steps down to $0.25 as the Scale ladder climbs. The pricing calculator shows $575 on the 100,000-email plan plus overage, but 1,000,000 is exactly that plan’s default spend cap (10 times its allowance, 1,000,000), so the next email would pause sending with 429 monthly_quota_exceeded until you raised the cap.

Resend is the closest match: the same free plan and entry prices, and the same answer on most product rows. It leads on client libraries, with official SDKs in eight languages, Rust and .NET among them, and on uptime, with a 99.99% SLA on Enterprise, where we print none. The difference shows when you add a mailing list. A product sending 50,000 emails a month in total, with 5,000 contacts on a newsletter list, pays $28.80 a month on Rasket (the $20 plan includes 4,500 contacts, and the rest cost one block of 1,000 at $8.80) and $60 on Resend: the $20 plan plus a $40 marketing plan for 5,000 contacts. Past the quota, extra email is $0.60 per 1,000 here against $0.90.

SendGrid includes a dedicated IP in its Pro plan at $89.95 for 100,000 emails, where Rasket’s costs $30 a month per address on Scale. It publishes seven official libraries and belongs to Twilio, which counts if you already buy SMS or voice there. The costs show up elsewhere: no free plan to stay on, three days of searchable activity on Essentials, and $1.33 per extra 1,000 on Essentials 50K ($0.88 on 100K), rates from Twilio’s plan sheet, since the pricing page prints none. The full bill, campaigns included, is in SendGrid pricing in 2026.

Postmark keeps 45 days of history by default and, on Pro and above, sells up to 365 days as an add-on, and keeps bulk mail on separate infrastructure (Message Streams), so newsletters and receipts never share a sending path. Its six official libraries include .NET and Java. It does not sign webhooks; its guide tells you to protect the URL with basic authentication and allowlist Postmark’s IP ranges. That works, but there is no signature for your code to check. At 50,000 emails it costs $55.

Mailgun has the cheapest plan on this page with a dedicated IP included: Foundation at 100,000 emails, $75 a month. Its inbound routing is rule-based, so “store mail to billing@, forward mail to support@” is configuration rather than code, and it keeps up to 40 versions of each template. The trade-off is history: one day of logs on Free and Basic, thirty only on Scale.

MailerSend is the cheapest way in, at $7 for 5,000 emails, and puts inbound routing on every plan, Free included. It publishes seven official libraries and a 99.5% uptime SLA from its Starter plan up. Its own pricing page gives two rates for extra email, $0.90 on the plan cards and $1.30 in the FAQ, so ask before you rely on either.

Brevo is a marketing suite first: campaigns, a sales CRM and live chat in one account. Its free plan allows 300 emails a day, the largest daily allowance of any free plan here, its pricing FAQ promises unlimited log retention, and it publishes seven SDKs. Its webhooks are protected by an IP allowlist, a password or a token rather than a signature, and its idempotency keys cover batch sends for 30 minutes.

This is what each vendor prints, read on 17 October 2026. An SLA (service-level agreement) is an uptime figure the vendor commits to in its contract.

For Rasket, the evidence you can check today is the live status page, which measures the API, sending, receiving, webhooks and the SMTP relay every five minutes. It shows the current state, not a history, and there is no SLA behind it. If your launch needs a contractual figure, that alone is a reason to choose Resend Enterprise or MailerSend Starter and above.

Inbox placement is not a row because no vendor here publishes placement rates measured the same way. Placement depends mostly on your domain’s reputation, your list and your complaint rate, though the quality of a provider’s shared IP pools also counts. To work on it, start with the deliverability guide.

For transactional email, mostly no: a receipt is sent because your application asked for it, so someone writes that request or connects a no-code tool such as Zapier or Make that makes it. Mailgun’s pricing page says it plainly: there is no send button in Mailgun. Rasket’s connectors are listed in the integrations docs.

For campaigns, Brevo, Resend and Rasket give you a sending screen on the plan you already have. Brevo has a drag-and-drop editor, and its FAQ says no prior skills are needed. Resend sends broadcasts from its dashboard. Rasket lets you build a segment and send a campaign designed in the template editor. SendGrid sells its campaign editor as Marketing Campaigns, a separate subscription.

One request sends one email. Replace the addresses with your own once your domain is verified:

curl https://api.rasket.com/emails \
  -H "Authorization: Bearer $RASKET_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: shortlist-test-1" \
  -H "User-Agent: acme-app/1.0" \
  -d '{"from":"hello@yourdomain.com","to":"you@example.com","subject":"Shortlist test","text":"Sent through Rasket."}'

A 200 means the message was accepted and recorded, not delivered; delivery comes later as an event. The body is the email’s id:

{ "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" }

A refusal carries statusCode, name and message (a missing User-Agent adds a code), and name is the value to branch on (errors):

{
  "statusCode": 422,
  "name": "missing_required_field",
  "message": "Missing required field: subject."
}

Retry only what can change: a lost answer, a 5xx, rate_limit_exceeded after its retry-after, and concurrent_idempotent_requests (the first attempt is still running). Send the same Idempotency-Key each time; the same key with a different body is refused with 409 invalid_idempotent_request, and keys are remembered for 24 hours. A 429 named monthly_quota_exceeded or daily_quota_exceeded is a quota or the spend cap, not a rate limit, and does not clear by waiting. This loop does that, with exponential backoff and jitter; idempotent email sends explains each line:

// Node 22+. The key names the email, not the attempt: reuse it on every retry.
const RETRY = new Set(["rate_limit_exceeded", "concurrent_idempotent_requests"]);

export async function sendEmail(email, key, attempts = 5) {
  for (let attempt = 1; ; attempt++) {
    let res;
    try {
      res = await fetch("https://api.rasket.com/emails", {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.RASKET_API_KEY}`,
          "Content-Type": "application/json",
          "Idempotency-Key": key,
          "User-Agent": "acme-app/1.0",
        },
        body: JSON.stringify(email),
        signal: AbortSignal.timeout(10_000),
      });
    } catch (error) {
      // No answer (network failure or timeout): it may have been accepted, so ask again.
      if (error.name !== "TypeError" && error.name !== "TimeoutError") throw error;
    }
    if (res?.ok) return res.json(); // { id }
    if (res && res.status < 500) {
      const { name = res.statusText, message = "" } = await res.json().catch(() => ({}));
      // Quota 429s and every other 4xx get the same answer again: fix, don't retry.
      if (!RETRY.has(name)) throw new Error(`${res.status} ${name}: ${message}`);
    }
    if (attempt === attempts) {
      throw new Error(`Gave up on ${key} after ${attempts} tries (last: ${res?.status ?? "no answer"})`);
    }
    const retryAfter = Number(res?.headers.get("retry-after")); // seconds, on rate limits
    const wait = retryAfter > 0 ? retryAfter * 1000 : 2 ** attempt * 250 * (1 + Math.random());
    await new Promise((resolve) => setTimeout(resolve, wait));
  }
}

For volume, POST /emails/batch takes up to 100 messages in one request, validated all or nothing, and one Idempotency-Key covers the whole batch, so a retry with that key returns the stored response rather than sending the batch again. With 10 requests a second, that is a ceiling of 1,000 emails a second (rate limits).

Delivery, bounce and complaint events arrive as signed webhooks. Every event has the same envelope; a bounce adds a bounce object, and a complaint carries the envelope alone. Hard bounces and complaints go on your suppression list without any code from you, so a handler is for your own records, such as flagging the address on the user’s account:

{
  "type": "email.bounced",
  "created_at": "2026-09-09T10:16:44.902Z",
  "data": {
    "email_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
    "from": "Acme <orders@send.acme.example>",
    "to": ["ronald.williams@example.com"],
    "subject": "Your order has shipped",
    "message_id": "<01000199a3c4d5e6-7f8a9b0c@send.acme.example>",
    "created_at": "2026-09-09T10:14:02.118Z",
    "tags": { "order": "1042" },
    "bounce": {
      "type": "Permanent",
      "subType": "General",
      "message": "smtp; 550 5.1.1 The email account that you tried to reach does not exist.",
      "diagnosticCode": ["smtp; 550 5.1.1 user unknown"]
    }
  }
}

Each delivery carries svix-id, svix-timestamp and svix-signature, and the scheme is Svix-compatible, so the open-source svix package verifies it. Events are tried up to ten times, hours apart, and can be replayed, so the same event can arrive twice: dedupe on svix-id, which never changes for an event (the schedule is in the webhooks reference).

// npm install svix (2.x)
import { createServer } from "node:http";
import { Webhook } from "svix";

const wh = new Webhook(process.env.RASKET_WEBHOOK_SECRET); // the whsec_ secret, shown once
const seen = new Set(); // in production: a unique svix_id column, written with the work

createServer((req, res) => {
  const chunks = [];
  req.on("data", (chunk) => chunks.push(chunk));
  req.on("end", () => {
    const raw = Buffer.concat(chunks).toString("utf8");
    try {
      wh.verify(raw, req.headers); // the raw body, never re-serialised JSON; throws on a mismatch
    } catch {
      return res.writeHead(400).end(); // bad signature, or more than five minutes old
    }
    const event = JSON.parse(raw);
    const id = req.headers["svix-id"]; // the same on every retry and replay of this event
    if (!seen.has(id)) {
      if (event.type === "email.bounced" && event.data.bounce.type === "Permanent") {
        console.log("stop mailing", event.data.to); // e.g. flag the address on the account
      }
      seen.add(id); // only after the work, so a crash mid-way is retried, not dropped
    }
    res.writeHead(200).end(); // any 2xx stops our retries, so a duplicate gets one too
  });
}).listen(3000);

Rasket is new. We publish no customer count, no sending volume and no uptime history, so you cannot judge us on track record. The others can be: Postmark says it has delivered mail since 2010, Brevo was founded in 2012, and Resend launched its sending platform in 2023. What you can check before paying is everything above: the prices, the live status page, and the API itself on the free plan.

Against Resend, the provider most like us, the choice comes down to three rows. Pick Rasket if you will send campaigns as well as receipts (one plan, one key: $28.80 against $60 in the newsletter example above) or expect to pay for overage. Pick Resend if you want an SDK in your language or a contractual SLA. Pick Postmark if a long record of transactional delivery matters more to you than price.

To limit the risk of a young provider, verify your domain with your top two at once; each signs with its own DKIM selector, so both can send. Keep the send call behind one function, like sendEmail above. Leaving then costs a key swap, new webhook secrets and deleting our DNS records (migration steps).

Pick another provider if any of these decides it for you:

• a CRM in the same account, which is Brevo’s job;
• between 3,000 and 10,000 emails a month, where MailerSend, Brevo, Postmark and Mailgun cost less;
• a dedicated IP inside the plan price, as Mailgun Foundation 100k, Mailgun Scale and SendGrid Pro include.

• Does your product read replies? Cross off any plan where inbound is not a Yes at your tier: Postmark keeps it to Pro and Platform.
• Do you send campaigns as well as receipts? Decide whether you want them on one plan and key (Rasket, Postmark’s Broadcast stream, Brevo) or as a second purchase (Resend, SendGrid).
• What is your real volume, received mail included? Read that column of the cost table, not the entry price.

Then send the same test message through your top two and compare what each can tell you about it an hour later. Rasket’s quickstart takes a new account from sign-up to that first send.