DEV Community: Nic Polotnianko 🇺🇦

The 6 best AI-native email marketing tools in 2026 (and which ones AI agents can actually run)

Nic Polotnianko 🇺🇦 — Mon, 02 Nov 2026 14:07:00 +0000

Every email platform has "AI" now. Most of it is a subject-line generator bolted onto a 2015 product. That's useful, but it isn't what changed in the last year.

What changed is that a few platforms now put AI at the center: you describe a goal, and the tool produces a finished multi-email flow in your brand, with timing and conditions, ready to review. And because these tools expose MCP servers, an AI agent like Claude, ChatGPT or Cursor can build segments, draft campaigns and read results for you.

This list is about those tools. I scored each one on four questions:

Does it produce finished work or fragments? Writing one email saves minutes. Generating a reviewed five-email onboarding sequence with timing saves days.
Does the AI use your real data? A dunning email that includes the customer's actual update-payment link beats a generic template.
Can an AI agent operate it? Through an MCP server or an app, and can the agent only draft, or also schedule and send (with approval)?
What does the AI cost at 10,000 contacts? Including the plan it requires, add-ons and credit meters.

Features and prices were checked against vendor docs and pricing pages in October 2026.

Quick comparison

Tool	Generates whole flows	Uses your billing/product data	Agent access (MCP)	Sends natively	~10k contacts / month
Sequenzy	Yes, sequences up to 10 emails	Yes (Stripe, Paddle, product events)	Yes, 350+ tools, sends with approval	Yes	$19 to $49, AI on every plan
Klaviyo	Yes (Composer, credit-metered)	Yes (ecommerce orders)	Drafts only	Yes	~$150 + Composer credits
Customer.io	Yes (AI Agent, beta)	Yes (your events)	Yes	Yes	$145
ActiveCampaign	Yes (AI automation builder)	CRM data	Yes, all plans	Yes	~$239
Braze	Yes (Operator)	Yes	Yes	Yes	Quote (~$88k/yr median)
Stripo	Drafts sequences, can't send	No	Yes (Medium plan+)	No	$20 to $125 (design only)

1. Sequenzy

Best for: SaaS and product teams that want AI to write complete, on-brand sequences from real billing and product data, and an agent to run the account.

Sequenzy is built around generative AI and agent control. Connect your website and it extracts your brand (logo, colors, voice) in under a minute. Describe a goal like "a trial conversion sequence for users who haven't connected their data" and it produces a complete sequence: up to 10 emails with subject lines, body copy, timing and conditions. Campaigns work the same way. Everything the AI creates is saved as a draft, and sequences are saved switched off, so nothing reaches a subscriber until you review it.

What sets it apart is that the AI writes against your real data. Stripe, Paddle, Lemon Squeezy and other billing tools feed the same subscriber profile as your product events, so a generated dunning sequence can include the customer's own update-payment link, and an upgrade sequence can reference real plan names. AI segments turn a sentence like "trial users who signed up last week and never sent a campaign" into filters.

The agent side is the most complete on this list: the MCP server exposes more than 350 tools, so Claude, ChatGPT, Cursor or Claude Code can build a segment, draft a campaign, start an A/B test and read results. Sends require explicit confirmation.

Pricing: Free for 2,500 emails/month with unlimited contacts; paid from $19/mo. All AI features are included on every plan, including free.
Pros: Generates whole flows, not single emails; AI grounded in billing and product data; transactional and marketing in one; agent-ready with approval steps; no per-contact pricing.
Cons: Predictive scores (LTV, churn, next order) only run on ecommerce order data; send-time optimization covers campaigns, not sequences; newer platform with a smaller template library; generated copy still needs a human edit.

2. Klaviyo

Best for: Ecommerce brands with enough order history to use predictions.

Klaviyo isn't AI-native by origin, but it has gone furthest of the incumbents. Its predictive analytics (lifetime value, churn risk, next order date) remain the benchmark, and Composer, in public beta since June 2026, builds campaigns, flows and signup forms from a prompt. Its MCP server and Claude/ChatGPT apps can read reporting and create drafts, but not send.

The catch is data and metering: predictions need at least 500 customers with orders and 180 days of history, and Composer runs on credits ($20/mo for 2,000).

Pricing: Free for 250 active profiles; ~$150/mo at 10,000 profiles, plus Composer credits.
Pros: Best predictive analytics in mid-market email, deep Shopify data, flow-building agent.
Cons: Predictions need order history, AI agent is metered, per-profile pricing climbs fast, built for ecommerce rather than SaaS.

3. Customer.io

Best for: Product and growth teams with event-driven journeys and engineers.

