Multi-Provider Payments: Stripe, Polar, and Lemonsqueezy in One Boilerplate

$# Create products in Stripe Dashboard or via API
$# Each price has a unique price_id like: price_1234567890

$# .env.local
$PAYMENT_PROVIDER=stripe

$# API Keys
$STRIPE_SECRET_KEY=sk_test_...  # Use sk_live_... for production
$STRIPE_PUBLISHABLE_KEY=pk_test_...

$# Webhook (generate in Stripe Dashboard → Webhooks)
$STRIPE_WEBHOOK_SECRET=whsec_...

$# Price IDs from your Stripe products
$STRIPE_PRICE_MONTHLY=price_...
$STRIPE_PRICE_YEARLY=price_...

$# .env.local
$PAYMENT_PROVIDER=polar

$# API Key (from Settings → Developers → Access Tokens)
$POLAR_ACCESS_TOKEN=polar_at_...

$# Organization ID
$POLAR_ORGANIZATION_ID=...

$# Webhook Secret (from Settings → Webhooks)
$POLAR_WEBHOOK_SECRET=...

$# Product IDs
$POLAR_PRODUCT_MONTHLY=...
$POLAR_PRODUCT_YEARLY=...

$# .env.local
$PAYMENT_PROVIDER=lemonsqueezy

$# API Key
$LEMONSQUEEZY_API_KEY=...

$# Store ID
$LEMONSQUEEZY_STORE_ID=...

$# Webhook Secret (from Settings → Webhooks)
$LEMONSQUEEZY_WEBHOOK_SECRET=...

$# Variant IDs (Lemonsqueezy uses variants for pricing)
$LEMONSQUEEZY_VARIANT_MONTHLY=...
$LEMONSQUEEZY_VARIANT_YEARLY=...

// src/components/billing/checkout-button.tsx
'use client';

import { Button } from '@/components/ui/button';
import { useState } from 'react';

interface CheckoutButtonProps {
  priceId: string;
  label?: string;
}

export function CheckoutButton({ priceId, label = '> SUBSCRIBE' }: CheckoutButtonProps) {
  const [loading, setLoading] = useState(false);

  const handleCheckout = async () => {
    setLoading(true);

    try {
      const response = await fetch('/api/checkout', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ priceId }),
      });

      const { url, error } = await response.json();

      if (error) {
        console.error('Checkout error:', error);
        return;
      }

      // Redirect to provider's checkout page
      window.location.href = url;
    } catch (error) {
      console.error('Checkout failed:', error);
    } finally {
      setLoading(false);
    }
  };

  return (
    <Button onClick={handleCheckout} disabled={loading}>
      {loading ? 'LOADING...' : label}
    </Button>
  );
}

// src/app/api/checkout/route.ts
import { auth } from '@/lib/auth';
import { env } from '@/lib/env';
import { NextResponse } from 'next/server';

export async function POST(request: Request) {
  const session = await auth();

  if (!session?.user) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
  }

  const { priceId } = await request.json();
  const provider = env.PAYMENT_PROVIDER;

  // Route to provider-specific handler
  switch (provider) {
    case 'stripe':
      return handleStripeCheckout(session.user, priceId);
    case 'polar':
      return handlePolarCheckout(session.user, priceId);
    case 'lemonsqueezy':
      return handleLemonsqueezyCheckout(session.user, priceId);
    default:
      return NextResponse.json(
        { error: 'Invalid payment provider' },
        { status: 500 }
      );
  }
}

// src/lib/payments/stripe.ts
import Stripe from 'stripe';
import { env } from '@/lib/env';

const stripe = new Stripe(env.STRIPE_SECRET_KEY);

export async function createStripeCheckout(
  user: { id: string; email: string },
  priceId: string
) {
  // Find or create customer
  const customers = await stripe.customers.list({
    email: user.email,
    limit: 1,
  });

  let customerId = customers.data[0]?.id;

  if (!customerId) {
    const customer = await stripe.customers.create({
      email: user.email,
      metadata: { userId: user.id },
    });
    customerId = customer.id;
  }

  // Create checkout session
  const session = await stripe.checkout.sessions.create({
    customer: customerId,
    mode: 'subscription',
    line_items: [{ price: priceId, quantity: 1 }],
    success_url: `${env.NEXT_PUBLIC_APP_URL}/billing?success=true`,
    cancel_url: `${env.NEXT_PUBLIC_APP_URL}/pricing?canceled=true`,
    metadata: { userId: user.id },
  });

  return { url: session.url };
}

// src/app/api/stripe/webhook/route.ts
import Stripe from 'stripe';
import { prisma } from '@/lib/prisma';
import { env } from '@/lib/env';

const stripe = new Stripe(env.STRIPE_SECRET_KEY);

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

  let event: Stripe.Event;

  try {
    event = stripe.webhooks.constructEvent(
      body,
      signature,
      env.STRIPE_WEBHOOK_SECRET
    );
  } catch (error) {
    console.error('Webhook signature verification failed:', error);
    return new Response('Webhook Error', { status: 400 });
  }

  switch (event.type) {
    case 'checkout.session.completed': {
      const session = event.data.object as Stripe.Checkout.Session;
      await handleCheckoutComplete(session);
      break;
    }

    case 'customer.subscription.updated': {
      const subscription = event.data.object as Stripe.Subscription;
      await updateSubscription(subscription);
      break;
    }

    case 'customer.subscription.deleted': {
      const subscription = event.data.object as Stripe.Subscription;
      await cancelSubscription(subscription.id);
      break;
    }

    case 'invoice.payment_failed': {
      const invoice = event.data.object as Stripe.Invoice;
      await handlePaymentFailed(invoice);
      break;
    }
  }

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

