Antigravity × Stripe Connect: Complete Marketplace Monetization Guide— Multi-Vendor Payments, Revenue Split, and Production Design

npm install stripe @stripe/stripe-js next zod
npm install -D @types/stripe

# .env.local
STRIPE_SECRET_KEY=sk_live_YOUR_STRIPE_SECRET_KEY
STRIPE_WEBHOOK_SECRET=whsec_YOUR_WEBHOOK_SECRET
STRIPE_PLATFORM_PERCENTAGE=10
NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_live_YOUR_PUBLISHABLE_KEY

// lib/stripe.ts
import Stripe from "stripe";
 
export const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
  apiVersion: "2024-12-18.acacia",
  typescript: true,
});
 
export const PLATFORM_FEE_PERCENTAGE =
  parseInt(process.env.STRIPE_PLATFORM_PERCENTAGE || "10", 10);
 
export function calculateApplicationFee(amount: number): number {
  return Math.floor((amount * PLATFORM_FEE_PERCENTAGE) / 100);
}

// app/api/connect/create-account/route.ts
import { NextRequest, NextResponse } from "next/server";
import { stripe } from "@/lib/stripe";
import { z } from "zod";
 
const Schema = z.object({
  userId: z.string(),
  email: z.string().email(),
  country: z.string().length(2).default("US"),
  businessType: z.enum(["individual", "company"]).default("individual"),
});
 
export async function POST(req: NextRequest) {
  const parsed = Schema.safeParse(await req.json());
  if (!parsed.success)
    return NextResponse.json({ error: "Invalid request" }, { status: 400 });
 
  const { userId, email, country, businessType } = parsed.data;
 
  const account = await stripe.accounts.create({
    type: "express",
    email, country,
    business_type: businessType,
    capabilities: {
      card_payments: { requested: true },
      transfers: { requested: true },
    },
    settings: {
      payouts: {
        schedule: { interval: "weekly", weekly_anchor: "monday" },
      },
    },
    metadata: { platform_user_id: userId },
  });
 
  const accountLink = await stripe.accountLinks.create({
    account: account.id,
    refresh_url: `${process.env.NEXT_PUBLIC_APP_URL}/onboarding/refresh`,
    return_url: `${process.env.NEXT_PUBLIC_APP_URL}/onboarding/complete`,
    type: "account_onboarding",
  });
 
  return NextResponse.json({
    accountId: account.id,
    onboardingUrl: accountLink.url,
  });
}

// app/api/connect/check-status/route.ts
export async function GET(req: NextRequest) {
  const accountId = new URL(req.url).searchParams.get("accountId");
  if (!accountId)
    return NextResponse.json({ error: "accountId required" }, { status: 400 });
 
  const account = await stripe.accounts.retrieve(accountId);
  return NextResponse.json({
    isReady: account.details_submitted && account.charges_enabled &&
             account.payouts_enabled,
    chargesEnabled: account.charges_enabled,
    payoutsEnabled: account.payouts_enabled,
    requirements: account.requirements?.currently_due || [],
  });
}

// app/api/payments/create-intent/route.ts
const IntentSchema = z.object({
  amount: z.number().int().positive(),
  vendorAccountId: z.string(),
  orderId: z.string(),
  description: z.string(),
});
 
export async function POST(req: NextRequest) {
  const { amount, vendorAccountId, orderId, description } =
    IntentSchema.parse(await req.json());
 
  const applicationFeeAmount = calculateApplicationFee(amount);
 
  /**
   * Destination Charge pattern:
   * - Payment goes to the platform account
   * - application_fee_amount stays with the platform
   * - Remainder is automatically transferred to vendorAccountId
   * - No money transmitter license needed (Stripe handles it)
   */
  const paymentIntent = await stripe.paymentIntents.create({
    amount, currency: "usd",
    application_fee_amount: applicationFeeAmount,
    transfer_data: { destination: vendorAccountId },
    metadata: { order_id: orderId, vendor_account_id: vendorAccountId },
    description,
    automatic_payment_methods: { enabled: true },
  });
 
  return NextResponse.json({
    clientSecret: paymentIntent.client_secret,
    applicationFee: applicationFeeAmount,
    vendorAmount: amount - applicationFeeAmount,
  });
}

// app/api/stripe/webhook/route.ts
import { headers } from "next/headers";
 
export async function POST(req: Request) {
  const body = await req.text();
  const signature = headers().get("stripe-signature")!;
 
  let event: Stripe.Event;
  try {
    event = stripe.webhooks.constructEvent(
      body, signature, process.env.STRIPE_WEBHOOK_SECRET!);
  } catch {
    return NextResponse.json({ error: "Signature failed" }, { status: 400 });
  }
 
  switch (event.type) {
    case "payment_intent.succeeded": {
      const intent = event.data.object as Stripe.PaymentIntent;
      await updateOrderStatus(intent.metadata.order_id, "paid");
      await notifyVendor(intent.metadata.vendor_account_id, {
        amount: intent.amount - (intent.application_fee_amount ?? 0),
        orderId: intent.metadata.order_id,
      });
      break;
    }
    case "payment_intent.payment_failed": {
      const intent = event.data.object as Stripe.PaymentIntent;
      await updateOrderStatus(intent.metadata.order_id, "payment_failed");
      break;
    }
    case "account.updated": {
      const account = event.data.object as Stripe.Account;
      await syncVendorAccountStatus(account.id, {
        chargesEnabled: account.charges_enabled,
        payoutsEnabled: account.payouts_enabled,
      });
      break;
    }
  }
 
  return NextResponse.json({ received: true });
}

// app/api/vendor/earnings/route.ts
export async function GET(req: NextRequest) {
  const { searchParams } = new URL(req.url);
  const accountId = searchParams.get("accountId");
  const period = parseInt(searchParams.get("period") || "30", 10);
 
  const since = Math.floor(Date.now() / 1000 - period * 86400);
 
  const [charges, balance] = await Promise.all([
    stripe.charges.list(
      { created: { gte: since }, limit: 100 },
      { stripeAccount: accountId! }
    ),
    stripe.balance.retrieve({}, { stripeAccount: accountId! }),
  ]);
 
  const totalEarned = charges.data
    .filter(c => c.status === "succeeded")
    .reduce((sum, c) => sum + c.amount, 0);
 
  return NextResponse.json({
    totalEarned,
    availableBalance: balance.available.find(b => b.currency === "usd")?.amount ?? 0,
    pendingBalance: balance.pending.find(b => b.currency === "usd")?.amount ?? 0,
    chargeCount: charges.data.length,
  });
}