How to Send Emails from Polar Webhooks (2026 Guide)

npm install sequenzy svix

npm install resend svix

npm install @sendgrid/mail svix

SEQUENZY_API_KEY=sq_your_api_key_here

RESEND_API_KEY=re_your_api_key_here

SENDGRID_API_KEY=SG.your_api_key_here

import Sequenzy from "sequenzy";

// Reads SEQUENZY_API_KEY from env automatically
export const sequenzy = new Sequenzy();

import { Resend } from "resend";

export const resend = new Resend(process.env.RESEND_API_KEY);
export const FROM = "Your App <noreply@yourdomain.com>";

import sgMail from "@sendgrid/mail";

sgMail.setApiKey(process.env.SENDGRID_API_KEY!);
export { sgMail };
export const FROM = "noreply@yourdomain.com";

import { NextRequest, NextResponse } from "next/server";
import { sequenzy } from "@/lib/email";
import { verifyPolarWebhook } from "@/lib/polar";
import {
orderConfirmationEmail,
subscriptionWelcomeEmail,
cancellationEmail,
revokedEmail,
uncancelledEmail,
benefitGrantedEmail,
planChangeEmail,
} from "@/lib/polar-emails";

const APP_URL = process.env.APP_URL!;

export async function POST(request: NextRequest) {
const body = await request.text();

let event: Record<string, unknown>;
try {
  event = verifyPolarWebhook(body, {
    "webhook-id": request.headers.get("webhook-id") ?? "",
    "webhook-timestamp": request.headers.get("webhook-timestamp") ?? "",
    "webhook-signature": request.headers.get("webhook-signature") ?? "",
  });
} catch {
  return NextResponse.json({ error: "Invalid signature" }, { status: 400 });
}

try {
  await handlePolarEvent(event);
} catch (error) {
  console.error(`Polar webhook failed for ${event.type}:`, error);
}

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

async function handlePolarEvent(event: Record<string, unknown>) {
const data = event.data as Record<string, unknown>;

switch (event.type) {
  case "order.created": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };
    const amount = data.amount as number;
    const currency = (data.currency as string) ?? "USD";

    const formatted = formatAmount(amount, currency);

    await sequenzy.transactional.send({
      to: customer.email,
      subject: `Order confirmed — ${formatted}`,
      body: orderConfirmationEmail({
        productName: product.name,
        amount: formatted,
        currency,
        appUrl: APP_URL,
      }),
    });

    // Add as subscriber for marketing
    await sequenzy.subscribers.create({
      email: customer.email,
      tags: ["customer", "polar"],
      customAttributes: {
        product: product.name,
        polarOrderId: data.id as string,
      },
    });
    break;
  }

  case "subscription.created":
  case "subscription.active": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };

    await sequenzy.transactional.send({
      to: customer.email,
      subject: `Welcome! Your ${product.name} subscription is active`,
      body: subscriptionWelcomeEmail({
        productName: product.name,
        appUrl: APP_URL,
      }),
    });

    await sequenzy.subscribers.create({
      email: customer.email,
      tags: ["customer", "polar", "subscriber"],
      customAttributes: {
        product: product.name,
        subscriptionId: data.id as string,
      },
    });
    break;
  }

  case "subscription.updated": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };
    const status = data.status as string;

    // Handle cancellation set (subscription.canceled is separate)
    if (status === "canceled") {
      const currentPeriodEnd = data.current_period_end as string | undefined;
      const endDate = currentPeriodEnd
        ? new Date(currentPeriodEnd).toLocaleDateString()
        : "the end of your billing period";

      await sequenzy.transactional.send({
        to: customer.email,
        subject: "Your subscription has been cancelled",
        body: cancellationEmail({
          productName: product.name,
          endDate,
          pricingUrl: `${APP_URL}/pricing`,
        }),
      });

      await sequenzy.subscribers.tags.add({
        email: customer.email,
        tag: "cancelled",
      });
      break;
    }

    // Handle plan change (product changed)
    // Compare previous product if available
    const priceAmount = data.amount as number | undefined;
    const currency = (data.currency as string) ?? "USD";

    if (priceAmount) {
      await sequenzy.transactional.send({
        to: customer.email,
        subject: `Your plan has been updated`,
        body: planChangeEmail({
          oldProduct: "Previous plan",
          newProduct: product.name,
          newAmount: formatAmount(priceAmount, currency),
          currency,
          appUrl: APP_URL,
        }),
      });
    }
    break;
  }

  case "subscription.canceled": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };
    const currentPeriodEnd = data.current_period_end as string | undefined;
    const endDate = currentPeriodEnd
      ? new Date(currentPeriodEnd).toLocaleDateString()
      : "the end of your billing period";

    await sequenzy.transactional.send({
      to: customer.email,
      subject: "Your subscription has been cancelled",
      body: cancellationEmail({
        productName: product.name,
        endDate,
        pricingUrl: `${APP_URL}/pricing`,
      }),
    });

    await sequenzy.subscribers.tags.add({
      email: customer.email,
      tag: "cancelled",
    });
    break;
  }

  case "subscription.uncanceled": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };

    await sequenzy.transactional.send({
      to: customer.email,
      subject: "Welcome back! Subscription reactivated",
      body: uncancelledEmail({
        productName: product.name,
        appUrl: APP_URL,
      }),
    });

    // Remove cancelled tag
    await sequenzy.subscribers.tags.remove({
      email: customer.email,
      tag: "cancelled",
    });
    break;
  }

  case "subscription.revoked": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };

    await sequenzy.transactional.send({
      to: customer.email,
      subject: "Your subscription access has ended",
      body: revokedEmail({
        productName: product.name,
        pricingUrl: `${APP_URL}/pricing`,
      }),
    });

    await sequenzy.subscribers.tags.add({
      email: customer.email,
      tag: "churned",
    });
    break;
  }

  case "benefit_grant.created": {
    const customer = data.customer as { email: string };
    const benefit = data.benefit as {
      type: string;
      description: string;
    };
    const product = data.product as { name: string } | undefined;

    const benefitLabels: Record<string, string> = {
      license_keys: "License Key",
      downloadables: "File Download",
      discord: "Discord Access",
      github_repository: "GitHub Repository Access",
      custom: "Custom Benefit",
    };

    await sequenzy.transactional.send({
      to: customer.email,
      subject: `Your benefit is ready: ${benefit.description}`,
      body: benefitGrantedEmail({
        benefitType: benefitLabels[benefit.type] ?? benefit.type,
        productName: product?.name ?? "your purchase",
        details: benefit.description,
        appUrl: APP_URL,
      }),
    });
    break;
  }
}
}