async function handleCheckoutComplete(session: Stripe.Checkout.Session) {
  const userId = session.metadata?.userId;
  if (!userId) return;

  const subscription = await stripe.subscriptions.retrieve(
    session.subscription as string
  );

  await prisma.subscription.create({
    data: {
      id: subscription.id,
      userId,
      provider: 'stripe',
      providerCustomerId: session.customer as string,
      status: subscription.status,
      priceId: subscription.items.data[0].price.id,
      currentPeriodEnd: new Date(subscription.current_period_end * 1000),
    },
  });
}

async function updateSubscription(subscription: Stripe.Subscription) {
  await prisma.subscription.update({
    where: { id: subscription.id },
    data: {
      status: subscription.status,
      priceId: subscription.items.data[0].price.id,
      currentPeriodEnd: new Date(subscription.current_period_end * 1000),
    },
  });
}

async function cancelSubscription(subscriptionId: string) {
  await prisma.subscription.update({
    where: { id: subscriptionId },
    data: { status: 'canceled' },
  });
}

// prisma/schema.prisma
model Subscription {
  id                 String   @id
  userId             String
  provider           String   // 'stripe', 'polar', 'lemonsqueezy'
  providerCustomerId String
  status             String   // 'active', 'canceled', 'past_due', etc.
  priceId            String   // Provider-specific price/variant ID
  currentPeriodEnd   DateTime
  cancelAtPeriodEnd  Boolean  @default(false)
  createdAt          DateTime @default(now())
  updatedAt          DateTime @updatedAt

  user User @relation(fields: [userId], references: [id])

  @@index([userId])
  @@index([provider, providerCustomerId])
}

// src/lib/subscription.ts
import { prisma } from '@/lib/prisma';

export async function getUserSubscription(userId: string) {
  const subscription = await prisma.subscription.findFirst({
    where: {
      userId,
      status: { in: ['active', 'trialing'] },
    },
  });

  return subscription;
}

export async function isUserSubscribed(userId: string): Promise<boolean> {
  const subscription = await getUserSubscription(userId);
  return !!subscription;
}

export async function getSubscriptionTier(userId: string): Promise<string> {
  const subscription = await getUserSubscription(userId);

  if (!subscription) return 'free';

  // Map price IDs to tier names
  const tierMap: Record<string, string> = {
    [process.env.STRIPE_PRICE_MONTHLY!]: 'pro',
    [process.env.STRIPE_PRICE_YEARLY!]: 'pro',
    // Add other provider mappings
  };

  return tierMap[subscription.priceId] || 'pro';
}

// src/components/billing/feature-gate.tsx
'use client';

import { useSubscription } from '@/hooks/use-subscription';
import { Card } from '@/components/ui/card';
import { Button } from '@/components/ui/button';
import Link from 'next/link';

interface FeatureGateProps {
  children: React.ReactNode;
  requiredTier: string;
}

export function FeatureGate({ children, requiredTier }: FeatureGateProps) {
  const { tier, loading } = useSubscription();

  if (loading) {
    return <div className="animate-pulse">Loading...</div>;
  }

  const tierHierarchy = ['free', 'pro', 'enterprise'];
  const userTierIndex = tierHierarchy.indexOf(tier);
  const requiredTierIndex = tierHierarchy.indexOf(requiredTier);

  if (userTierIndex < requiredTierIndex) {
    return (
      <Card className="border border-border p-6 text-center">
        <p className="font-mono text-sm text-muted-foreground mb-4">
          This feature requires {requiredTier.toUpperCase()} plan
        </p>
        <Link href="/pricing">
          <Button>> UPGRADE</Button>
        </Link>
      </Card>
    );
  }

  return <>{children}</>;
}

// src/app/api/billing/portal/route.ts
import Stripe from 'stripe';
import { auth } from '@/lib/auth';
import { prisma } from '@/lib/prisma';
import { env } from '@/lib/env';

const stripe = new Stripe(env.STRIPE_SECRET_KEY);

export async function POST() {
  const session = await auth();
  if (!session?.user) {
    return Response.json({ error: 'Unauthorized' }, { status: 401 });
  }

  const subscription = await prisma.subscription.findFirst({
    where: { userId: session.user.id, provider: 'stripe' },
  });

  if (!subscription) {
    return Response.json({ error: 'No subscription found' }, { status: 404 });
  }

  const portalSession = await stripe.billingPortal.sessions.create({
    customer: subscription.providerCustomerId,
    return_url: `${env.NEXT_PUBLIC_APP_URL}/billing`,
  });

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

$# Install Stripe CLI
$brew install stripe/stripe-cli/stripe

$# Login
$stripe login

$# Forward webhooks
$stripe listen --forward-to localhost:3000/api/stripe/webhook

$# Use ngrok or similar for local webhook testing
$ngrok http 3000

$# Add ngrok URL to Polar webhook settings