Customer.io launched its AI Agent (beta) in April 2026: it drafts emails, builds automations, analyzes performance and runs scheduled routines, and works in Slack too. LLM Actions run a prompt inside a journey and save the result to a profile attribute, which is handy for personalization at scale. It has a hosted MCP server, a Claude connector and a ChatGPT plugin, and the AI is included on every plan.

Pricing: $145/mo at 10,000 profiles on Essentials; extra AI credits $10 per 100k; no free plan.
Pros: AI that works on your event data, agent included, strong developer tooling.
Cons: No predictive scoring, no native billing triggers, technical setup, Premium starts at $1,000/mo.

4. ActiveCampaign

Best for: SMB teams that want AI inside a deep automation builder and CRM.

ActiveCampaign's third-generation AI ("Wavelength", August 2026) drafts campaigns, builds segments, generates automations from a description and flags journeys that stopped converting. It was one of the first marketing platforms with an official MCP server, and agent access works on every plan.

Pricing: ~$239/mo Plus at 10,000 contacts ($189 annual); predictive sending needs Pro (~$469/mo); 500 AI credits on every plan.
Pros: Mature automation, AI that builds automations, CRM included.
Cons: Key AI on higher tiers, contact-based pricing, dense interface, transactional is a paid add-on.

5. Braze

Best for: Enterprises running email, push and in-app across millions of users.

Braze's Operator (GA September 2026) writes copy, builds complete email designs from a prompt and edits Liquid. Intelligent Timing and Channel pick when and where to message each user, Decisioning Studio uses reinforcement learning to choose offers and frequency, and Agent Console runs your own LLM agents inside journeys. Its official MCP server went GA in September 2026. Salesforce agreed to acquire Braze in October 2026.

Pricing: Quote only; Vendr reports a median contract around $88,500/year.
Pros: Most complete AI decisioning stack, cross-channel, bring-your-own-model agents.
Cons: Enterprise price floor, months-long implementation, roadmap uncertainty after the acquisition.

6. Stripo

Best for: Designers who build emails in one tool and send from another.

Stripo is a design platform, not a sender. Its AI Assistant generates an email or a whole sequence from your brand settings, writes subject lines, preheaders and alt text, and generates images on credits. Its MCP server (Medium plan and up) lets Claude, Cursor or Codex create emails and export HTML to your ESP.

Pricing: Free plan; Basic $20/mo, Medium $45/mo, Pro $125/mo.
Pros: Strong AI design, exports to every major ESP.
Cons: Doesn't send, limited image credits, MCP only from Medium.

Which one should you pick?

SaaS or app with billing and product events: Sequenzy. Its AI writes against native Stripe, Paddle and Lemon Squeezy subscription data plus your product events, with agent access on every plan.
You want an AI agent to run your email day to day: Sequenzy, or Customer.io if you have engineers to wire up events.
Ecommerce with lots of order history: Klaviyo.
Complex event journeys and an engineering team: Customer.io.
SMB that wants AI plus a CRM: ActiveCampaign.
Enterprise, multi-channel: Braze.
Keep your ESP, just want AI design: Stripo.

A note on letting agents send

Every tool above that allows agent sending puts a confirmation step in front of live sends, and you should keep it on. A practical setup: let the agent build segments, draft campaigns and sequences, and report results freely, but require a human click for anything that reaches subscribers. AI-generated copy is good enough to start from, not good enough to ship unread.

For a broader version of this comparison, including predictive features and cold-email AI, see the best AI email marketing tools.

The 10 best email marketing tools for SaaS in 2026 (compared on billing triggers and price at 10k contacts)

Nic Polotnianko 🇺🇦 — Sun, 01 Nov 2026 14:07:00 +0000

Most "best email marketing tools" lists are written for ecommerce stores and newsletters. SaaS needs something different. Your most valuable emails are triggered by things that happen in your billing system and your product: a trial ending, a failed payment, a user who signed up but never connected their data. A tool that can't see those events turns every lifecycle email into a custom integration project.

So this list scores tools on five things:

Native billing triggers. Can it react to Stripe, Paddle, Lemon Squeezy or Chargebee events (trial ending, payment failed, upgraded, churned) without you writing webhook glue?
Product events. Is there a real events API so you can trigger emails on in-app behavior?
Transactional email. Can receipts, invites and password resets go through the same tool, or do you need a second provider?
B2B accounts. Can it model companies with several users, not just individual contacts?
Price at 10,000 contacts. Many SaaS lists are full of inactive free-tier signups, and per-contact pricing punishes that.

