Resend vs SendGrid vs Postmark 2026

TL;DR

Resend for new projects — developer DX is best, React Email integration is native, generous free tier. Postmark for transactional email when deliverability is non-negotiable — they've maintained industry-leading inbox placement rates for 15 years. SendGrid for high-volume (1M+ sends) where cost matters and you're okay with a more complex API. In 2026, Resend has largely won the developer mindshare but Postmark's reputation still matters for apps where "password reset went to spam" is catastrophic.

Key Takeaways

Resend: $0 free (3K/month), best DX, React Email native, $20/month (50K sends)
Postmark: $15/month (10K sends), #1 deliverability, best for transactional-only use cases
SendGrid: $20/month (100K sends), most features, complex API, used by large enterprises
Deliverability: Postmark > Resend ≈ SendGrid for inbox placement rates
React Email: all three support HTML/text, but Resend's SDK has first-class React Email integration
Volume pricing: SendGrid cheapest at >100K sends/month; Resend most expensive

Resend: Developer-First Email

Best for: indie developers, SaaS builders, anyone using React for email templates

// npm install resend
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

// Send a plain HTML email:
const { data, error } = await resend.emails.send({
  from: 'Acme <noreply@acme.com>',
  to: ['user@example.com'],
  subject: 'Welcome to Acme!',
  html: '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
  text: 'Welcome! Thanks for signing up.',  // Plain text fallback
});

React Email Integration (Killer Feature)

// npm install @react-email/components react react-dom
// emails/welcome.tsx:
import {
  Html,
  Head,
  Preview,
  Body,
  Container,
  Heading,
  Text,
  Button,
  Hr,
} from '@react-email/components';

interface WelcomeEmailProps {
  userName: string;
  loginUrl: string;
}

export function WelcomeEmail({ userName, loginUrl }: WelcomeEmailProps) {
  return (
    <Html>
      <Head />
      <Preview>Welcome to our platform, {userName}!</Preview>
      <Body style={{ fontFamily: 'Arial, sans-serif', backgroundColor: '#f4f4f4' }}>
        <Container style={{ maxWidth: '600px', margin: '0 auto', padding: '20px' }}>
          <Heading>Welcome, {userName}! 👋</Heading>
          <Text>Thanks for signing up. Here's how to get started:</Text>
          <Button
            href={loginUrl}
            style={{
              backgroundColor: '#000',
              color: '#fff',
              padding: '12px 24px',
              borderRadius: '4px',
              textDecoration: 'none',
            }}
          >
            Get Started →
          </Button>
          <Hr />
          <Text style={{ color: '#666', fontSize: '12px' }}>
            You received this because you signed up at acme.com.
          </Text>
        </Container>
      </Body>
    </Html>
  );
}

// Send React Email with Resend:
import { render } from '@react-email/render';
import { WelcomeEmail } from '@/emails/welcome';

const emailHtml = render(WelcomeEmail({ userName: 'Alice', loginUrl: 'https://acme.com/login' }));

await resend.emails.send({
  from: 'Acme <noreply@acme.com>',
  to: [user.email],
  subject: 'Welcome to Acme!',
  html: emailHtml,
});

// Resend batch sending:
const { data } = await resend.batch.send([
  {
    from: 'noreply@acme.com',
    to: 'user1@example.com',
    subject: 'Your weekly report',
    html: render(WeeklyReport({ user: user1 })),
  },
  {
    from: 'noreply@acme.com',
    to: 'user2@example.com',
    subject: 'Your weekly report',
    html: render(WeeklyReport({ user: user2 })),
  },
]);

Resend Pricing

Free:          3,000 emails/month, 1 domain
Pro ($20/month): 50,000 emails/month, unlimited domains
Scale ($90/month): 300,000 emails/month

Beyond plan limits (Pro overage):
  $1.50/1,000 emails = $0.0015/email

vs Postmark:   $0.001/email
vs SendGrid:   $0.0008/email at 100K

Postmark: Deliverability Champion

Best for: password resets, payment receipts, security alerts — any email that MUST reach the inbox

// npm install postmark
import * as postmark from 'postmark';

const client = new postmark.ServerClient(process.env.POSTMARK_API_TOKEN!);

// Send transactional email:
const response = await client.sendEmail({
  From: 'noreply@acme.com',
  To: 'user@example.com',
  Subject: 'Reset your password',
  HtmlBody: '<h1>Reset Your Password</h1><p>Click <a href="{{url}}">here</a>.</p>',
  TextBody: 'Reset your password: {{url}}',
  ReplyTo: 'support@acme.com',
  MessageStream: 'outbound',  // Or a named stream (e.g., 'password-resets')
});