function formatAmount(amount: number, currency: string): string {
try {
  return new Intl.NumberFormat("en", {
    style: "currency",
    currency,
  }).format(amount / 100);
} catch {
  return `${(amount / 100).toFixed(2)} ${currency}`;
}
}

import { NextRequest, NextResponse } from "next/server";
import { resend, FROM } from "@/lib/email";
import { verifyPolarWebhook } from "@/lib/polar";
import {
orderConfirmationEmail,
subscriptionWelcomeEmail,
cancellationEmail,
revokedEmail,
uncancelledEmail,
benefitGrantedEmail,
} from "@/lib/polar-emails";

const APP_URL = process.env.APP_URL!;

export async function POST(request: NextRequest) {
const body = await request.text();

let event: Record<string, unknown>;
try {
  event = verifyPolarWebhook(body, {
    "webhook-id": request.headers.get("webhook-id") ?? "",
    "webhook-timestamp": request.headers.get("webhook-timestamp") ?? "",
    "webhook-signature": request.headers.get("webhook-signature") ?? "",
  });
} catch {
  return NextResponse.json({ error: "Invalid signature" }, { status: 400 });
}

try {
  await handlePolarEvent(event);
} catch (error) {
  console.error(`Polar webhook failed for ${event.type}:`, error);
}

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

async function handlePolarEvent(event: Record<string, unknown>) {
const data = event.data as Record<string, unknown>;

switch (event.type) {
  case "order.created": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };
    const amount = data.amount as number;
    const currency = (data.currency as string) ?? "USD";

    await resend.emails.send({
      from: FROM, to: customer.email,
      subject: `Order confirmed — ${formatAmount(amount, currency)}`,
      html: orderConfirmationEmail({
        productName: product.name,
        amount: formatAmount(amount, currency),
        currency, appUrl: APP_URL,
      }),
    });
    break;
  }

  case "subscription.created":
  case "subscription.active": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };

    await resend.emails.send({
      from: FROM, to: customer.email,
      subject: `Welcome! Your ${product.name} subscription is active`,
      html: subscriptionWelcomeEmail({
        productName: product.name, appUrl: APP_URL,
      }),
    });
    break;
  }

  case "subscription.canceled": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };
    const currentPeriodEnd = data.current_period_end as string | undefined;

    await resend.emails.send({
      from: FROM, to: customer.email,
      subject: "Your subscription has been cancelled",
      html: cancellationEmail({
        productName: product.name,
        endDate: currentPeriodEnd
          ? new Date(currentPeriodEnd).toLocaleDateString()
          : "the end of your billing period",
        pricingUrl: `${APP_URL}/pricing`,
      }),
    });
    break;
  }

  case "subscription.uncanceled": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };

    await resend.emails.send({
      from: FROM, to: customer.email,
      subject: "Welcome back! Subscription reactivated",
      html: uncancelledEmail({
        productName: product.name, appUrl: APP_URL,
      }),
    });
    break;
  }

  case "subscription.revoked": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };

    await resend.emails.send({
      from: FROM, to: customer.email,
      subject: "Your subscription access has ended",
      html: revokedEmail({
        productName: product.name,
        pricingUrl: `${APP_URL}/pricing`,
      }),
    });
    break;
  }

  case "benefit_grant.created": {
    const customer = data.customer as { email: string };
    const benefit = data.benefit as { type: string; description: string };
    const product = data.product as { name: string } | undefined;

    await resend.emails.send({
      from: FROM, to: customer.email,
      subject: `Your benefit is ready: ${benefit.description}`,
      html: benefitGrantedEmail({
        benefitType: benefit.type, details: benefit.description,
        productName: product?.name ?? "your purchase", appUrl: APP_URL,
      }),
    });
    break;
  }
}
}