Each entry lists where the tool falls short and when another tool is the better pick. Prices and features were checked against vendor pricing pages and docs in October 2026.

Quick comparison

Tool	Best for	Native billing triggers	Transactional	B2B accounts	~10k contacts / month
Sequenzy	Billing-led SaaS	Stripe, Paddle, Lemon Squeezy, Chargebee, Polar + more	Included	Yes	$19 to $49 (billed by emails sent)
Customer.io	Complex event journeys	No (webhooks/Pipelines)	Included	Yes (Objects)	$145
Loops	Simple, modern SaaS email	Stripe, Polar	Included	No	~$99
Userlist	Account-based B2B	Via Zapier	Included	Yes	$149
Encharge	Visual flows, non-technical teams	Stripe, Chargebee, Paddle, Recurly	Premium only	Yes	$249
Bento	Indie SaaS on a budget	Stripe	Separate package	No	~$79
Resend	Developers who want email in code	No	Core product	No	$80
Postmark	Transactional deliverability	No	Core product	No	$15 (10k emails)
Brevo	Budget email plus SMS	Not native	Included	Yes (CRM)	~$69
HubSpot	Teams already on HubSpot CRM	Stripe data sync	Add-on	Yes	~$470 (Starter)

1. Sequenzy

Best for: SaaS teams whose lifecycle email runs on billing and product events.

Sequenzy is built specifically for software companies. Connect Stripe with OAuth (or Paddle, Lemon Squeezy, Chargebee, Polar, RevenueCat and others with an API key) and every subscription change becomes an event, a tag and an attribute: trial started, trial ending, payment failed, upgraded, downgraded, cancelled, churned, with MRR, lifetime value and plan on each profile. Sequences start from those events without code. A failed-payment event even carries the amount due and Stripe's hosted invoice link, so a dunning email can link straight to the page where the customer pays.

Product events come in through the API, server SDKs (TypeScript, Python, PHP, Go), a web SDK, mobile SDKs, Segment or PostHog. Organizations give B2B products company-level data, so you can run a sequence once per company or send billing emails only to account owners. Transactional email runs on the same platform and subscriber record.

AI is built in rather than bolted on: describe a goal and it drafts a complete onboarding, trial or dunning sequence in your brand, saved switched off for review. Its MCP server lets Claude, ChatGPT or Cursor build segments, draft campaigns and read results.

Pricing: Free for 2,500 emails/month with unlimited contacts; paid from $19/mo for 15k emails. Billed by emails sent, so dormant signups cost nothing.
Pros: Deepest native billing coverage on this list, marketing and transactional in one, B2B accounts, AI sequence generation, per-email pricing.
Cons: Newer platform (founded 2025), smaller template library than incumbents, no HubSpot or Salesforce CRM sync, free plan carries Sequenzy branding.

2. Customer.io

Best for: Technical teams with complex, branching event-driven journeys.

Customer.io has the most flexible workflow engine in mid-market SaaS email. Journeys branch on any event or attribute, wait for conditions and send email, push, SMS or in-app messages. Objects model accounts and workspaces for B2B. An AI Agent (beta since April 2026) drafts emails and builds automations.

The catch is billing: there's no native Stripe app. You send billing events yourself through Data Pipelines, a webhook recipe or your own code. With engineers, that's flexibility; for a founder who wants dunning working today, it's a project. Startups that raised under $10M can apply for a free year.

Pricing: Essentials from $100/mo (5,000 profiles), $145/mo at 10,000; Premium from $1,000/mo.
Pros: Best-in-class journeys, multi-channel, Objects for B2B, strong API.
Cons: No native billing triggers, learning curve, big jump to Premium, no free plan.

3. Loops

Best for: Founders who want a clean, modern tool with minimal setup.

Loops is the minimalist favorite of indie and early-stage SaaS. Transactional and marketing email live together, every feature is on every plan, and its native Stripe integration gained subscription, quote and checkout triggers in 2026. Polar is native too, and there's an MCP server and CLI.

Loops doesn't model accounts, segmentation is simpler than Customer.io's, and billing coverage stops at Stripe and Polar.

Pricing: Free for 1,000 contacts and 4,000 sends; paid from $49/mo; ~$99/mo at 10,000.
Pros: Clean UX, fast setup, generous free tier, transactional included.
Cons: No account objects, lighter segmentation, no Paddle/Chargebee/Lemon Squeezy.

4. Userlist

Best for: B2B SaaS selling to companies with many users.

Userlist is built around users and companies, so you can email an account's admin about billing and its active users about features. It handles onboarding, trial and lifecycle flows well and includes transactional email. Billing integrations aren't native: Stripe and Chargebee connect through Zapier or your own events.