console.log('Message ID:', response.MessageID);

// Postmark with templates (stored in dashboard):
await client.sendEmailWithTemplate({
  From: 'noreply@acme.com',
  To: user.email,
  TemplateAlias: 'welcome',  // Template created in Postmark dashboard
  TemplateModel: {
    product_name: 'Acme',
    name: user.name,
    action_url: `https://acme.com/verify?token=${token}`,
    support_email: 'support@acme.com',
  },
});

Message Streams

Postmark's key architectural feature — separate streams for transactional vs broadcast:

// Separate streams prevent marketing blocks from affecting transactional delivery:

// Transactional stream (highest priority, no unsubscribe required):
await client.sendEmail({
  From: 'noreply@acme.com',
  To: user.email,
  Subject: 'Payment receipt',
  HtmlBody: receiptHtml,
  MessageStream: 'outbound',  // Default transactional stream
});

// Broadcast stream (requires unsubscribe link):
await client.sendEmail({
  From: 'newsletter@acme.com',
  To: user.email,
  Subject: 'Monthly newsletter',
  HtmlBody: newsletterHtml,
  MessageStream: 'newsletters',  // Separate broadcast stream
});

Postmark Pricing

No free plan (100 test emails/month for devs)
$15/month:   10,000 emails
$45/month:   100,000 emails
$225/month:  1,000,000 emails

Per email at scale:
  100K:  $0.00045/email
  1M:    $0.000225/email

SendGrid: High-Volume Enterprise

Best for: 500K+ emails/month, marketing + transactional combined, existing SendGrid infrastructure

// npm install @sendgrid/mail
import sgMail from '@sendgrid/mail';

sgMail.setApiKey(process.env.SENDGRID_API_KEY!);

// Send email:
await sgMail.send({
  to: 'user@example.com',
  from: 'noreply@acme.com',
  subject: 'Welcome!',
  html: '<h1>Welcome!</h1>',
  text: 'Welcome!',
});

// Dynamic templates (HTML + substitutions):
await sgMail.send({
  to: user.email,
  from: 'noreply@acme.com',
  templateId: 'd-abc123',  // Template ID from SendGrid
  dynamicTemplateData: {
    first_name: user.firstName,
    reset_url: resetUrl,
  },
});

// SendGrid Inbound Parse (receive emails via webhook):
// When a user replies to your email, SendGrid POSTs to your webhook:
export async function POST(request: Request) {
  const formData = await request.formData();
  const from = formData.get('from') as string;
  const subject = formData.get('subject') as string;
  const text = formData.get('text') as string;

  // Handle reply email
  await processReply({ from, subject, text });
  return new Response('OK');
}

SendGrid Pricing

Free: 100 emails/day forever
Essentials ($20/month): 100K emails/month
Pro ($90/month): 1M emails/month
Premier: Custom

Per email at scale:
  100K:  $0.0002/email
  1M:    $0.00009/email

SendGrid is ~4x cheaper than Resend at 100K emails.
But has more moving parts (suppression groups, event webhooks, template engine).

Side-by-Side Comparison

	Resend	Postmark	SendGrid
Free tier	3K/month	100/month	100/day
Deliverability	Good	Best	Good
DX (API quality)	Best	Good	Complex
React Email native	✅	Partial	❌
Templates in dashboard	Basic	✅	✅
Marketing email	❌	Broadcasts	✅
Inbound email	❌	✅	✅
Webhooks	✅	✅	✅
100K/month cost	~$90	~$45	~$20
Rate limit default	2 req/s	None	None

Recommendation

New SaaS (small to medium scale):
  → Use Resend
  → React Email templates, minimal config
  → Upgrade path exists (Scale plan for growth)

Established app where inbox placement is critical:
  → Use Postmark for transactional
  → Add SendGrid if you need marketing email
  → Message Streams = clean separation

High-volume or existing SendGrid users:
  → Stick with SendGrid
  → Cost savings significant at >500K emails/month
  → Complex API but worth it at scale

Deliverability Deep Dive

Most developers don't think about deliverability until a password reset lands in a user's spam folder and that user never completes signup. By that point, your sender reputation may already be compromised — and rebuilding it takes weeks. Understanding the deliverability landscape before you ship is worth the thirty minutes it takes.

