Resend vs Loops vs Plunk APIs 2026

The developer email API market finally has real competition in 2026. Resend established the modern developer-first pattern — clean REST API, React Email templates, 3,000 emails/month free. Loops responded to product teams who need more than transactional sends, with behavior-triggered campaigns and audience segmentation built for SaaS onboarding. Plunk offers an open-source path with self-hosting as a genuine option.

Choosing wrong means either paying for marketing features you'll never use, or migrating away when you need them. Here's what actually matters.

The Three Platforms

Resend

Resend launched in 2023 and quickly became the default choice for developers building transactional email. The core insight: developers should build email templates with the same tools they use for UI — React components.

The integration is simple to the point of elegance. Install resend, create an API key, write a React Email component, and send it:

import { Resend } from 'resend';

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

const { data, error } = await resend.emails.send({
  from: 'noreply@yourapp.com',
  to: 'user@example.com',
  subject: 'Welcome to YourApp',
  react: WelcomeEmail({ name: 'Alice', confirmUrl: '...' }),
});

That's the entire integration for transactional email. No template IDs, no external template editors, no JSON payload construction. Your email is a React component that lives in your repo.

Resend's free tier includes 3,000 emails/month and 100 emails/day. Paid plans start at $20/month for 50,000 emails/month.

Resend is pure transactional. There is no campaign builder, no broadcast emails, no audience management. If you need to send a newsletter or an onboarding drip sequence, you need another tool or you build it yourself with Resend's API.

Loops

Loops is what happens when product teams get frustrated wiring together Resend + a separate marketing tool. It's a full SaaS email platform: transactional sends, onboarding sequences, broadcast campaigns, and audience segmentation — all in one product.

The architecture is event-driven. You identify users, send events, and Loops triggers emails based on user actions. Think:

• User signs up → trigger signup event → Loops sends welcome email, waits 3 days, sends onboarding tip, waits 7 days, sends upgrade nudge
• User upgrades to paid → trigger upgrade event → Loops cancels the upgrade nudge, starts the paid welcome sequence

This is what Intercom charges $400+/month for at scale. Loops starts at $49/month.

Transactional email is now free on Loops (announced Q4 2025) — you only pay for the marketing features and audience size. Free tier: 1,000 subscribers, 4,000 monthly sends.

Plunk

Plunk is the open-source option. The GitHub repo is public, the code is MIT-licensed, and you can self-host the entire platform on your own infrastructure. For teams with privacy requirements or who want to avoid per-email costs entirely, self-hosting is a real path.

The cloud offering runs on AWS SES under the hood, which gives Plunk competitive deliverability without building their own sending infrastructure. Pricing is aggressive: $0.001 per email after the free tier, which is 5-10x cheaper than equivalent SendGrid or Mailchimp volume tiers.

Plunk handles transactional emails, campaigns, and automations. The feature set is narrower than Loops — the workflow builder is simpler, the segmentation less granular — but it covers the full email lifecycle.

The honest limitation: Plunk is newer and the polish shows. The React Email integration is not as seamless as Resend, and the documentation has gaps. But for budget-conscious teams or those who want to own their infrastructure, it's a serious option.

Feature Comparison

Feature	Resend	Loops	Plunk
Transactional email	Yes (native)	Yes (free since Q4 2025)	Yes
Marketing campaigns	No	Yes	Yes
Onboarding sequences	No (build it yourself)	Yes (visual builder)	Yes (limited)
React Email support	First-class	Limited	No
Free tier	3K emails/mo	1K subscribers, 4K sends	100 contacts
Paid starting price	$20/month	$49/month	$9/month
Open source	No	No	Yes (MIT)
Self-hosting	No	No	Yes
API quality	Excellent	Good	Good
SDK languages	JS, Python, Ruby, Go, PHP	JS, Python	JS
Deliverability	High (custom infra)	High (Postmark backend)	High (AWS SES)

Pricing Deep Dive

Resend Pricing

Resend bills by email volume:

• Free: 3,000 emails/month, 100/day, 1 domain
• Pro ($20/month): 50,000 emails/month
• Scale ($90/month): 200,000 emails/month
• Enterprise: custom

The predictability is excellent for transactional workloads. If you send 10,000 emails/month, you're on the $20 plan. Simple.

Loops Pricing

