BIRD Email
The Email API for developers who ship the rest of the message too.
Transactional and marketing email on the same infrastructure that carries your SMS, voice, and WhatsApp. About 40% of the world's commercial email transits the Bird network. We've been at this a decade. On Black Friday weekend 2025 we processed 19.9 billion emails.
import { BirdClient } from "@messagebird/sdk";
import { render } from "@react-email/render";
import { WelcomeEmail } from "./emails/welcome";
const bird = new BirdClient({ apiKey: process.env.BIRD_API_KEY! });
const { data, error } = await bird.email.send({
from: "Bird <hello@bird.com>",
to: ["ada@example.com"],
subject: "Your invite is ready",
html: await render(<WelcomeEmail name="Ada" />),
}).safe();
if (error) throw error;
console.log(data.id);
// → "em_2bX91Yk8h..."
You can sign in any time at bird.com/login.
Your test API key is on your dashboard, ready to send.
5 minutes from npm install to first send
Send an email from the language you already use.
SDKs in every major runtime. The first send can go to a sanctioned test address (delivered@messagebird.dev), so you can build against the live API (sends, webhooks, the whole flow) before you verify a domain.
const msg = await bird.email.send({
from: { email: "onboarding@messagebird.dev", name: "Bird" },
to: ["delivered@messagebird.dev"],
subject: "Hello from Bird",
html: "<p>My first Bird email.</p>",
});
console.log(msg.id, msg.status); // "em_…", "accepted"Ten parts of email that
aren't your problem anymore.
Deliverability and operational primitives,
named and audit-able.
- 01
Signed at the edge.
Three records to publish: DKIM, a return-path CNAME, and a DMARC policy. The CNAME covers SPF too, so nothing has to go on your domain apex.
- 02
An audit before you send a byte.
Point the audit tool at any domain and it resolves the live DMARC, SPF, DKIM, BIMI, and MX records, grades how they work together, and ranks what to fix. No account needed.
- 03
Managed dedicated IPs.
Provisioned per account and warmed automatically over roughly 30 days, organized into pools you control.
- 04
Dynamic suppression list.
Bounces, complaints, and unsubscribes suppress the recipient automatically and reversibly.
- 05
No polling to verify a domain.
Add a domain, publish the records, and Bird re-checks on its own until they resolve, usually within minutes of DNS propagating. There's a verify call if you want an answer right now.
- 06
Stored templates, or your own HTML.
Name a stored template and Bird renders it with Liquid, or render React Email to HTML in your app and pass the result.
- 07
Searchable email log.
Every message you send is logged with its delivery events and status. Query any email by ID.
- 08
Deliverability metrics, broken down.
Bounce codes, complaint types, and mailbox-provider and client breakdowns, broken out per domain, ISP, and IP, in the dashboard and via the stats API.
- 09
Inbound parsing.
Take a Bird-generated forwarding address, or publish MX records on a subdomain you own. Either way the mail arrives as a signed webhook you can thread.
- 10
Batch send up to 100.
Up to 100 independent messages per call, each with its own recipient and variables. One idempotency key covers the batch.
Explore the Email platform
Each capability in depth. One API, one set of keys.
Deliverability.
Authentication, IP warmup, suppression, and blocklist monitoring.
Analytics.
Delivery and engagement metrics, per domain, ISP, and IP.
Sending.
Transactional and marketing email, templates, and batch sends.
Templates.
Stored, versioned email templates, personalized per recipient at send.
Dedicated IPs.
Managed dedicated IPs and pools, warmed automatically.
Sending domains.
Domain verification, DKIM/SPF/DMARC signing, and DMARC monitoring.
Suppressions.
Automatic, reversible suppression of bounces, complaints, and unsubscribes.
Broadcasts.
Marketing campaigns: draft, target an audience, schedule, and send.
Audiences.
Your contacts and the audiences you target from a broadcast.
Agent Mailboxes.
A real inbox your code owns. Claim an address, receive mail into threads, and reply over the API.
Why we build email
Because your verification codes shouldn't live in a different vendor than your delivery receipts.
Email isn't its own product; it's one channel in a flow. Auth codes start as email and fall back to SMS. Receipts ship by WhatsApp when the customer prefers it. Bird Email is the one whose API, webhooks, and idempotency contract match every other channel, because the same engineering team built them all on the same network.
import { BirdClient } from "@messagebird/sdk";
import { render } from "@react-email/render";
import { WelcomeEmail } from "./emails/welcome";
const bird = new BirdClient({ apiKey: process.env.BIRD_API_KEY! });
const { data, error } = await bird.email.send({
from: "Bird <hello@bird.com>",
to: ["ada@example.com"],
subject: "Your invite is ready",
html: await render(<WelcomeEmail name="Ada" />),
}).safe();
if (error) throw error;
console.log(data.id);
// → "em_2bX91Yk8h..."
You can sign in any time at bird.com/login.
Your test API key is on your dashboard, ready to send.
Every state change is a webhook.
HMAC-signed payloads, replay-protected, idempotent. The same signed envelope on every Bird channel, so the handler you write for email already parses your SMS and WhatsApp events.
{
"type": "email.delivered",
"timestamp": "2026-05-19T15:42:01.221Z",
"data": {
"email_id": "em_01krdgeqcxet5s7t44vh8rt9mg",
"recipient_id": "er_01krdgeqcxet5s7t44vh8rt9mg",
"workspace_id": "ws_01krdgeqcxet5s7t44vh8rt9mg",
"recipient": "ada@example.com",
"recipient_role": "to",
"tags": [{ "name": "campaign", "value": "spring-2026" }],
"metadata": { "order_id": "ord_5512" }
}
}
Eight attempts over roughly 27.5 hours, backing off 5s, 5m, 30m, 2h, 5h, 10h, 10h with 20% jitter so retries don't synchronize. Every attempt reuses the same webhook-id, which is what makes your deduplication check work. After the last one the delivery is permanently failed, and a replay call recovers it.
email.acceptedThe send was accepted and is being prepared for delivery.email.processedQueued for the recipient's mail server.email.deliveredThe recipient's mail server accepted the message.email.openedThe recipient opened the message. Can fire more than once.email.clickedThe recipient clicked a tracked link.email.bouncedPermanently failed: bounce type and SMTP code in the payload.email.complainedThe recipient reported the message as spam.email.unsubscribedThe recipient opted out through a tracked unsubscribe link.email.list_unsubscribedThe recipient used their mail client's one-click unsubscribe.
If you've integrated email, you've integrated SMS.
Same auth model, same idempotency contract, same error envelope, same webhook shape. The difference is what each one does, not how you call it.
Verified domain, signed at the edge, suppression-aware. Render React or pass raw HTML.
await bird.email.send({
from: "hello@bird.com",
to: ["ada@example.com"],
subject: "Your code",
html: `<p>Code: ${code}</p>`,
});
SMS
Same envelope, same idempotency, same error type registry. The transport is the only difference.
await bird.sms.send({
from: "Bird",
to: "+14155550172",
text: `Your code is ${code}.`,
category: "authentication",
});
Pricing
From $0.30 per 1,000 emails
Start free: 1,000 emails a month, no card. Paid plans begin at $15 for 50K, and the Growth per-message rate keeps dropping as you scale to 2.5M. No platform fee, no seat fee, no tier features locked behind annual commits.
