How to Send Emails from Lemon Squeezy Webhooks (2026 Guide)

npm install sequenzy

npm install resend

npm install @sendgrid/mail

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 { verifyLemonSqueezyWebhook } from "@/lib/lemon-squeezy";
import {
orderConfirmationEmail,
subscriptionWelcomeEmail,
trialStartedEmail,
paymentFailedEmail,
cancellationEmail,
expiredEmail,
pausedEmail,
resumedEmail,
licenseKeyEmail,
} from "@/lib/lemon-squeezy-emails";

const APP_URL = process.env.APP_URL!;

export async function POST(request: NextRequest) {
const body = await request.text();
const signature = request.headers.get("x-signature") ?? "";

if (!verifyLemonSqueezyWebhook(body, signature, process.env.LEMON_SQUEEZY_WEBHOOK_SECRET!)) {
  return NextResponse.json({ error: "Invalid signature" }, { status: 400 });
}

const event = JSON.parse(body);

try {
  await handleLemonSqueezyEvent(event);
} catch (error) {
  console.error(`LS webhook failed for ${event.meta.event_name}:`, error);
}

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

interface LemonSqueezyEvent {
meta: {
  event_name: string;
  custom_data?: Record<string, string>;
};
data: {
  id: string;
  type: string;
  attributes: Record<string, unknown>;
};
}

async function handleLemonSqueezyEvent(event: LemonSqueezyEvent) {
const eventName = event.meta.event_name;
const attrs = event.data.attributes;
const email = attrs.user_email as string;
const userName = (attrs.user_name as string) ?? "there";

if (!email) return;

switch (eventName) {
  case "order_created": {
    const firstItem = attrs.first_order_item as {
      product_name: string;
      variant_name: string;
    };
    const totalFormatted = attrs.total_formatted as string;
    const urls = attrs.urls as { receipt?: string } | undefined;

    await sequenzy.transactional.send({
      to: email,
      subject: `Order confirmed — ${totalFormatted}`,
      body: orderConfirmationEmail({
        userName,
        productName: firstItem.product_name,
        totalFormatted,
        receiptUrl: urls?.receipt,
        appUrl: APP_URL,
      }),
    });

    // Add as subscriber for marketing
    await sequenzy.subscribers.create({
      email,
      firstName: userName,
      tags: ["customer", "lemon-squeezy"],
      customAttributes: {
        product: firstItem.product_name,
        variant: firstItem.variant_name,
      },
    });
    break;
  }

  case "subscription_created": {
    const productName = attrs.product_name as string;
    const variantName = attrs.variant_name as string;
    const status = attrs.status as string;

    if (status === "on_trial") {
      const trialEndsAt = attrs.trial_ends_at as string | null;
      const trialEndDate = trialEndsAt
        ? new Date(trialEndsAt).toLocaleDateString()
        : "soon";

      await sequenzy.transactional.send({
        to: email,
        subject: "Your free trial has started!",
        body: trialStartedEmail({
          userName,
          productName,
          trialEndDate,
          appUrl: APP_URL,
        }),
      });
    } else {
      await sequenzy.transactional.send({
        to: email,
        subject: `Welcome! Your ${productName} subscription is active`,
        body: subscriptionWelcomeEmail({
          userName,
          productName,
          variantName,
          appUrl: APP_URL,
        }),
      });
    }

    await sequenzy.subscribers.create({
      email,
      firstName: userName,
      tags: [status === "on_trial" ? "trial" : "customer", "lemon-squeezy"],
      customAttributes: {
        product: productName,
        variant: variantName,
        lsSubscriptionId: event.data.id,
      },
    });
    break;
  }

  case "subscription_updated": {
    const status = attrs.status as string;
    const productName = attrs.product_name as string;
    const urls = attrs.urls as {
      update_payment_method?: string;
      customer_portal?: string;
    } | undefined;

    // Handle different status transitions
    if (status === "paused") {
      await sequenzy.transactional.send({
        to: email,
        subject: "Your subscription has been paused",
        body: pausedEmail({
          productName,
          resumeUrl: urls?.customer_portal ?? `${APP_URL}/billing`,
        }),
      });
    } else if (status === "past_due") {
      await sequenzy.transactional.send({
        to: email,
        subject: "Payment failed — action required",
        body: paymentFailedEmail({
          updatePaymentUrl: urls?.update_payment_method ?? `${APP_URL}/billing`,
          appUrl: APP_URL,
        }),
      });

      await sequenzy.subscribers.tags.add({
        email,
        tag: "past-due",
      });
    }
    break;
  }

  case "subscription_cancelled": {
    const productName = attrs.product_name as string;
    const endsAt = attrs.ends_at as string | null;
    const endDate = endsAt
      ? new Date(endsAt).toLocaleDateString()
      : "the end of your billing period";

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

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

  case "subscription_expired": {
    const productName = attrs.product_name as string;

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

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

  case "subscription_resumed": {
    const productName = attrs.product_name as string;

    await sequenzy.transactional.send({
      to: email,
      subject: "Welcome back! Subscription resumed",
      body: resumedEmail({
        productName,
        appUrl: APP_URL,
      }),
    });

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

  case "subscription_paused": {
    const productName = attrs.product_name as string;
    const urls = attrs.urls as { customer_portal?: string } | undefined;

    await sequenzy.transactional.send({
      to: email,
      subject: "Your subscription has been paused",
      body: pausedEmail({
        productName,
        resumeUrl: urls?.customer_portal ?? `${APP_URL}/billing`,
      }),
    });
    break;
  }

  case "subscription_payment_failed": {
    const urls = attrs.urls as { update_payment_method?: string } | undefined;

    await sequenzy.transactional.send({
      to: email,
      subject: "Payment failed — action required",
      body: paymentFailedEmail({
        updatePaymentUrl: urls?.update_payment_method ?? `${APP_URL}/billing`,
        appUrl: APP_URL,
      }),
    });

    await sequenzy.subscribers.tags.add({
      email,
      tag: "past-due",
    });
    break;
  }

  case "license_key_created": {
    const key = attrs.key as string;
    const activationLimit = (attrs.activation_limit as number) ?? 1;
    const expiresAt = attrs.expires_at as string | null;
    const productName = (attrs.product_name as string) ?? "your purchase";

    await sequenzy.transactional.send({
      to: email,
      subject: `Your license key for ${productName}`,
      body: licenseKeyEmail({
        productName,
        licenseKey: key,
        activationLimit,
        expiresAt: expiresAt ? new Date(expiresAt).toLocaleDateString() : undefined,
      }),
    });
    break;
  }
}
}

import { NextRequest, NextResponse } from "next/server";
import { resend, FROM } from "@/lib/email";
import { verifyLemonSqueezyWebhook } from "@/lib/lemon-squeezy";
import {
orderConfirmationEmail,
subscriptionWelcomeEmail,
trialStartedEmail,
paymentFailedEmail,
cancellationEmail,
expiredEmail,
pausedEmail,
resumedEmail,
licenseKeyEmail,
} from "@/lib/lemon-squeezy-emails";

const APP_URL = process.env.APP_URL!;

export async function POST(request: NextRequest) {
const body = await request.text();
const signature = request.headers.get("x-signature") ?? "";

if (!verifyLemonSqueezyWebhook(body, signature, process.env.LEMON_SQUEEZY_WEBHOOK_SECRET!)) {
  return NextResponse.json({ error: "Invalid signature" }, { status: 400 });
}

const event = JSON.parse(body);

try {
  await handleLemonSqueezyEvent(event);
} catch (error) {
  console.error(`LS webhook failed for ${event.meta.event_name}:`, error);
}

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

async function handleLemonSqueezyEvent(event: Record<string, unknown>) {
const meta = event.meta as { event_name: string };
const data = event.data as { id: string; attributes: Record<string, unknown> };
const attrs = data.attributes;
const email = attrs.user_email as string;
const userName = (attrs.user_name as string) ?? "there";

if (!email) return;

switch (meta.event_name) {
  case "order_created": {
    const firstItem = attrs.first_order_item as { product_name: string };
    const totalFormatted = attrs.total_formatted as string;
    const urls = attrs.urls as { receipt?: string } | undefined;

    await resend.emails.send({
      from: FROM, to: email,
      subject: `Order confirmed — ${totalFormatted}`,
      html: orderConfirmationEmail({
        userName, productName: firstItem.product_name,
        totalFormatted, receiptUrl: urls?.receipt, appUrl: APP_URL,
      }),
    });
    break;
  }

  case "subscription_created": {
    const productName = attrs.product_name as string;
    const variantName = attrs.variant_name as string;
    const status = attrs.status as string;

    if (status === "on_trial") {
      const trialEndsAt = attrs.trial_ends_at as string | null;
      await resend.emails.send({
        from: FROM, to: email,
        subject: "Your free trial has started!",
        html: trialStartedEmail({
          userName, productName,
          trialEndDate: trialEndsAt ? new Date(trialEndsAt).toLocaleDateString() : "soon",
          appUrl: APP_URL,
        }),
      });
    } else {
      await resend.emails.send({
        from: FROM, to: email,
        subject: `Welcome! Your ${productName} subscription is active`,
        html: subscriptionWelcomeEmail({
          userName, productName, variantName, appUrl: APP_URL,
        }),
      });
    }
    break;
  }

  case "subscription_cancelled": {
    const productName = attrs.product_name as string;
    const endsAt = attrs.ends_at as string | null;

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

  case "subscription_expired": {
    await resend.emails.send({
      from: FROM, to: email,
      subject: "Your subscription access has ended",
      html: expiredEmail({
        productName: attrs.product_name as string,
        pricingUrl: `${APP_URL}/pricing`,
      }),
    });
    break;
  }

  case "subscription_paused": {
    const urls = attrs.urls as { customer_portal?: string } | undefined;
    await resend.emails.send({
      from: FROM, to: email,
      subject: "Your subscription has been paused",
      html: pausedEmail({
        productName: attrs.product_name as string,
        resumeUrl: urls?.customer_portal ?? `${APP_URL}/billing`,
      }),
    });
    break;
  }

  case "subscription_resumed": {
    await resend.emails.send({
      from: FROM, to: email,
      subject: "Welcome back! Subscription resumed",
      html: resumedEmail({
        productName: attrs.product_name as string, appUrl: APP_URL,
      }),
    });
    break;
  }

  case "subscription_payment_failed": {
    const urls = attrs.urls as { update_payment_method?: string } | undefined;
    await resend.emails.send({
      from: FROM, to: email,
      subject: "Payment failed — action required",
      html: paymentFailedEmail({
        updatePaymentUrl: urls?.update_payment_method ?? `${APP_URL}/billing`,
        appUrl: APP_URL,
      }),
    });
    break;
  }

  case "license_key_created": {
    await resend.emails.send({
      from: FROM, to: email,
      subject: `Your license key for ${attrs.product_name ?? "your purchase"}`,
      html: licenseKeyEmail({
        productName: (attrs.product_name as string) ?? "your purchase",
        licenseKey: attrs.key as string,
        activationLimit: (attrs.activation_limit as number) ?? 1,
        expiresAt: attrs.expires_at ? new Date(attrs.expires_at as string).toLocaleDateString() : undefined,
      }),
    });
    break;
  }
}
}

import { NextRequest, NextResponse } from "next/server";
import { sgMail, FROM } from "@/lib/email";
import { verifyLemonSqueezyWebhook } from "@/lib/lemon-squeezy";
import {
orderConfirmationEmail,
subscriptionWelcomeEmail,
trialStartedEmail,
paymentFailedEmail,
cancellationEmail,
expiredEmail,
pausedEmail,
resumedEmail,
licenseKeyEmail,
} from "@/lib/lemon-squeezy-emails";

const APP_URL = process.env.APP_URL!;

export async function POST(request: NextRequest) {
const body = await request.text();
const signature = request.headers.get("x-signature") ?? "";

if (!verifyLemonSqueezyWebhook(body, signature, process.env.LEMON_SQUEEZY_WEBHOOK_SECRET!)) {
  return NextResponse.json({ error: "Invalid signature" }, { status: 400 });
}

const event = JSON.parse(body);

try {
  await handleLemonSqueezyEvent(event);
} catch (error) {
  console.error(`LS webhook failed for ${event.meta.event_name}:`, error);
}

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

async function handleLemonSqueezyEvent(event: Record<string, unknown>) {
const meta = event.meta as { event_name: string };
const data = event.data as { id: string; attributes: Record<string, unknown> };
const attrs = data.attributes;
const email = attrs.user_email as string;
const userName = (attrs.user_name as string) ?? "there";

if (!email) return;

switch (meta.event_name) {
  case "order_created": {
    const firstItem = attrs.first_order_item as { product_name: string };
    const totalFormatted = attrs.total_formatted as string;
    const urls = attrs.urls as { receipt?: string } | undefined;

    await sgMail.send({
      to: email, from: FROM,
      subject: `Order confirmed — ${totalFormatted}`,
      html: orderConfirmationEmail({
        userName, productName: firstItem.product_name,
        totalFormatted, receiptUrl: urls?.receipt, appUrl: APP_URL,
      }),
    });
    break;
  }

  case "subscription_created": {
    const productName = attrs.product_name as string;
    const variantName = attrs.variant_name as string;
    const status = attrs.status as string;

    if (status === "on_trial") {
      const trialEndsAt = attrs.trial_ends_at as string | null;
      await sgMail.send({
        to: email, from: FROM,
        subject: "Your free trial has started!",
        html: trialStartedEmail({
          userName, productName,
          trialEndDate: trialEndsAt ? new Date(trialEndsAt).toLocaleDateString() : "soon",
          appUrl: APP_URL,
        }),
      });
    } else {
      await sgMail.send({
        to: email, from: FROM,
        subject: `Welcome! Your ${productName} subscription is active`,
        html: subscriptionWelcomeEmail({
          userName, productName, variantName, appUrl: APP_URL,
        }),
      });
    }
    break;
  }

  case "subscription_cancelled": {
    const productName = attrs.product_name as string;
    const endsAt = attrs.ends_at as string | null;

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

  case "subscription_expired": {
    await sgMail.send({
      to: email, from: FROM,
      subject: "Your subscription access has ended",
      html: expiredEmail({
        productName: attrs.product_name as string,
        pricingUrl: `${APP_URL}/pricing`,
      }),
    });
    break;
  }

  case "subscription_paused": {
    const urls = attrs.urls as { customer_portal?: string } | undefined;
    await sgMail.send({
      to: email, from: FROM,
      subject: "Your subscription has been paused",
      html: pausedEmail({
        productName: attrs.product_name as string,
        resumeUrl: urls?.customer_portal ?? `${APP_URL}/billing`,
      }),
    });
    break;
  }

  case "subscription_resumed": {
    await sgMail.send({
      to: email, from: FROM,
      subject: "Welcome back! Subscription resumed",
      html: resumedEmail({
        productName: attrs.product_name as string, appUrl: APP_URL,
      }),
    });
    break;
  }

  case "subscription_payment_failed": {
    const urls = attrs.urls as { update_payment_method?: string } | undefined;
    await sgMail.send({
      to: email, from: FROM,
      subject: "Payment failed — action required",
      html: paymentFailedEmail({
        updatePaymentUrl: urls?.update_payment_method ?? `${APP_URL}/billing`,
        appUrl: APP_URL,
      }),
    });
    break;
  }

  case "license_key_created": {
    await sgMail.send({
      to: email, from: FROM,
      subject: `Your license key for ${attrs.product_name ?? "your purchase"}`,
      html: licenseKeyEmail({
        productName: (attrs.product_name as string) ?? "your purchase",
        licenseKey: attrs.key as string,
        activationLimit: (attrs.activation_limit as number) ?? 1,
        expiresAt: attrs.expires_at ? new Date(attrs.expires_at as string).toLocaleDateString() : undefined,
      }),
    });
    break;
  }
}
}