Loops bills by subscriber count with unlimited sends:

• Free: 1,000 subscribers
• Starter ($49/month): up to 2,500 subscribers
• Growth ($99/month): up to 10,000 subscribers
• Scale ($199/month): up to 50,000 subscribers

Unlimited transactional emails are included on all plans. If you have 5,000 users but send 500,000 transactional emails/month, you still pay the $99 Growth price — not per-email.

This pricing model is dramatically cheaper than per-volume pricing at scale for transactional workloads. A startup with 8,000 users sending order confirmations and password resets pays $99/month on Loops vs. ~$90/month just for volume on Resend (Scale plan) — and also gets the full marketing platform.

Plunk Pricing

Plunk uses a simple model:

• Free: 100 contacts
• Starter ($9/month): 1,000 contacts
• Growth ($29/month): 10,000 contacts
• Business ($79/month): 50,000 contacts
• Self-hosted: free (infrastructure costs only)

At 10,000 contacts, Plunk ($29/month) is dramatically cheaper than Loops ($99/month) and offers comparable features if you don't need Loops' visual workflow sophistication.

Code Examples in Next.js

Resend in Next.js App Router

// app/api/send-welcome/route.ts
import { Resend } from 'resend';
import { WelcomeEmail } from '@/emails/WelcomeEmail';

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

export async function POST(request: Request) {
  const { email, name } = await request.json();

  const { data, error } = await resend.emails.send({
    from: 'welcome@yourapp.com',
    to: email,
    subject: `Welcome to YourApp, ${name}!`,
    react: WelcomeEmail({ name }),
  });

  if (error) {
    return Response.json({ error: error.message }, { status: 500 });
  }

  return Response.json({ messageId: data?.id });
}

// emails/WelcomeEmail.tsx
import { Html, Button, Text, Section } from '@react-email/components';

export function WelcomeEmail({ name }: { name: string }) {
  return (
    <Html>
      <Section>
        <Text>Hi {name}, welcome to YourApp!</Text>
        <Button href="https://yourapp.com/dashboard">
          Get started
        </Button>
      </Section>
    </Html>
  );
}

Loops in Next.js

// app/api/user-signup/route.ts
// Loops: identify the user and send an event, let Loops handle the emails
import { LoopsClient } from 'loops';

const loops = new LoopsClient(process.env.LOOPS_API_KEY!);

export async function POST(request: Request) {
  const { email, name, plan } = await request.json();

  // Create/update the contact in Loops
  await loops.createContact(email, {
    firstName: name,
    plan: plan,
    source: 'signup',
  });

  // Send a signup event — Loops triggers the right email sequence
  await loops.sendEvent({
    email,
    eventName: 'signup',
    eventProperties: { plan },
  });

  return Response.json({ success: true });
}

The Loops pattern is different from Resend's. You don't send emails from your API — you send events, and Loops' automation engine decides which emails to send, when, and in what sequence. This keeps your application code clean and puts the email logic in Loops' visual builder.

Plunk in Next.js

// app/api/send-welcome/route.ts
import Plunk from '@plunk/node';

const plunk = new Plunk(process.env.PLUNK_SECRET_KEY!);

export async function POST(request: Request) {
  const { email, name } = await request.json();

  // Track the event — triggers any matching automations
  await plunk.events.track({
    event: 'signup',
    email,
    data: { name },
  });

  // Or send a transactional email directly
  const result = await plunk.emails.send({
    to: email,
    subject: `Welcome, ${name}!`,
    body: `<p>Hi ${name}, thanks for signing up!</p>`,
  });

  return Response.json({ success: result.success });
}

Plunk supports both direct sends and event-based automation, similar to Loops but with a simpler API.

React Email Integration

The way each platform handles email templates is a significant DX differentiator, especially for teams already working in Next.js and React.

Resend + React Email

React Email is an open-source component library for building email templates with React. Resend and React Email are developed in close collaboration — Resend was essentially the first platform to make React Email first-class, and the two projects are maintained by overlapping teams.

The workflow feels natural for React developers. You create email components like UI components:

// emails/components/Button.tsx
import { Button as EmailButton } from '@react-email/components';

export function Button({ href, children }: { href: string; children: React.ReactNode }) {
  return (
    <EmailButton
      href={href}
      style={{
        background: '#6366f1',
        color: 'white',
        borderRadius: '6px',
        padding: '12px 24px',
        fontWeight: '600',
      }}
    >
      {children}
    </EmailButton>
  );
}