function formatAmount(amount: number, currency: string): string {
try {
  return new Intl.NumberFormat("en", {
    style: "currency", currency,
  }).format(amount / 100);
} catch {
  return `${(amount / 100).toFixed(2)} ${currency}`;
}
}

import { NextRequest, NextResponse } from "next/server";
import { sgMail, FROM } from "@/lib/email";
import { verifyPolarWebhook } from "@/lib/polar";
import {
orderConfirmationEmail,
subscriptionWelcomeEmail,
cancellationEmail,
revokedEmail,
uncancelledEmail,
benefitGrantedEmail,
} from "@/lib/polar-emails";

const APP_URL = process.env.APP_URL!;

export async function POST(request: NextRequest) {
const body = await request.text();

let event: Record<string, unknown>;
try {
  event = verifyPolarWebhook(body, {
    "webhook-id": request.headers.get("webhook-id") ?? "",
    "webhook-timestamp": request.headers.get("webhook-timestamp") ?? "",
    "webhook-signature": request.headers.get("webhook-signature") ?? "",
  });
} catch {
  return NextResponse.json({ error: "Invalid signature" }, { status: 400 });
}

try {
  await handlePolarEvent(event);
} catch (error) {
  console.error(`Polar webhook failed for ${event.type}:`, error);
}

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

async function handlePolarEvent(event: Record<string, unknown>) {
const data = event.data as Record<string, unknown>;

switch (event.type) {
  case "order.created": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };
    const amount = data.amount as number;
    const currency = (data.currency as string) ?? "USD";

    await sgMail.send({
      to: customer.email, from: FROM,
      subject: `Order confirmed — ${formatAmount(amount, currency)}`,
      html: orderConfirmationEmail({
        productName: product.name,
        amount: formatAmount(amount, currency),
        currency, appUrl: APP_URL,
      }),
    });
    break;
  }

  case "subscription.created":
  case "subscription.active": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };

    await sgMail.send({
      to: customer.email, from: FROM,
      subject: `Welcome! Your ${product.name} subscription is active`,
      html: subscriptionWelcomeEmail({
        productName: product.name, appUrl: APP_URL,
      }),
    });
    break;
  }

  case "subscription.canceled": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };
    const currentPeriodEnd = data.current_period_end as string | undefined;

    await sgMail.send({
      to: customer.email, from: FROM,
      subject: "Your subscription has been cancelled",
      html: cancellationEmail({
        productName: product.name,
        endDate: currentPeriodEnd
          ? new Date(currentPeriodEnd).toLocaleDateString()
          : "the end of your billing period",
        pricingUrl: `${APP_URL}/pricing`,
      }),
    });
    break;
  }

  case "subscription.uncanceled": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };

    await sgMail.send({
      to: customer.email, from: FROM,
      subject: "Welcome back! Subscription reactivated",
      html: uncancelledEmail({
        productName: product.name, appUrl: APP_URL,
      }),
    });
    break;
  }

  case "subscription.revoked": {
    const customer = data.customer as { email: string };
    const product = data.product as { name: string };

    await sgMail.send({
      to: customer.email, from: FROM,
      subject: "Your subscription access has ended",
      html: revokedEmail({
        productName: product.name,
        pricingUrl: `${APP_URL}/pricing`,
      }),
    });
    break;
  }

  case "benefit_grant.created": {
    const customer = data.customer as { email: string };
    const benefit = data.benefit as { type: string; description: string };
    const product = data.product as { name: string } | undefined;

    await sgMail.send({
      to: customer.email, from: FROM,
      subject: `Your benefit is ready: ${benefit.description}`,
      html: benefitGrantedEmail({
        benefitType: benefit.type, details: benefit.description,
        productName: product?.name ?? "your purchase", appUrl: APP_URL,
      }),
    });
    break;
  }
}
}

function formatAmount(amount: number, currency: string): string {
try {
  return new Intl.NumberFormat("en", {
    style: "currency", currency,
  }).format(amount / 100);
} catch {
  return `${(amount / 100).toFixed(2)} ${currency}`;
}
}