Postmark's entire business model is built around deliverability. They maintain dedicated IP pools exclusively for transactional email — they refuse to send marketing email from those same IPs. This is a meaningful distinction. When a bulk sender blasts a promotional campaign and recipients mark it as spam, that negative signal hits the sending IP's reputation. Postmark prevents that contamination by design. Their transactional IPs have never been used for marketing, so inbox providers like Gmail and Outlook have years of clean history to evaluate.

Resend uses shared infrastructure on the free tier, meaning your emails go out alongside other senders on the same IP pool. This is fine for development and low-volume production use, but shared IP reputation means you're partially dependent on your neighbors' behavior. Resend's paid plans offer dedicated IPs, which removes that dependency and lets you build your own sending reputation. For most SaaS apps in the early growth phase, the shared infrastructure is entirely adequate — the problems show up at scale or in high-stakes scenarios.

SendGrid starts all new accounts on shared IPs. If you want dedicated IPs (recommended for volume over 100K/month), you need to warm them gradually — starting at a few hundred emails per day and increasing over 4-6 weeks. Skipping the warmup process means inbox providers treat your dedicated IP as an unknown sender and apply stricter filtering. SendGrid's documentation covers IP warming schedules in detail, but it's a commitment that many teams underestimate.

Understanding SPF, DKIM, and DMARC is worthwhile regardless of which service you use. SPF (Sender Policy Framework) is a DNS record that authorizes specific servers to send email on your domain's behalf — it tells receiving mail servers "only these IP ranges are allowed to send from acme.com." DKIM (DomainKeys Identified Mail) adds a cryptographic signature to every outgoing email, allowing receivers to verify that the message wasn't tampered with in transit. DMARC (Domain-based Message Authentication, Reporting, and Conformance) ties SPF and DKIM together and tells receiving servers what to do when a message fails authentication — reject it, quarantine it (spam folder), or let it through while sending you a report.

All three services walk you through setting up these DNS records during onboarding. The setup takes about fifteen minutes and makes a measurable difference in inbox placement. Don't skip it.

For measuring your actual inbox placement before you launch, tools like Mail-Tester.com and GlockApps let you send a test email and receive a score showing where it lands across major providers. GlockApps is more thorough — it tests across Gmail, Outlook, Yahoo, and Apple Mail and gives you a breakdown by inbox vs. spam vs. missing. Postmark publishes their own inbox placement metrics and has historically reported 99%+ placement rates for transactional email. Resend and SendGrid do not publish comparable benchmarks, so third-party testing tools are your best option for verifying your own setup.

Template and Design Workflow

How you build and maintain email templates matters more than it seems — email templates tend to accumulate technical debt quickly, especially when the "template" is a string of hand-rolled HTML buried in an API route. Each of the three services takes a different approach to this problem.

SendGrid has the most feature-complete built-in template system. The dashboard includes a drag-and-drop "Design" editor and a raw "Code" editor, and you can switch between them for any template. The Design editor makes it accessible to non-developers — a marketer can adjust layout, copy, and branding without touching code. The trade-off is complexity: SendGrid templates use their own expression language for dynamic content ({{first_name}}), and the template IDs you reference in your API calls are managed through the dashboard, which adds a deployment consideration when you're promoting changes through environments.

Postmark uses Handlebars syntax for templates. Their dashboard has a preview feature where you can supply test model data and see how a template renders, but there's no visual editor — you write HTML with {{variable}} placeholders and preview the result. This is a more developer-friendly workflow than SendGrid's drag-and-drop if you're comfortable writing email HTML, but it requires knowledge of how email HTML differs from web HTML (inline styles, table-based layouts, limited CSS support).

Resend's answer to templates is React Email, and it's genuinely the best developer experience in this category if your team already works in React. You write your email as a standard React component using primitives from the @react-email/components package — things like <Button>, <Container>, <Text>, and <Hr> that abstract away email-specific HTML quirks. You preview it in the browser with hot reloading using npx react-email dev. When it's time to send, you render the component to an HTML string and pass it to the Resend API. The whole workflow — edit, preview in browser, test send — takes seconds rather than minutes. The only requirement is a build step, which means React Email doesn't fit well in non-React codebases.

