Resend Pricing Guide

Who this guide is for

This guide is for engineering-led SaaS teams whose highest-stakes email is sent from application code — receipts, invites, password resets, usage alerts — and who want that traffic on infrastructure they can debug at 2 a.m. without opening a marketing console.

You will get the most from it if your team already thinks in events and logs, prefers an API and an SMTP relay over drag-and-drop, and is willing to own deliverability practice rather than outsource it to a black box. Solo technical founders and platform teams both fit; so do stacks where product email ships in the same pull request as the feature that triggers it.

If nobody on the team will touch code and you need lifecycle playbooks out of the box, the pricing guides index points toward suite-first vendors instead — and our verified pricing snapshot shows how Resend's three meters compare with their single-axis bills.

The investment is not just SDK time. Owning the send layer means owning authentication hygiene, bounce policy, and the calendar on which volume grows — a small but real operations habit that suite-first teams never have to form.

Resend is evaluated as a developer-first send layer for teams that want event mail close to application code. Every claim here sticks to figures verified on official pages.

If you are shortlisting, read this page alongside our Customer.io guide and Brevo guide — they represent the two suite shapes most often paired with an API send layer.

Automation patterns on an API foundation

Resend gives developers primitives rather than playbooks: receipts, invites, trial warnings, and usage alerts fired from code with logs that make debugging painless. The DX details compound — typed SDKs, clear event webhooks, per-message logs — because the person debugging a missing receipt is the person who shipped the endpoint.

That alignment changes how teams operate: failures are diagnosed where the code lives, templates can ship through the same review flow as features, and nobody files a ticket to learn whether a send left the building.

The flip side is ownership: when something does not send, there is no vendor dashboard to hide behind — the log is the truth, and the team that shipped the trigger reads it.

Lifecycle depth — billing triggers, visual sequences, revenue attribution — lives in the suite you pair with Resend. Many stacks run both, with Resend handling event mail and the suite owning conversion. The contract between the halves matters: one shared suppression list, one authenticated domain strategy, and an agreed owner for every template.

Watching the meters that surprise teams

Three meters, not one: transactional volume (Pro $20 per 50k plus overages), marketing contacts (paid from $40 per 5k contacts with unlimited sends), and automation runs (10,000 included, then per-run fees). Heavy workflow users get surprised by the third — forecast automation runs from event logs before committing, and compare the full-stack cost against unified suites in our verified pricing snapshot.

The meters interact. A product launch spikes transactional volume in the first week, marketing contacts rise with the resulting signups, and any new onboarding workflow multiplies runs across every new contact — three curves moving together in the same thirty days.

Instrument them as three dashboards with one monthly review, and the invoice becomes arithmetic rather than archaeology.

Non-technical marketers will want a visual builder alongside the API. That is not a flaw so much as the product's stance: Resend is the send layer, and the layer above it is yours to choose. The teams who regret Resend are usually the ones who never chose the layer above.

Check Resend pricing

Pricing tiers and the billing axis

Three axes in one product: transactional meters sends (ideal for forecasting from application event logs), marketing meters contacts (friendly sends, familiar list-growth math), and automations meter runs (invisible until a branching program multiplies every send by several workflow steps). A growing SaaS list touches all three, which is why single-number comparisons against suite pricing are misleading.

Engineers appreciate this map because each axis has a natural owner: platform watches sends, growth watches contacts, lifecycle watches runs. What the model demands is that someone reconcile the three monthly — otherwise each half optimizes its own meter and the invoice arrives as a surprise.

What the axes do in practice: a big free-user base inflates only the marketing meter if those users receive campaigns — transactional volume stays proportional to real product activity. The automation-run meter is the sleeper; a modest program that re-evaluates several journeys per contact per day can pass 10,000 runs before anyone reads the docs twice. Export run counts monthly and model growth beside the other vendors in our pricing snapshot.

Where it fits in the five-stage lifecycle

Resend covers the transactional skeleton of every stage — the confirmation, the alert, the reminder — and does it excellently. What it does not provide natively is the orchestration between those sends: branching on billing state, multi-email narratives with exit goals, attribution proving which sequence recovered revenue. Those belong to the layer you choose above the API.

The stages are not equally served either: welcome and the transactional edges of retain are natural, while convert and win back usually need the narrative layer most.

The productive frame is complementary rather than compensatory: let Resend own anything a server should decide, and let the lifecycle suite own anything a marketer should iterate.

The frame also keeps incidents legible: when a receipt fails, the owner is unambiguous; when a nurture branch misfires, so is its.

Teams that try to make the API layer carry narrative sequences end up encoding copy in deploys; teams that make the suite carry high-volume receipts end up debugging marketing tools for outages.

