2026-05-08 · ~6 min read

Resend vs Postmark vs SendGrid for Stripe Webhook Emails (2026 Comparison)

Your Stripe webhook fires; you need to send the customer "your case is open" or "thanks for the order" email; you have to pick a provider. Three real choices for indie-hacker scale: Resend, Postmark, SendGrid. Comparison table at the top, gotcha section at the bottom.

The decision matrix

Criterion	Resend	Postmark	SendGrid
Free tier	3,000/mo	100 in dev mode (test only)	100/day forever
Cheapest paid tier	$20/mo for 50,000	$15/mo for 10,000	$19.95/mo for 50,000
Effective cost at 10k/mo	$20	$15	$19.95
Effective cost at 50k/mo	$20	~$25-50 (tiered)	$19.95
API DX	Cleanest (single POST endpoint)	Clean	Heavy SDK, more boilerplate
Deliverability rep	Strong but newer (founded 2023)	Best-in-class transactional	Mixed — bigger volume = more shared-IP risk
Domain verification	Required for prod sends; ~10 min	Required; ~10-15 min	Required; harder UX
Free-tier sender	onboarding@resend.dev	None — must verify your domain even on dev	None — must verify your domain
Webhook for delivery events	Yes	Yes	Yes (legacy event format)
Suppression management	Built in	Best UI, manual + auto handling	Built in, more enterprise-shaped

Resend — best DX, OK at scale

Founded 2023 by the team behind React Email. The API is the cleanest of the three:

const r = await fetch('https://api.resend.com/emails', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${RESEND_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    from: 'Sentry Forge <onboarding@resend.dev>',
    to: customerEmail,
    subject: 'Your case is open',
    text: emailBody,
  }),
});

One POST. JSON in, JSON out. No SDK required. Rate limits are generous; deliverability is solid. The 3,000-email free tier is the most useful of the three for early-stage indie products — most webhooks send fewer than 3k emails a month for the first 6 months.

Use it when: you're under 50k emails/month, you want clean DX, you're shipping a webhook today and the free-tier sender domain (onboarding@resend.dev) is acceptable until you verify your custom domain in 10 minutes.

Avoid it when: you're a regulated industry (healthcare, finance) where Postmark's longer track record matters, or you need 100k+/month and Postmark's higher tiers fit better.

Postmark — best deliverability, premium pricing

Around since 2010. Built specifically for transactional email (not marketing). Best deliverability rep in the industry, especially for emails that absolutely must hit the inbox (account verification, password reset, payment receipts).

const r = await fetch('https://api.postmarkapp.com/email', {
  method: 'POST',
  headers: {
    'X-Postmark-Server-Token': POSTMARK_TOKEN,
    'Accept': 'application/json',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    From: 'noreply@yourdomain.com',
    To: customerEmail,
    Subject: 'Your case is open',
    TextBody: emailBody,
    MessageStream: 'outbound',
  }),
});

Note the camelCase field names (From, To) and the MessageStream requirement. Slight friction vs Resend's lowercase JSON.

Pricing is tiered, so it gets expensive faster than Resend or SendGrid past 10k/mo. At 50k/mo, expect $25-50/mo depending on tier breakpoints.

Use it when: deliverability matters more than cost (financial services, healthcare, legal). When customer's payment receipt MUST hit the primary inbox, not Promotions. When you have budget and want fewest deliverability surprises.

Avoid it when: you're cost-sensitive at scale and your emails are routine notifications (welcome, ordered, shipped) where Resend or SendGrid deliver fine.

SendGrid — most established, biggest at scale

Owned by Twilio since 2019. Built for both marketing and transactional. Largest of the three in customer count.

const r = await fetch('https://api.sendgrid.com/v3/mail/send', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${SENDGRID_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    personalizations: [{ to: [{ email: customerEmail }] }],
    from: { email: 'noreply@yourdomain.com', name: 'Sentry Forge' },
    subject: 'Your case is open',
    content: [{ type: 'text/plain', value: emailBody }],
  }),
});

Note the heavy nested structure — personalizations, from as object, content as array. More boilerplate than Resend or Postmark. The SDK is the standard way to use SendGrid; raw fetch is verbose.

Pricing is the most aggressive at scale — $19.95/mo gets you 50k emails. Above 100k you can negotiate down toward $0.0001-0.0002/email territory.

Use it when: you're sending 100k+/mo and Postmark's tiered pricing breaks the bank. When you need both transactional and marketing in one provider.

Avoid it when: you want clean DX, you're under 10k/mo, or you've heard the deliverability horror stories on shared IPs and don't want to gamble.

The gotchas

Gotcha 1 — domain verification

All three require you to verify your sending domain (DKIM + SPF records on your DNS) before they'll deliver to most providers. Resend gives you 3,000 emails on its free onboarding@resend.dev domain so you can ship a working webhook before doing the verification. Postmark and SendGrid require domain setup before any production sends.

If you don't verify your domain, expect Gmail to mark every email as spam, and Outlook to reject them at the SMTP level. The free tier of any provider that uses a shared sender domain (Resend's onboarding@) is fine for your founder inbox, but customers will see "via resend.dev" in the from address — looks suspicious.

Gotcha 2 — bounce / complaint handling

If a customer's email bounces (mailbox full, address invalid, reputation block), all three providers automatically suppress future sends to that address. They don't tell you about it unless you check the dashboard or wire up the delivery-event webhook.

Wire up the delivery-event webhook for at least bounces and spam complaints. Otherwise you'll spend hours debugging "why didn't the customer get their email" only to discover the address bounced 3 weeks ago.

Gotcha 3 — rate limits on free tiers

Stripe webhooks fire as fast as 6 events per checkout. If your handler dispatches an email per event (don't, see multi-event handling post), you can hit per-second rate limits on free tiers during a checkout burst. Provider responses degrade silently — some emails dispatched, some dropped.

Filter to a single event type (checkout.session.completed) BEFORE you call the email API. The other 5 events shouldn't trigger emails.

The decision tree

1. Sending under 3,000 emails/month → Resend (free, clean API, ship today)
2. Sending 3k-50k/month and cost is the priority → Resend (still cheapest)
3. Sending 50k+/month or you're regulated/financial-services → Postmark (deliverability premium)
4. Sending 100k+/month and have an existing relationship with Twilio → SendGrid
5. Sending 1M+/month → hire someone or use AWS SES with deliverability ops

For most indie-hacker products at the time of webhook setup, the answer is Resend.

Related

• Why your Stripe webhook returns 400 in production
• Why Stripe fires 6+ events per checkout — filter before emailing
• Webhook idempotency for handling duplicates
• Cost calculator — compare your monthly spend across providers
• Webhook uptime monitoring — $29/mo