Cross-client rendering is a persistent pain point for all three. Gmail, Outlook, and Apple Mail each have their own quirks in how they render HTML email. Outlook still uses Word's HTML renderer on Windows, which means CSS Grid and Flexbox don't work. Gmail clips emails over ~102KB. Apple Mail renders beautifully but Apple Mail on iOS behaves differently from macOS. React Email's components are built with these constraints in mind — the <Button> component renders as a table cell with an anchor tag, not a standard <button>, because that's what survives across clients. Raw HTML templates require testing with Litmus or Email on Acid to catch rendering issues before they reach users.

For teams without React in their stack, the choice between SendGrid's dashboard templates and Postmark's Handlebars templates comes down to whether non-developers need to edit email copy. If yes, SendGrid's visual editor is worth the added complexity. If your engineering team owns all email templates, Postmark's approach is cleaner.

Real Scenarios: Which to Pick

General advice is useful, but specific scenarios help clarify the decision. Here are five situations developers commonly face:

SaaS launch with under 1,000 users. Resend wins here without much competition. The free tier covers 3,000 emails per month, which is more than enough. React Email templates mean your welcome email, password reset, and payment receipt are all React components that live in your codebase alongside your other components. There's no dashboard to learn, no template ID to manage, and the API integration is a few lines. You're not paying anything, and the path to scaling (upgrading to the Pro plan) is a single click.

E-commerce order confirmations at 100,000 emails per month. At this volume, cost becomes a real factor. Resend's Scale plan at $90/month sends 300K emails, but if you're only at 100K, you're paying $90 versus SendGrid Essentials at $20/month for the same volume. That's a $70/month difference — $840 per year — for functionally equivalent email delivery for a straightforward transactional use case. If you're already on SendGrid or comfortable with the setup complexity, staying there or moving to it is the economically rational choice.

B2B SaaS where a missed password reset costs a sales deal. This is Postmark's home turf. In B2B, your users are often on corporate email systems with aggressive spam filtering. A missed auth email can mean a prospect never logs into your trial, and you never know why they churned. Postmark's reputation with corporate email systems — built over 15 years of handling nothing but transactional email — makes the $45/month for 100K emails worthwhile. The message streams architecture also makes it easy to audit exactly what was sent to any given address and when.

Next.js App Router startup already using Resend. Don't switch. React Email integrates with Resend better than with any other provider — the resend.emails.send() method accepts a React component directly in recent SDK versions, so you can skip the manual render() call. If your team knows React and you're not hitting deliverability or cost issues, the switching cost buys you nothing.

Large enterprise with both marketing and transactional email needs. SendGrid's feature set is built for this. Marketing automation workflows, A/B testing for subject lines, suppression group management, engagement scoring — none of the other two come close. The API complexity that makes SendGrid annoying for a simple transactional use case is precisely the flexibility that makes it powerful when you're running coordinated campaigns alongside transactional sends.

Monitoring and Analytics

Knowing that an email was sent is not the same as knowing it was delivered, opened, and acted on. Each service provides different tools for understanding what happens after the API call returns.

Resend provides the basics: open tracking, click tracking, and delivery webhooks. You can receive webhook events when an email is delivered, bounced, marked as spam, or opened. The dashboard shows aggregate send volume and event counts, but it's not built for deep investigation. If you need to debug why a specific user didn't receive their welcome email, you'll find the delivery logs in the Resend dashboard, but the experience is more "can I confirm it was sent" than "here's exactly what happened."

Postmark is where delivery logs shine. Every message has a detailed activity entry showing the SMTP conversation, delivery status, bounce type (if applicable), spam complaint (if applicable), and timestamps. The default retention is 45 days on lower plans and 365 days on higher plans. When a customer says "I never got my invoice," you can pull up that exact email in the Postmark activity feed within seconds. For debugging deliverability issues — figuring out whether a bounce was a hard bounce (invalid address) or a soft bounce (full mailbox), or understanding why a specific ISP is rejecting your emails — Postmark's logs are the most immediately useful tool across the three services.

SendGrid has the most comprehensive analytics offering. Beyond basic delivery and open tracking, you get A/B testing for subject lines and content, engagement recency scoring (segmenting your list by how recently subscribers engaged), geographic delivery data broken down by country and ISP, and spam complaint rates by domain. For teams running sophisticated email programs, this depth of analytics feeds into deliverability optimization — you can identify that a specific domain is bouncing at a higher rate, or that a segment of users hasn't opened an email in 90 days, and act on that data. For most developer-focused transactional use cases, this level of detail is more than you need, but at enterprise scale it becomes genuinely valuable.

Compare all email APIs at APIScout.

Compare Resend and SendGrid on APIScout.

The API Integration Checklist (Free PDF)