You preview them in a browser with hot reload (npx react-email dev), test across email clients, and send them from your API with full TypeScript type checking. Props flow from your server-side data into the template the same way they would in a React component.

The testing workflow is particularly strong: react-email ships a dev server that renders your templates locally with live preview across simulated email clients. You catch Outlook rendering bugs before they reach users.

Loops

Loops supports React Email to a degree — you can send transactional emails with HTML content — but the deep integration is with their visual editor, not React components. The email templates for your onboarding sequences and campaigns are built in Loops' drag-and-drop interface.

This is actually appropriate for Loops' use case. Marketing and onboarding email sequences are typically managed by product managers or marketers, not developers. The visual editor means less developer involvement in iteration cycles. When a PM wants to change the copy in the day-3 onboarding email, they do it in Loops without opening a code editor.

For transactional emails triggered from your application code, Loops accepts HTML in the API call. React Email renders to HTML, so you can use it:

import { render } from '@react-email/render';
import { ReceiptEmail } from '@/emails/ReceiptEmail';

const html = await render(ReceiptEmail({ orderTotal: 49.99, items: [...] }));

await loops.sendTransactionalEmail({
  transactionalId: 'order_receipt',
  to: email,
  dataVariables: { html }, // Pass pre-rendered HTML
});

This works but is more circuitous than Resend's native React Email integration.

Plunk

Plunk accepts HTML in all API calls. There's no native React Email integration — you render to HTML yourself and pass it. The same approach as Loops for transactional emails applies.

For teams committed to React Email, this is workable but adds a rendering step. For teams comfortable with MJML, Handlebars templates, or plain HTML, Plunk's HTML-first approach is perfectly fine.

Webhook and Event Handling

Resend Webhooks

Resend emits webhook events for email lifecycle: email.sent, email.delivered, email.bounced, email.complained, email.clicked, email.opened. You configure a webhook endpoint in the Resend dashboard, and Resend POSTs events to it with HMAC signatures for verification.

// app/api/resend-webhook/route.ts
import { Webhook } from 'svix';

const webhookSecret = process.env.RESEND_WEBHOOK_SECRET!;

export async function POST(request: Request) {
  const payload = await request.text();
  const headers = Object.fromEntries(request.headers);

  const wh = new Webhook(webhookSecret);
  const event = wh.verify(payload, headers) as ResendWebhookEvent;

  if (event.type === 'email.bounced') {
    await markEmailAsUndeliverable(event.data.to);
  }

  return Response.json({ received: true });
}

This is the standard webhook pattern and works well. Resend uses the Svix webhook infrastructure, which is battle-tested.

Loops Webhooks

Loops emits events for both email lifecycle and user events. You can trigger webhook callbacks when users enter or exit sequences, when they open or click emails, or when custom events are fired. The Loops dashboard provides a visual webhook configuration interface.

For SaaS applications, this is particularly useful: when a user completes your onboarding sequence (exits the onboarding automation), you can webhook into your application to mark them as "onboarded" in your database.

Plunk Webhooks

Plunk supports webhooks for email events and contact events. The implementation is simpler than Resend's — no Svix, just HMAC verification of the raw payload. For teams who need webhook reliability at high volume, Resend's Svix-backed infrastructure has more enterprise precedent.

Deliverability

All three platforms take deliverability seriously, but via different backends:

Resend built their own sending infrastructure with dedicated IPs and a focus on developer education around SPF, DKIM, and DMARC. Their deliverability rates are competitive with SendGrid and Postmark.

Loops uses Postmark as its sending backbone, which has historically top-tier deliverability scores. You inherit Postmark's infrastructure quality.

Plunk routes through AWS SES, which has good baseline deliverability when properly configured. The tradeoff is that SES requires more careful warm-up and reputation management compared to managed platforms.

Email Authentication: SPF, DKIM, and DMARC

All three platforms require you to set up DNS records to authenticate your sending domain. Skipping this step is the single biggest cause of email landing in spam. Here's what each platform requires and how the setup differs.

Setting Up Resend Domain Authentication

Resend's domain verification flow is one of the smoothest in the industry. After adding your domain in the Resend dashboard, you get a set of DNS records to add:

• SPF TXT record (or include in existing SPF): v=spf1 include:amazonses.com ~all
• DKIM CNAME records: three CNAME records pointing to Resend's signing infrastructure
• DMARC TXT record: Resend provides a recommended value based on your desired policy

Resend validates your DNS records automatically and notifies you when the domain is verified. The entire process takes about 10 minutes of wall-clock time (most of it waiting for DNS propagation).

Resend also shows you a domain reputation score in the dashboard, and provides guidance on warming up new sending domains to avoid triggering spam filters. For first-time email API users, this guidance is genuinely valuable.

Loops Domain Authentication

Loops uses Postmark's sending infrastructure, which means you're authenticating your domain against Postmark's SPF and DKIM signing records. The process is similar: add DNS records, wait for propagation, and Loops verifies.

One nuance: if you're already sending transactional emails via another service on the same domain, you may need to update an existing SPF record rather than add a new one. Multiple v=spf1 records cause SPF to fail. Loops' documentation covers this scenario.

Loops provides a deliverability testing tool in the dashboard that lets you send test emails and see how they score across major spam filters. This is particularly useful for new campaigns before you send to your full audience.

Plunk Domain Authentication

Plunk's domain authentication goes through AWS SES, and the setup requires more manual steps than Resend or Loops. You add SES-specific CNAME records for DKIM signing and update your SPF record. If you're self-hosting, you have full control over SES configuration and can set up custom MAIL FROM domains for improved deliverability.

The self-host path gives you access to SES dedicated IPs if you need them — useful for high-volume senders who want to isolate their reputation from shared IP pools. At $0.001 per email on Plunk, even with a dedicated IP allocation from SES, you're paying dramatically less than managed alternatives.

Migration Considerations

Switching email providers is never trivial, but some paths are easier than others.

Migrating from SendGrid or Mailgun to Resend

The migration is primarily a code change — swap the SDK, update environment variables, and re-verify your domain with Resend. If you've built email templates in SendGrid's template editor or Mailgun's template system, you'll need to rebuild them as React Email components or plain HTML.

For teams already using Handlebars templates, Resend accepts raw HTML so the template migration is just a format conversion. For teams taking the opportunity to upgrade to React Email components, the migration is more work but the result is a dramatically better template development experience.

Migrating from Resend to Loops

The most common migration story in 2026: start with Resend for pure transactional sends, then need onboarding sequences and campaign capabilities. The migration involves:

1. Keep Resend for critical transactional emails if you're on a volume plan that's cheaper than Loops per-email
2. Add Loops for event-based sequences and campaigns
3. Over time, migrate transactional emails to Loops' free transactional tier to consolidate

Or go all-in on Loops: since transactional is now free, there's no per-email cost argument for keeping Resend unless you're at very high transactional volume (above 2,500 subscribers where Loops' pricing tiers apply).

Data Portability

All three platforms let you export your contact lists and email logs. Resend exports event logs (sent, delivered, bounced). Loops exports contacts and their properties. Plunk exports contacts and event history.

None of them give you the complete raw email delivery data that you'd have if you ran your own Postfix/SES setup — some analytics are platform-specific. Plan for this when evaluating which platform owns your email relationship data.

Which Should You Choose?

Choose Resend if your use case is 100% transactional — password resets, receipts, notifications. You want to build beautiful emails with React components, you're a developer-first team, and you have no plans to build marketing campaigns. The API is the best in class and the React Email integration is unmatched.

Choose Loops if you're a SaaS team that needs both transactional and product marketing emails. The event-driven model scales with your product: start with signup/onboarding sequences, add broadcast emails, A/B test subject lines — all without migrating to a different platform. The $49 starting price is fair for the full feature set.

Choose Plunk if you want the lowest cost at scale, need open-source licensing for compliance or philosophy reasons, or want the option to self-host. You'll trade some polish and advanced workflow features for a dramatically lower bill.

The most common mistake teams make: starting with Resend because it's the simplest, then hitting a wall when they need onboarding sequences and realizing they need to either build a drip system themselves or migrate to Loops. If you know you'll need marketing automation within 6 months, start with Loops.

---

See also: Best Email APIs for Developers 2026, How to Send Transactional Emails with Resend, Building a SaaS Backend with Auth, Stripe, PostHog, and Resend