Stripe Connect for
Platforms & Marketplaces
Split Payments in 15 Minutes

npm install stripe

STRIPE_SECRET_KEY=sk_test_...
NEXT_PUBLIC_APP_URL=http://localhost:3000

import Stripe from "stripe";

export const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
  apiVersion: "2025-12-18.acacia",
  typescript: true,
});

import { NextResponse } from "next/server";
import { stripe } from "@/lib/stripe";

export async function POST(req: Request) {
  const { email } = await req.json();

  // 1. Create the Express connected account
  const account = await stripe.accounts.create({
    type: "express",
    email,
    capabilities: {
      card_payments: { requested: true },
      transfers: { requested: true },
    },
  });

  // 2. Create an onboarding link
  const accountLink = await stripe.accountLinks.create({
    account: account.id,
    refresh_url: `${process.env.NEXT_PUBLIC_APP_URL}/seller/onboarding?refresh=true`,
    return_url: `${process.env.NEXT_PUBLIC_APP_URL}/seller/dashboard`,
    type: "account_onboarding",
  });

  // Save account.id to your database, linked to this seller
  // e.g., await db.seller.update({ where: { email }, data: { stripeAccountId: account.id } });

  return NextResponse.json({
    accountId: account.id,
    onboardingUrl: accountLink.url,
  });
}

"use client";

import { useState } from "react";

export default function SellerOnboarding() {
  const [loading, setLoading] = useState(false);

  async function handleOnboard() {
    setLoading(true);
    const res = await fetch("/api/connect/create-account", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ email: "seller@example.com" }), // from your auth
    });
    const { onboardingUrl } = await res.json();
    window.location.href = onboardingUrl;
  }

  return (
    <button onClick={handleOnboard} disabled={loading}>
      {loading ? "Setting up..." : "Set up payouts"}
    </button>
  );
}

import { NextResponse } from "next/server";
import { stripe } from "@/lib/stripe";

export async function GET(req: Request) {
  const { searchParams } = new URL(req.url);
  const accountId = searchParams.get("accountId");

  if (!accountId) {
    return NextResponse.json({ error: "Missing accountId" }, { status: 400 });
  }

  const account = await stripe.accounts.retrieve(accountId);

  return NextResponse.json({
    chargesEnabled: account.charges_enabled,
    payoutsEnabled: account.payouts_enabled,
    detailsSubmitted: account.details_submitted,
    // If charges_enabled is true, this seller can receive payments
  });
}

import { NextResponse } from "next/server";
import { stripe } from "@/lib/stripe";

export async function POST(req: Request) {
  const { productName, priceInCents, sellerStripeAccountId } = await req.json();

  const session = await stripe.checkout.sessions.create({
    mode: "payment",
    line_items: [
      {
        price_data: {
          currency: "usd",
          product_data: { name: productName },
          unit_amount: priceInCents,
        },
        quantity: 1,
      },
    ],
    payment_intent_data: {
      // This is the magic line — your platform fee
      application_fee_amount: Math.round(priceInCents * 0.1), // 10% platform fee
      transfer_data: {
        destination: sellerStripeAccountId, // acct_xxxxx
      },
    },
    success_url: `${process.env.NEXT_PUBLIC_APP_URL}/purchase/success?session_id={CHECKOUT_SESSION_ID}`,
    cancel_url: `${process.env.NEXT_PUBLIC_APP_URL}/purchase/cancel`,
  });

  return NextResponse.json({ checkoutUrl: session.url });
}

"use client";

export function BuyButton({
  productName,
  priceInCents,
  sellerStripeAccountId,
}: {
  productName: string;
  priceInCents: number;
  sellerStripeAccountId: string;
}) {
  async function handleBuy() {
    const res = await fetch("/api/connect/checkout", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ productName, priceInCents, sellerStripeAccountId }),
    });
    const { checkoutUrl } = await res.json();
    window.location.href = checkoutUrl;
  }

  return (
    <button onClick={handleBuy}>
      Buy for ${(priceInCents / 100).toFixed(2)}
    </button>
  );
}

import { NextResponse } from "next/server";
import { stripe } from "@/lib/stripe";

export async function POST(req: Request) {
  const { sellerStripeAccountId } = await req.json();

  // Create a login link to the Express dashboard
  // Sellers can view their balance, payouts, and tax info here
  const loginLink = await stripe.accounts.createLoginLink(
    sellerStripeAccountId
  );

  return NextResponse.json({ dashboardUrl: loginLink.url });
}

import { NextResponse } from "next/server";
import { stripe } from "@/lib/stripe";

export async function GET(req: Request) {
  const { searchParams } = new URL(req.url);
  const accountId = searchParams.get("accountId")!;

  const balance = await stripe.balance.retrieve({
    stripeAccount: accountId,
  });

  return NextResponse.json({
    available: balance.available,  // funds ready to pay out
    pending: balance.pending,      // funds not yet available
  });
}

import { NextResponse } from "next/server";
import { stripe } from "@/lib/stripe";

const endpointSecret = process.env.STRIPE_CONNECT_WEBHOOK_SECRET!;

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

  let event;
  try {
    event = stripe.webhooks.constructEvent(body, sig, endpointSecret);
  } catch (err) {
    console.error("Webhook signature verification failed");
    return NextResponse.json({ error: "Invalid signature" }, { status: 400 });
  }

  switch (event.type) {
    case "account.updated": {
      // A connected account's status changed
      const account = event.data.object;
      console.log(`Account ${account.id}: charges_enabled=${account.charges_enabled}`);
      // Update your database:
      // await db.seller.update({
      //   where: { stripeAccountId: account.id },
      //   data: { chargesEnabled: account.charges_enabled },
      // });
      break;
    }

    case "checkout.session.completed": {
      // A payment was completed through your platform
      const session = event.data.object;
      console.log(`Payment completed: ${session.id}`);
      // Fulfill the order, send confirmation email, etc.
      break;
    }

    case "transfer.created": {
      // Money was transferred to a connected account
      const transfer = event.data.object;
      console.log(`Transfer ${transfer.id}: ${transfer.amount} to ${transfer.destination}`);
      break;
    }

    case "payout.paid": {
      // A payout to a seller's bank account succeeded
      const payout = event.data.object;
      console.log(`Payout ${payout.id} paid: ${payout.amount}`);
      break;
    }

    case "payout.failed": {
      // A payout to a seller's bank failed
      const payout = event.data.object;
      console.log(`Payout ${payout.id} failed: ${payout.failure_message}`);
      // Notify the seller to update their bank details
      break;
    }

    default:
      console.log(`Unhandled event: ${event.type}`);
  }

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