BIRD Email

The Email API your product depends on.

Send receipts, password resets and product notifications with an SDK in your language. Build with React or HTML, then follow delivery through events and analytics. Add campaigns, SMTP or inbound email as your product grows.

Start building Read the Email docs

Create your account, then follow the Email setup checklist to your first test send.

Set up in:

CursorCopied!

welcome.tsx

200 · 1.2s

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..."

welcome.tsx

200 · 1.2s

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..."

Find your email workflow

Build an integration, run a campaign or improve the email you already send.

Send from your applicationExplore transactional email, batch sends, templates and delivery webhooks.Create an email campaignConnect your contacts, define an audience and build your next broadcast.Improve email deliveryReview authentication, sender reputation, recipient quality and inbox placement.

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 auditable.

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.
Hard bounces and complaints create category-aware suppressions. Unsubscribes record a separate preference.
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.

Try the workflow with your own email.

Create an account, send a controlled test and follow its delivery events.

Start building

Explore the Email platform

Choose the workflow you need, from application email to campaigns and delivery controls.

Deliverability.

Authentication, managed IP warmup, recipient suppressions and delivery signals.

Analytics.

Delivery by domain, provider and IP, with separate engagement reporting.

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 signing, SPF alignment and DMARC policy setup.

Suppressions.

Recipient suppressions and opt-out preferences checked before delivery.

Email marketing.

Marketing campaigns: draft, target an audience, schedule, and send.

Broadcasts.

Draft, target, schedule and send the same campaign from the dashboard or API.

Contacts and 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.

SMTP relay.

Connect your existing application with a regional SMTP host and an API key.

Inbound email.

Receive messages through forwarding or your own subdomain, then process their content and attachments.

Inbox Insights.

Measure estimated inbox placement and run seed tests for your verified domains.

Competitive Insights.

Research captured competitor campaigns, sending cadence and panel-estimated placement.

Email validation.

Check an address through Lookup before adding it to your sending workflow.

Enterprise email.

Choose managed sending or explore PowerMTA and Momentum for your infrastructure.

Email resource library.

Find FAQs, explained articles, setup guides, migration help and tools.

Why we build email

Because your verification codes shouldn't live in a different vendor than your delivery receipts.

Read the Email docs

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.

welcome.tsx

200 · 1.2s

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..."

welcome.tsx

200 · 1.2s

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..."

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.

POST /webhooks/bird

signed

{
  "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" },
    "broadcast_id": null
  }
}

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.

order-shipped.tsx

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.

order-shipped.tsx

await bird.sms.send({
  from:     "Bird",
  to:       "+14155550172",
  text:     `Your code is ${code}.`,
  category: "authentication",
});

Pricing

Priced per 1,000 emails

Review published email rates for your expected sending volume, including the plan and any dedicated IP requirements. Compare the total for your use case before starting a migration.

See full pricing Start building

Trusted every day by teams that build world-class software

Send your first request before you write any code.

The whole public API is a Postman collection, converted from the same OpenAPI specification the SDKs are generated from, with an example request and response on every endpoint. Fork it into your own workspace, set an API key, and send a live request.

Open the collection in Postman Read the API reference

Questions about the Email API

Can I send both transactional and marketing email?

Yes, both go through the same send API. The only difference is the category field, which decides how suppressions and unsubscribes apply. Pick transactional for password resets and receipts, and marketing for campaigns.

What happens if a request times out and I retry it?

Send an Idempotency-Key header with each logical send. If the first request succeeded but you never saw the response, replaying it with the same key gives you the original result back with an Idempotency-Replay header, rather than sending the email twice.

Can I schedule a send for later?

Set scheduled_at to any time between 30 seconds and 30 days ahead. The send comes back accepted straight away and stays scheduled until it goes out, so you can cancel it at any point before then.

Can I attach files?

Yes, as base64 in the attachments array. To show an image inline, give it a content_id and reference that from your HTML with cid:. Keep the raw files at or below 15 MB so the message still fits the 20 MB cap once it is encoded, and note that executable and script content types are refused before the send.

Put it into practice.

Continue with the documentation, guides and examples for this topic. Resources are in English.

Watch the guideGetting started with email Implementation guideSend your first email Follow the learning pathBuild your first integration

Try the practice and get an implementation brief

Make your next email count.

Start with a test message, build your first campaign or bring a larger sending program to Bird. Choose the next step for your team.

Start building Plan your email program

Create your account, then follow the Email setup checklist to your first test send.

The Email API your product depends on.

Find your email workflow

5 minutes from npm installnpm install to first send

Send an email from the language you already use.

Ten parts of email that aren't your problem anymore.

Try the workflow with your own email.

Explore the Email platform

Because your verification codes shouldn't live in a different vendor than your delivery receipts.

Every state change is a webhook.

If you've integrated email, you've integrated SMS.

Priced per 1,000 emails

Send your first request before you write any code.

Questions about the Email API

Put it into practice.

Make your next email count.

Start with one channel.Add the others when you're ready.

5 minutes from npm install to first send

Start with one channel.
Add the others when you're ready.