Pricing: Basic $149/mo up to 10,000 users ($119 annual); Professional $349/mo.
Pros: Excellent account model, SaaS-focused, transactional included.
Cons: No native billing triggers, high entry price, no free plan.

5. Encharge

Best for: Non-technical teams that want visual flows with billing triggers.

Encharge's visual flow builder makes branching readable for marketers, and it connects natively to Stripe, Chargebee, Paddle, Recurly and Chargify. The catch is plan gating: custom events, event-based segmentation and transactional email are Premium-only, and most SaaS teams need exactly those.

Pricing: Growth $249/mo at 10,000 subscribers; Premium $399/mo.
Pros: Best visual builder for non-technical teams, broad billing coverage, Companies support.
Cons: Events and transactional locked to Premium, no free plan.

6. Bento

Best for: Indie SaaS that wants native Stripe and events on a budget.

Bento leans hard on events: Stripe payments and your own product events trigger flows and build segments, and lifetime value syncs to profiles. Pricing is per active user, which is kind to lists full of dormant free accounts. The interface is busy, and transactional email is now a separately priced package.

Pricing: $29/mo for 5,000 active users, then $0.01 per user (~$79 at 10,000).
Pros: Native Stripe at indie pricing, real event model, active-user billing.
Cons: Cluttered UI, transactional billed separately, no account objects.

7. Resend

Best for: Developer-led SaaS that wants to own email in code.

Resend has the best developer experience in email: a clean API, TypeScript SDK, React Email templates and fast domain setup. In April 2026 it added event-triggered Automations alongside broadcasts, so it now covers simple lifecycle email too. There are no billing integrations; you forward Stripe webhooks yourself.

Pricing: Transactional free for 3,000 emails/month; Pro Marketing $80/mo at 10,000 contacts.
Pros: Excellent DX, React Email, transactional + broadcasts + automations.
Cons: Automations are new and simple, no billing triggers, no account model.

8. Postmark

Best for: Transactional email that must arrive.

Postmark is a transactional email service known for inbox placement and speed. Message streams keep broadcasts separate from password resets. There's no automation builder, so it pairs with a lifecycle tool rather than replacing one.

Pricing: Basic $15/mo for 10,000 emails.
Pros: Excellent deliverability and logs, simple pricing.
Cons: No marketing automation or segments; you need a second tool for lifecycle email.

9. Brevo

Best for: Budget-conscious teams that also want SMS and a light CRM.

Brevo bills by emails sent rather than contacts, includes transactional email, and adds SMS, WhatsApp and a simple CRM. SaaS-specific depth is limited: no native billing triggers, and the events API needs the Standard plan or higher.

Pricing: ~$69/mo Standard (20,000 emails).
Pros: Cheap at scale, transactional included, multi-channel.
Cons: No native billing triggers, low email tiers cap your effective list size, generic rather than SaaS-focused.

10. HubSpot Marketing Hub

Best for: Sales-led SaaS already living in HubSpot CRM.

If your sales team runs on HubSpot, keeping marketing email next to deals and contacts has real value. But it's expensive for what SaaS lifecycle email needs: Starter limits automation, custom behavioral events are Enterprise-only, and Professional carries a $3,000 onboarding fee.

Pricing: ~$470/mo Starter at 10,000 contacts; Professional far higher.
Pros: CRM and email in one, strong reporting, huge ecosystem.
Cons: Expensive, product events gated to Enterprise, contact-based pricing.

How to choose

Stripe, Paddle or Lemon Squeezy is your source of truth: Sequenzy.
Complex product journeys and engineers to wire them: Customer.io.
Pre-revenue and want simple: Loops or Sequenzy's free plan.
B2B with many users per account: Userlist or Sequenzy.
Non-technical team, visual flows: Encharge.
Tight budget, indie SaaS: Bento or Sequenzy.
You want email in code: Resend for everything, or Postmark for transactional plus a lifecycle tool.
Sales-led on HubSpot: stay on HubSpot.

Whatever you choose, set up these four flows first: onboarding (signup → activation), trial ending, failed payment, and cancellation/win-back. They're where SaaS email pays for itself.

There's a longer, 20-tool version of this comparison, with billing-integration tables and pricing traps per tool, on the Sequenzy blog: 20 best email marketing tools for SaaS.

How to send transactional emails from Next.js App Router (Server Actions, route handlers and after())

Nic Polotnianko 🇺🇦 — Sat, 31 Oct 2026 11:35:22 +0000

Almost every Next.js app needs to send a few emails: a welcome email after signup, a magic link or password reset, a receipt. The App Router gives you several places to put that code, and they don't behave the same way when something is slow or fails.

