LemonSqueezy vs Stripe vs Polar: Billing for Your Next.js SaaS in 2026

Billing is one of the highest-stakes decisions in a SaaS. Get it wrong and you're either overpaying in fees, drowning in tax compliance, or locked into a checkout experience that kills conversions. The three dominant options for Next.js SaaS in 2026 are Stripe, LemonSqueezy, and Polar—and they solve different problems.

This is a decision guide, not a marketing comparison. It covers fees, tax handling, subscription flexibility, developer ergonomics, and where each breaks down.

The Short Version

• Stripe: Maximum control, maximum complexity. Use it if you have usage-based billing, complex pricing tiers, or enterprise contracts.
• LemonSqueezy: Merchant of record (tax handled for you), simple flat pricing, fast to ship. Use it for digital products and early-stage SaaS.
• Polar: Open-source-first, usage-based billing built-in, developer-focused. Use it if your customers are developers or you want transparent pricing.

What "Merchant of Record" Actually Means

Before comparing features, understand the merchant-of-record (MoR) distinction—it changes everything about tax liability.

Merchant of record means LemonSqueezy is legally the seller. They collect, remit, and handle disputes for sales tax, VAT, and GST across all jurisdictions. For a solo founder or small team, this is worth money—tax compliance across 50+ US states and the EU is a real operational burden.

With Stripe and Polar, you own tax collection and remittance. Stripe Tax can automate the calculation and filing, but it costs extra and you're still the merchant.

Fees

Stripe

• Transaction fee: 2.9% + $0.30 per transaction (US cards)
• International cards: +1.5%
• Stripe Tax: +0.5% per transaction
• Stripe Billing (for subscriptions): included but metered usage add-ons cost extra
• Stripe Radar (fraud): included at basic level

At $10K MRR, you're paying roughly $350–$500/month in Stripe fees depending on card mix and whether you use Tax.

LemonSqueezy

• Transaction fee: 5% + $0.50 per transaction
• No additional tax fee (included)
• No separate fraud product needed (MoR covers it)

At $10K MRR, you're paying roughly $550/month—more than Stripe. But that includes tax compliance.

Break-even math: If hiring a tax professional or accountant costs more than ~$200/month (it often does for EU VAT + US sales tax), LemonSqueezy's fee premium pays for itself.

Polar

• Transaction fee: 5% (no per-transaction flat fee for subscriptions)
• Uses Stripe under the hood for payment processing
• Usage-based billing is a first-class feature (not an add-on)

For low-ticket, high-volume products, Polar's lack of per-transaction flat fee is better than LemonSqueezy. For high-ticket items, the 5% rate matters more.

Subscription and Pricing Model Support

Stripe

Stripe has the most flexible pricing primitives in the industry:

• Flat rate, tiered, volume, package pricing
• Metered/usage-based billing (log usage events, bill at period end)
• Per-seat billing
• Trials, coupons, proration
• Multiple currencies natively
• Customer portal (self-serve upgrades/downgrades)

If you need complex pricing—usage spikes, seat expansions, annual + monthly tiers—Stripe is the only option that handles all of it without workarounds.

// Stripe: create a metered subscription
const subscription = await stripe.subscriptions.create({
  customer: customerId,
  items: [
    {
      price: "price_metered_api_calls",
      // usage billed at end of period
    },
  ],
  trial_period_days: 14,
});

LemonSqueezy

LemonSqueezy supports:

• Flat rate subscriptions
• Tiered plans (manual, not automatic upgrade/downgrade)
• One-time purchases
• Product bundles
• License keys (good for desktop apps)

What it does not support well: metered billing, per-seat pricing, complex proration logic. If your pricing is "pay per API call" or "pay per active seat," LemonSqueezy will require significant workarounds or won't work at all.

Polar

Polar's billing model is designed for developer tools:

• Usage-based billing is built-in (not bolted on)
• Tier meters: define credits/units and customers buy bundles
• Free tier + paid tier in one product definition
• GitHub-integrated benefits (repo access, sponsorship tiers)

// Polar: create a usage-based product
const product = await polar.products.create({
  name: "API Credits",
  prices: [
    {
      type: "recurring",
      recurringInterval: "month",
      amountType: "custom",
      minimumAmount: 500, // $5 minimum
      presetAmount: 2000, // $20 preset
    },
  ],
});

Checkout and Customer Experience

Stripe

