Stripe Checkout, for SaaS founders

If you have ever tried to build a checkout from scratch, you already know that “take a credit card” is one sentence and roughly four months of work. PCI scoping, 3D Secure flows, BIN routing, retries on soft declines, currency formatting, EU SCA, Apple Pay tokenization — the list does not end. Stripe Checkout exists so a solo founder can outsource all of that and ship a working paywall in an afternoon.

A concrete flow: from button click to webhook

Here is what actually happens when a customer pays through Stripe Checkout. Read this once and the rest of the page will make sense.

1. Customer clicks “Subscribe” on your marketing page.
2. Your server calls Stripe’s API to create a Checkout Session — this returns a unique URL like checkout.stripe.com/c/pay/cs_test_a1b2….
3. You redirect the customer to that URL. Stripe shows their hosted payment page.
4. Customer enters card details on Stripe’s domain. You never touch the card number.
5. Stripe processes payment, runs 3D Secure if needed, and creates the customer + subscription objects in your Stripe account.
6. Stripe redirects the customer back to your success_url, which can include the session ID as a query param.
7. Stripe fires a checkout.session.completed webhook to your backend. This — not the redirect — is when you grant access.

The order matters. Founders who grant access on the success-URL redirect get burned by users who close the tab before the redirect, or who screenshot a fake success URL. The webhook is the source of truth.

Stripe Checkout vs Stripe Elements vs Payment Links

Stripe ships three different ways to take money. They look similar from the outside but differ a lot in what you have to build.

For 90 percent of solo founders, Stripe Checkout is the right answer. Payment Links don’t scale to subscription logic that needs metadata; Elements buys you UI control you do not need at $0–$10k MRR. Start with Checkout and migrate to Elements only when a customer specifically tells you the redirect kills their conversion rate.

What you actually need to set up

The end-to-end build is five steps. None of them are hard, but each has a footgun that a beginner will trip on.

Step 1 — Create a product and price in the Stripe dashboard

Inside Stripe, create a Product (e.g. “Pro plan”) and add a recurring Price ($29/mo). Save the price ID — it looks like price_1OabcdEFG…. You will reference this from your code. You can do this entirely in the dashboard; no API call needed.

Step 2 — Create a Checkout Session from your server

When the user clicks subscribe, your backend hits Stripe’s API and returns the session URL.

// Node.js / Next.js API route
import Stripe from 'stripe';
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

export async function POST(req) {
  const { userId } = await req.json();

  const session = await stripe.checkout.sessions.create({
    mode: 'subscription',
    line_items: [{ price: 'price_1OabcdEFG', quantity: 1 }],
    success_url: 'https://yourapp.com/success?session_id={CHECKOUT_SESSION_ID}',
    cancel_url: 'https://yourapp.com/pricing',
    client_reference_id: userId,        // your internal user ID
    metadata: { userId },               // duplicated for webhook reliability
  });

  return Response.json({ url: session.url });
}

Two things people forget here: pass client_reference_id so you can map the session back to your user, and put the same value in metadata as a belt-and-suspenders check.

Step 3 — Redirect the user

On the client, after the API call returns, just window.location = data.url. That is the entire client side. No Stripe.js needed for Checkout (unlike Elements).

Step 4 — Listen for the webhook

This is the step every beginner skips and regrets. You need an HTTP endpoint that Stripe will POST to when the session completes.

// Webhook handler — verify signature, then act
import Stripe from 'stripe';
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

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

  let event;
  try {
    event = stripe.webhooks.constructEvent(
      body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET
    );
  } catch (err) {
    return new Response('Bad signature', { status: 400 });
  }

  if (event.type === 'checkout.session.completed') {
    const session = event.data.object;
    const userId = session.client_reference_id;
    await db.users.update(userId, {
      stripeCustomerId: session.customer,
      subscriptionStatus: 'active',
    });
  }

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

Set this URL in Stripe’s dashboard under Developers → Webhooks, subscribe to the checkout.session.completed event, and copy the signing secret into your env vars. If you’ve never built one of these before, our walkthrough on building an invoicing SaaS with Claude uses a similar pattern end-to-end.

Step 5 — Handle subscription lifecycle events

checkout.session.completed fires once. To track ongoing subscription state — renewals, failed payments, cancellations — you also need to listen for customer.subscription.updated, customer.subscription.deleted, and invoice.payment_failed. Most founders skip this on day one and patch it after the first churn event surprises them.

When to use Stripe Checkout vs Lemon Squeezy

The honest answer: it depends on whether you want to be the Merchant of Record. Stripe Checkout makes you the merchant. Every EU VAT registration, every state sales tax filing, every chargeback dispute — that is your problem. The trade-off is lower fees (around 2.9% + 30¢ vs Lemon Squeezy’s 5% + 50¢) and a dramatically more capable platform.

Lemon Squeezy is a Merchant of Record, which means they handle global tax compliance, chargeback risk, and invoicing on your behalf in exchange for the higher take rate. For a solo founder selling globally with under $50k ARR, the math often tips toward Lemon Squeezy — the time you do not spend on tax is more valuable than 2 percent of your revenue. We compare the two head-to-head in our Lemon Squeezy vs Stripe breakdown, and the broader landscape lives on our best payment processor for SaaS page.

Pricing, fees, and what counts as "available"

Stripe Checkout is included free with any Stripe account — you only pay the standard processing fee (2.9% + 30¢ for US cards as of May 2026, with international cards adding 1.5%). There is no per-session fee, no monthly minimum. The full pricing breakdown lives at stripe.com/pricing, and the Checkout-specific docs are at stripe.com/docs/payments/checkout.

One detail that catches founders: availability. Stripe Checkout is supported in 46 countries. If you live somewhere Stripe has not launched (parts of Latin America, most of Africa), your only options are Stripe Atlas (US incorporation), Paddle, or Lemon Squeezy.

Frequently asked questions

The takeaway

Stripe Checkout is the “just take my money” option for solo founders. It is not the most flexible — that is Elements — and it is not the cheapest globally — that is rolling your own with a Merchant of Record like Lemon Squeezy. But it is the fastest to ship, the safest from a PCI standpoint, and the easiest to extend later. Build it, get to first revenue, and revisit the decision at $10k MRR when the trade-offs change.