This guide covers where the send should live, how to keep the API key off the client, how to avoid making users wait for your email provider, and the mistakes that lead to missing or duplicate emails. The examples use a generic sendEmail() helper so you can plug in whichever provider you use.

1. Keep the send on the server, always

Your email provider's API key can send mail as your domain. If it reaches the browser, anyone can use it.

Read it from process.env.EMAIL_API_KEY (no NEXT_PUBLIC_ prefix, which would inline it into client bundles).
Put the helper in a module that only server code imports, and mark it so a mistaken client import fails the build:

// lib/email.ts
import "server-only";

type SendEmailInput = {
  to: string;
  subject: string;
  html: string;
  idempotencyKey?: string;
};

export async function sendEmail(input: SendEmailInput) {
  const res = await fetch("https://api.your-email-provider.com/send", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.EMAIL_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(input),
  });

  if (!res.ok) {
    throw new Error(`Email send failed: ${res.status} ${await res.text()}`);
  }
  return res.json();
}

The server-only package (npm i server-only) makes the build fail if a Client Component imports this file.

2. Pick the right entry point

Trigger	Where to send from
A form in your own UI (signup, invite a teammate, contact form)	A Server Action
An external system calls you (Stripe webhook, auth provider hook, cron)	A route handler (`app/api/.../route.ts`)
Something that happens later (trial ending in 3 days, weekly digest)	A queue or scheduled job, not a request handler

Server Action: invite a teammate

// app/team/actions.ts
"use server";

import { after } from "next/server";
import { auth } from "@/lib/auth";
import { db } from "@/lib/db";
import { sendEmail } from "@/lib/email";
import { renderInviteEmail } from "@/emails/invite";

export async function inviteTeammate(formData: FormData) {
  const session = await auth();
  if (!session) throw new Error("Not signed in");

  const email = String(formData.get("email") ?? "").trim().toLowerCase();
  if (!email.includes("@")) return { error: "Enter a valid email" };

  const invite = await db.invite.create({
    data: { email, teamId: session.teamId, invitedBy: session.userId },
  });

  // Respond to the user now; send the email after the response is done.
  after(async () => {
    await sendEmail({
      to: email,
      subject: `${session.name} invited you to ${session.teamName}`,
      html: await renderInviteEmail({ invite, inviter: session.name }),
      idempotencyKey: `invite-${invite.id}`,
    });
  });

  return { ok: true };
}

Two things to notice:

Authorization happens inside the action. Server Actions are public HTTP endpoints. Anyone can call them with any form data, so check the session and validate input in the action itself, not only in the UI.
after() (from next/server, stable since Next.js 15.1) runs the callback once the response has been sent. The user doesn't wait on your email provider's latency, and a slow provider doesn't hold the form in a pending state.

Route handler: a webhook from your auth provider

// app/api/webhooks/auth/route.ts
import { sendEmail } from "@/lib/email";
import { renderWelcomeEmail } from "@/emails/welcome";
import { verifyAuthWebhook } from "@/lib/auth-webhooks";