Stripe Checkout (hosted page) handles the heavy lifting. The UI is conversion-optimized and handles localization, Apple Pay, Google Pay, and 3DS automatically.

For custom checkout, Stripe Elements lets you embed a card form. Stripe's checkout has the highest trust signal of the three—customers recognize it.

LemonSqueezy

LemonSqueezy's overlay checkout works well for simple products. The UX is clean. However:

• Less customizable than Stripe Elements
• Overlay modal pattern can feel jarring on some UIs
• You have less control over the purchase flow

For early-stage products where you want something that works out of the box, this is fine. For established products with specific brand requirements, Stripe gives you more.

Polar

Polar has a checkout component designed for developer-facing products. It's clean and integrates well with GitHub sponsorship flows. For consumer-facing SaaS, it may feel more bare than Stripe Checkout.

Webhooks and Developer Ergonomics

All three use webhooks to notify your server of billing events. The patterns are similar, but the reliability and debugging experience differ.

Stripe

// Stripe webhook handler (Next.js App Router)
import Stripe from "stripe";
import { headers } from "next/headers";

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

export async function POST(req: Request) {
  const body = await req.text();
  const sig = (await headers()).get("stripe-signature")!;

  let event: Stripe.Event;
  try {
    event = stripe.webhooks.constructEvent(
      body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET!
    );
  } catch (err) {
    return new Response("Webhook signature verification failed", { status: 400 });
  }

  switch (event.type) {
    case "customer.subscription.updated":
      await handleSubscriptionUpdate(event.data.object);
      break;
    case "invoice.payment_failed":
      await handlePaymentFailed(event.data.object);
      break;
  }

  return new Response(null, { status: 200 });
}

Stripe's webhook dashboard has retry logic, event logs, and the ability to replay events. The stripe listen CLI for local development is excellent.

LemonSqueezy

// LemonSqueezy webhook handler
import crypto from "crypto";

export async function POST(req: Request) {
  const body = await req.text();
  const sig = req.headers.get("x-signature")!;

  const hash = crypto
    .createHmac("sha256", process.env.LEMON_SQUEEZY_WEBHOOK_SECRET!)
    .update(body)
    .digest("hex");

  if (hash !== sig) {
    return new Response("Invalid signature", { status: 401 });
  }

  const payload = JSON.parse(body);
  const eventName = payload.meta.event_name;

  switch (eventName) {
    case "subscription_updated":
      await handleSubscriptionUpdate(payload.data);
      break;
    case "subscription_payment_failed":
      await handlePaymentFailed(payload.data);
      break;
  }

  return new Response(null, { status: 200 });
}

LemonSqueezy's webhook event names are less standardized than Stripe's and the event payload structure is less consistent. The webhook retry/replay tooling is less mature.

Polar

Polar uses a similar webhook pattern with HMAC signature verification. The event payload structure is well-typed if you use the Polar SDK. Replay and debugging tooling is still maturing.

Customer Portal (Self-Serve Billing)

All three have a hosted customer portal that handles common billing actions without you building UI. For most SaaS, the default portal is sufficient.

Which to Use and When

Migrating Between Providers

Migrating billing providers after you have active subscribers is painful. Before committing:

• Export your subscriber list: make sure you can export customer and subscription data in a portable format.
• Stripe: full data export, API access to all historical data.
• LemonSqueezy: export available, but migrating active Stripe subscriptions into LemonSqueezy requires customers to re-subscribe.
• Polar: uses Stripe under the hood, so migration to/from Stripe is closer to a configuration change.

ShipAI's Approach

ShipAI ships with Stripe pre-integrated—webhook handlers, customer portal redirect, plan-based feature gating, and usage-based billing hooks are all wired up out of the box.

The choice of Stripe was driven by metered billing requirements (AI SaaS products that bill per API call or per token need usage-based billing), maximum pricing flexibility for the boilerplate's users, and the most mature webhook tooling.

LemonSqueezy and Polar integrations can be swapped in. The billing abstraction layer is isolated to src/lib/billing/ so switching providers doesn't require touching feature code.

Summary

Next Steps

• Stripe Webhooks for SaaS: Reliability Patterns — webhook handler reliability, retry design, and billing drift prevention.
• How to Build an AI SaaS with Next.js — billing decisions in the context of the full AI SaaS stack.
• ShipAI Production Playbook — operational baseline including billing event handling in production.