When the split works, welcome and convert become a handshake: application events Resend already understands become suite triggers for the story around them.

Automation depth: what you can and cannot build

Inventory of the surface, stated plainly.

• Transactional sending from API, SDKs, and SMTP with per-message logs and event webhooks.
• Broadcast and campaign email to contact lists with contact-band pricing and unlimited sends on paid.
• Automation workflows — 10,000 runs included — for sequences and simple branching off product events.
• Domains, authentication, and suppression handled with developer-grade clarity.
• Event webhooks that feed whatever orchestration layer you prefer, including billing-native suites.
• Templates and audiences manageable through the API, so marketing content can ship via CI.
• Suppression and bounce handling exposed clearly enough to automate against.

What you should not expect: native subscription objects from Stripe, Paddle, or Lemon Squeezy driving branches with plan and payment context; per-flow revenue attribution; AI generation of whole lifecycle narratives; or a canvas tuned for marketer-only ownership at journey-design depth. E-commerce catalog playbooks and SMS are also not the center of this product's world.

The second honest limit is organizational. Automation runs are metered, so sprawling journey graphs have a financial shape as well as a maintenance one — programs built by trial-and-error replication tend to pass 10,000 runs quietly. Treat run count as a first-class metric next to sends, prune dead branches quarterly, and push narrative complexity to the layer that iterates without deploys.

There is also a craft limit: deliverability at volume is still yours. Resend gives you the instruments; open rates on a receipt do not substitute for bounce policy, complaint handling, and a human who reads the postmaster dashboard after every large send.

Where Resend fits in a SaaS stack

Resend is a send layer for server-decided mail; the lifecycle suite handles narrative stories. Where they compete is the middle ground — trial nudges, usage alerts, plan-change notes — and the philosophies diverge. Resend treats those as events your application emits, keeping truth close to code.

Both positions are coherent. The application-emits view keeps truth close to code and works beautifully until the branching narrative needs marketer iteration; the subscription-reads view keeps narrative close to billing and works beautifully until a bespoke product alert needs a deploy anyway.

Resend's counter is credibility with engineering: if receipts must be debuggable at the endpoint level and send volume should map directly to code paths, a purpose-built API remains the right call even when lifecycle lives elsewhere. Model its three meters against unified alternatives in our pricing snapshot before assuming the split is automatically cheaper.

Common mistakes when adopting Resend

API-first teams make a distinctive set of errors — the tooling is rarely the problem.

• Ignoring the automation-run meter until a branching program quietly passes 10,000 included runs.
• Letting marketers encode narrative sequences as application templates, so copy changes require deploys.
• Running two audiences — Resend contacts and suite contacts — without one shared suppression list.
• Building dunning in code where a billing-aware suite already owns the state machine.
• Treating the 100-per-day free cap as a production allowance and discovering it during launch week.
• Skipping deliverability monitoring because the logs are pretty — reputation still needs an owner.
• Never choosing the layer above the API, then blaming Resend for lacking journey depth.

The correction is architectural rather than tool-specific: assign every email a home (server-decided or marketer-iterated), give suppression and domain strategy single owners, and meter runs with the same seriousness as sends.

Most of these errors share one root — adopting the API as a strategy rather than as a layer. The layer needs a declared partner; without one, it absorbs jobs it was never meant to hold.

Pricing note and verdict

Free 3,000 monthly within a 100-per-day cap validates the send layer; Pro at $20 for 50,000 with $0.90 per 1,000 overage is one of the cleanest volume forecasts in the category. Marketing from $40 for 5,000 contacts and automation runs at 10,000 included then $0.0015 complete the picture — three meters, three owners, one monthly reconciliation.

The transactional meter is the one engineers trust: it maps to code paths they can count. The marketing and automation meters are the ones finance should own, because they follow list decisions and journey sprawl rather than deploy cadence.

Buy Resend when server-decided email is the point and the layer above is a deliberate choice. Model the full stack — Resend plus whatever suite carries narrative — against unified alternatives in our verified pricing snapshot before assuming the split is automatically cheaper.

Rollout plan

A 30-day rollout for a split Resend stack

1. Days 1–5 · Send layer. Authenticate the domain, route receipts and alerts through the API, and confirm per-message logs cover every application template.
2. Days 6–12 · Welcome handshake. Fire signup events into your lifecycle suite; ship the setup sequence there while Resend keeps confirmations.
3. Days 13–18 · Trial visibility. Emit trial and usage events; add the warning sends, keeping narrative copy out of deploy cycles.
4. Days 19–24 · Meter watch. Baseline sends, contacts, and automation runs; set a calendar reminder to review run counts monthly.
5. Days 25–30 · Suppression unity. Merge suppression across both halves, document the template ownership map, and review which stage still has no owner.

FAQ