export async function POST(request: Request) {
  const payload = await verifyAuthWebhook(request); // throws on a bad signature
  if (payload.type !== "user.created") {
    return Response.json({ ignored: true });
  }

  await sendEmail({
    to: payload.user.email,
    subject: "Welcome to Acme",
    html: await renderWelcomeEmail({ name: payload.user.firstName }),
    idempotencyKey: `welcome-${payload.user.id}`,
  });

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

Webhook senders retry when you return an error or time out, which is good for reliability and bad for duplicate emails. That's what the idempotencyKey is for (section 5).

3. Don't send from Client Components or `useEffect`

It's tempting to fire a "send welcome email" request from the client after signup succeeds. Don't:

The browser tab can close before the request goes out.
React Strict Mode runs effects twice in development, so you'll see double emails locally and might "fix" the wrong thing.
You need a public endpoint for it, which anyone can call to make you send email.

Send from the server code that created the user, or from the webhook your auth provider calls.

4. Templates: React Email or plain HTML

Email clients are not browsers. Outlook on Windows still renders with Word's engine, Gmail strips <style> blocks in some contexts, and flexbox and grid are unreliable. Two sane options:

React Email (@react-email/components + @react-email/render): write templates as React components using email-safe primitives (Section, Row, Column, Button) and render them to an HTML string on the server.
Provider-side templates: design the email in your provider's editor and send a template ID plus variables. Non-developers can then edit copy without a deploy.

// emails/welcome.tsx
import { Html, Body, Container, Heading, Text, Button } from "@react-email/components";
import { render } from "@react-email/render";

function WelcomeEmail({ name }: { name: string }) {
  return (
    <Html>
      <Body style={{ fontFamily: "Arial, sans-serif", backgroundColor: "#ffffff" }}>
        <Container style={{ maxWidth: 560, padding: 24 }}>
          <Heading as="h1">Welcome, {name}</Heading>
          <Text>Your workspace is ready. The fastest way to get value is to connect your data first.</Text>
          <Button href="https://app.acme.com/onboarding" style={{ backgroundColor: "#111", color: "#fff", padding: "12px 20px" }}>
            Finish setup
          </Button>
        </Container>
      </Body>
    </Html>
  );
}

export function renderWelcomeEmail(props: { name: string }) {
  return render(<WelcomeEmail {...props} />); // returns a Promise<string>
}

Whichever you choose, also send a plain-text version if your provider doesn't generate one, and keep the important action in a real link rather than only in an image.

5. Make sends idempotent

Duplicates come from retries: a webhook delivered twice, a user double-submitting a form, a serverless function retried after a timeout. The fix is to give every logical email a stable key:

welcome-${userId}, invite-${inviteId}, receipt-${invoiceId}, password-reset-${tokenId}

Then either pass it to your provider as an idempotency key (many APIs accept one and return the original result for a repeated key), or record it in your database with a unique constraint and skip the send when the insert conflicts:

const inserted = await db.sentEmail.createMany({
  data: [{ key: `welcome-${user.id}` }],
  skipDuplicates: true,
});
if (inserted.count === 0) return; // already sent

6. Know what `after()` doesn't do

after() is great for "don't make the user wait". It is not a job queue:

If the send throws, nothing retries it. Log the error, and alert on it for important emails.
On serverless platforms the work is tied to the lifetime of that invocation. Short sends are fine; long work belongs elsewhere.
It can't schedule anything for later.

For emails that must arrive (password resets, receipts), either retry inside the callback with a short backoff, or enqueue a job (BullMQ, Inngest, QStash, Trigger.dev, your provider's own scheduling) and let the queue retry. For anything time-based (trial reminders, onboarding drips), use a scheduler or an email platform's automation instead of request handlers.

7. Before you go live

[ ] Send from your own domain with SPF, DKIM and DMARC set up, not the provider's shared test domain
[ ] Separate sending subdomains for transactional and marketing email, if you send both
[ ] API key only in server env vars, server-only on the email module
[ ] Server Actions check the session and validate input
[ ] Every email has an idempotency key
[ ] Failures are logged and alerted, not swallowed
[ ] Test rendering in Gmail, Outlook and Apple Mail (or a rendering preview tool)

Using Sequenzy for this

Here is how this looks with Sequenzy, an email platform for SaaS. The sendEmail helper above becomes:

import "server-only";
import Sequenzy from "sequenzy";

const sequenzy = new Sequenzy({ apiKey: process.env.SEQUENZY_API_KEY });

export function sendWelcome(to: string, firstName: string) {
  return sequenzy.transactional.send({
    to,
    slug: "welcome-email", // template designed in the dashboard
    variables: { firstName },
  });
}

The same account also runs the onboarding and trial sequences from section 6, so time-based emails don't need their own queue. The quick start takes about five minutes. Everything else in this guide applies whichever provider you choose.

Stripe failed payment emails: a dunning flow that recovers revenue (Node.js)

Nic Polotnianko 🇺🇦 — Sat, 31 Oct 2026 11:33:14 +0000

Failed payments are the quietest kind of churn. Nobody decided to leave: a card expired, a bank flagged a renewal, a corporate card hit its limit. If nobody tells the customer, Stripe retries a few times, gives up, and the subscription ends.

Stripe will send a basic failed payment email for you (Settings → Billing → Subscriptions and emails). It's worth turning on, but it's one generic email. A short sequence that explains what happened, links straight to a page where the customer can fix it, and stops the moment they pay recovers noticeably more.

This post walks through building that flow on Stripe webhooks in Node.js: the events you need, the timing, the copy, and the edge cases that make dunning emails go wrong.

The events that matter

You need three webhook events:

Event	What it tells you
`invoice.payment_failed`	A charge attempt on an invoice failed. Fires on the first attempt and on every automatic retry.
`invoice.paid`	The invoice was paid, either by a retry or by the customer. This is your "stop emailing" signal.
`customer.subscription.updated` / `customer.subscription.deleted`	The subscription moved to `past_due`, `unpaid` or `canceled` after retries ran out.

The invoice object on invoice.payment_failed carries most of what an email needs:

id: the invoice ID. It stays the same across every retry of that invoice, which makes it the right key for "one recovery flow per failed invoice".
attempt_count: 1 on the first failure, then increments with each retry.
next_payment_attempt: a Unix timestamp for the next automatic retry, or null when Stripe will not retry again.
hosted_invoice_url: Stripe's hosted page where the customer can pay this invoice with a new card.
amount_due and currency: for "Your $49.00 payment didn't go through".
customer and customer_email.

Step 1: receive and verify the webhook

Verify the signature against the raw body. Parsing JSON first breaks verification, which is the number one "why does my Stripe webhook fail" issue.

import express from "express";
import Stripe from "stripe";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
const app = express();

app.post(
  "/webhooks/stripe",
  express.raw({ type: "application/json" }),
  async (req, res) => {
    let event;
    try {
      event = stripe.webhooks.constructEvent(
        req.body,
        req.headers["stripe-signature"],
        process.env.STRIPE_WEBHOOK_SECRET
      );
    } catch (err) {
      return res.status(400).send(`Webhook Error: ${err.message}`);
    }

    // Acknowledge fast, do the work in a queue.
    await enqueue("stripe-event", { id: event.id, type: event.type, data: event.data.object });
    res.json({ received: true });
  }
);

Two things to get right here:

Return 2xx quickly. Stripe retries webhooks it considers failed (for up to three days in live mode). If you send emails inline and your email provider is slow, Stripe times out, retries, and you send the same email twice.
Deduplicate by event.id. Even with fast responses, Stripe can deliver an event more than once. Store processed event IDs (a unique index is enough) and skip repeats.

Step 2: decide what to send

Here's a sequence that works for most B2B SaaS:

When	Email	Goal
First failure (`attempt_count === 1`)	"Your payment didn't go through"	Calm, factual, one button to update the card.
~3 days later, still unpaid	"Quick reminder: update your card"	Shorter. Mention what they'd lose (their data, their team's access).
Final retry (`next_payment_attempt === null`)	"Last chance before your subscription is canceled"	Clear deadline, same single button.
After cancellation	"Your subscription was canceled"	How to reactivate in one click. No guilt.

The key detail: drive the flow off the first failure, not every failure. invoice.payment_failed fires on every retry. If you send an email per event, a customer on Stripe's default Smart Retries schedule (Stripe's recommended default is up to 8 tries within 2 weeks) can get eight near-identical emails. Start one flow when attempt_count === 1, and use next_payment_attempt === null to trigger the final notice.

async function handleStripeEvent({ id, type, data }) {
  if (await alreadyProcessed(id)) return;

  if (type === "invoice.payment_failed") {
    const invoice = data;

    if (invoice.attempt_count === 1) {
      await startDunningFlow({
        invoiceId: invoice.id,
        email: invoice.customer_email,
        amount: formatMoney(invoice.amount_due, invoice.currency),
        payUrl: invoice.hosted_invoice_url,
      });
    }

    if (invoice.next_payment_attempt === null) {
      await sendFinalNotice(invoice.id);
    }
  }

  if (type === "invoice.paid") {
    await stopDunningFlow(data.id); // keyed by invoice ID
  }

  await markProcessed(id);
}

function formatMoney(amountInCents, currency) {
  return new Intl.NumberFormat("en-US", {
    style: "currency",
    currency: currency.toUpperCase(),
  }).format(amountInCents / 100);
}

(Zero-decimal currencies like JPY don't divide by 100. If you bill in them, check the currency before formatting.)

startDunningFlow should schedule the follow-ups as delayed jobs (BullMQ, Sidekiq, Cloud Tasks, whatever you use) and re-check the invoice status before each send:

async function sendReminderIfStillUnpaid(invoiceId) {
  const invoice = await stripe.invoices.retrieve(invoiceId);
  if (invoice.status !== "open") return; // paid, voided or uncollectible: stop
  await sendEmail("dunning-reminder", { invoice });
}

The re-check is cheap insurance. Webhooks arrive out of order sometimes, and "we already charged you, please pay" is the fastest way to get a support ticket.

Step 3: where the button should go

Your email needs one button that lets the customer fix the problem in under a minute. You have two good options:

hosted_invoice_url: Stripe's hosted invoice page. The customer can pay that exact invoice with a new card, no login needed. Best for the dunning emails themselves.
The Stripe customer portal: lets the customer replace their default payment method for future invoices too. Portal session URLs are short-lived, so don't paste one into an email. Link to a route in your app that creates a session on click:

app.get("/billing/update-card", requireLogin, async (req, res) => {
  const session = await stripe.billingPortal.sessions.create({
    customer: req.user.stripeCustomerId,
    return_url: "https://app.example.com/settings/billing",
  });
  res.redirect(session.url);
});

Avoid sending people to a generic "log in to your account" page. Every extra step loses recoveries, and a customer whose card failed is not in the mood to hunt through settings.

Step 4: the copy

Dunning emails are transactional in tone even though they feel like marketing. A few things consistently help:

Lead with the fact, not the apology. "Your $49.00 payment for Acme Pro didn't go through" beats "Uh oh! Something went wrong."
Say what happens next and when. "We'll try again on November 4. If it still fails, your workspace will be paused on November 12."
Never blame the customer. Most failures are expired cards or bank fraud filters. "Your bank declined the charge" is accurate and neutral.
One button. "Update payment method". Not a menu of links.
Send from a human-looking address, and let replies land in a real inbox. People reply to dunning emails with "I changed jobs, can you invoice my new company?", and those are recoveries too.

A first email can be this short:

Subject: Your Acme payment didn't go through

Hi Sam,

We tried to charge $49.00 for your Acme Pro plan, but your bank declined it. This usually means the card expired or was replaced.

[Update payment method]

We'll retry automatically on November 4. Nothing changes in your account until then.

If you have questions, just reply to this email.

Edge cases that cause double (or wrong) emails

These come up in almost every dunning implementation:

Two invoices fail at once. A customer with two subscriptions can have two open invoices. Key the flow by invoice ID, not by customer, or the second failure gets swallowed (or the first payment stops both flows).
Customer pays between retries. Handled by invoice.paid plus the status re-check before each send.
Manual invoices. Invoices with collection_method: "send_invoice" have no automatic retries, so next_payment_attempt is null from the start. Decide whether they get the same flow or a different "your invoice is overdue" email.
One-off invoices. Not every failed invoice belongs to a subscription. Check billing_reason (subscription_create, subscription_cycle, subscription_update) if you only want to chase renewals.
API version drift. Stripe's 2025-03-31 (basil) API moved some invoice fields, for example the subscription reference now lives under invoice.parent.subscription_details. Pin your webhook endpoint's API version and read fields that exist in it.

Measuring it

Track two numbers:

Recovery rate: failed invoices that end up paid ÷ failed invoices. Split it by "paid by automatic retry" and "paid after an email click". Automatic retries recover some without any email, and you want to know what the emails add.
Time to recovery: days from first failure to payment. If most recoveries happen after email 1, your later emails can be gentler; if they cluster at the final notice, the deadline is doing the work.

If you'd rather not maintain this

Sequenzy, an email platform for SaaS, handles this flow out of the box. You connect Stripe, and failed invoices arrive as a saas.payment_failed event carrying invoiceId, attemptCount, amountDueFormatted, hostedInvoiceUrl and willRetry. A sequence triggered on the first attempt and stopped by the matching saas.purchase handles the "one flow per invoice, stop on payment" logic above without your own queue. The Stripe integration docs show the setup.

Whether you build it yourself or not, the pattern is the same: start on the first failure, key by invoice, re-check before every send, and make the button go straight to a page where the customer can pay.

DEV Community: Nic Polotnianko 🇺🇦

The 6 best AI-native email marketing tools in 2026 (and which ones AI agents can actually run)

Quick comparison

1. Sequenzy

2. Klaviyo

3. Customer.io

4. ActiveCampaign

5. Braze

6. Stripo

Which one should you pick?

A note on letting agents send

The 10 best email marketing tools for SaaS in 2026 (compared on billing triggers and price at 10k contacts)

Quick comparison

1. Sequenzy

2. Customer.io

3. Loops

4. Userlist

5. Encharge

6. Bento

7. Resend

8. Postmark

9. Brevo

10. HubSpot Marketing Hub

How to choose

How to send transactional emails from Next.js App Router (Server Actions, route handlers and after())

1. Keep the send on the server, always

2. Pick the right entry point

Server Action: invite a teammate

Route handler: a webhook from your auth provider

3. Don't send from Client Components or useEffect

4. Templates: React Email or plain HTML

5. Make sends idempotent

6. Know what after() doesn't do

7. Before you go live

Using Sequenzy for this

Stripe failed payment emails: a dunning flow that recovers revenue (Node.js)

The events that matter

Step 1: receive and verify the webhook

Step 2: decide what to send

Step 3: where the button should go

Step 4: the copy

Edge cases that cause double (or wrong) emails

Measuring it

If you'd rather not maintain this

3. Don't send from Client Components or `useEffect`

6. Know what `after()` doesn't do