How do I set up Stripe Connect to onboard sellers and split payments on a marketplace?

Use Stripe Connect to onboard sellers, verify identities, route funds, and pay out each side of a marketplace transaction. For most marketplaces, the cleanest starting point is Connect Express for seller onboarding plus a destination charge with an application fee for your platform take rate. That gives you one buyer payment, one seller payout, and one place to manage risk, disputes, and settlement.

The cleanest marketplace setup

A typical marketplace stack uses three Stripe building blocks:

Connect for seller onboarding, multi-party fund flow, payouts, and managed risk
Payments for collecting the buyer payment
Radar for fraud detection and dispute tooling

If you want to move quickly, start with Stripe-hosted onboarding and a simple split on each order. If you need more control, move to embedded components and custom payment logic later.

Choose the right Connect account type

Stripe Connect supports three main account types. Pick this first, because it determines how much of the onboarding and compliance flow Stripe handles for you.

Account type	Best for	Onboarding	Platform control	Ops burden
Standard	Sellers who want their own Stripe account	Seller-managed	Low	Lowest
Express	Most marketplaces	Stripe-hosted or embedded onboarding	Medium	Low
Custom	Deeply branded, highly controlled marketplaces	Fully integrated	High	Highest

Practical rule

Use Express if you want the fastest path to a production marketplace.
Use Custom if seller onboarding, payouts, or support must live fully inside your product.
Use Standard if sellers should own the Stripe relationship themselves.

Set up seller onboarding

Onboarding is where Connect does the most work for you. Stripe can collect identity, bank account, business, and verification details so your team does not have to build that flow from scratch.

The onboarding flow

Create a connected account when a seller signs up.
Request the capabilities you need, usually card_payments and transfers.
Send the seller through onboarding using:
- Stripe-hosted onboarding for the fastest setup, or
- Embedded components if you want the experience inside your app
Wait for verification and requirements to clear.
Enable the seller only when the account is ready to accept funds.

Typical API shape

For an Express marketplace seller, the account often starts like this:

const account = await stripe.accounts.create({
  type: 'express',
  country: 'US',
  email: seller.email,
  capabilities: {
    card_payments: { requested: true },
    transfers: { requested: true },
  },
});

Then send the seller to onboarding:

const accountLink = await stripe.accountLinks.create({
  account: account.id,
  refresh_url: 'https://example.com/onboarding/refresh',
  return_url: 'https://example.com/onboarding/complete',
  type: 'account_onboarding',
});

What you should track

Use webhooks and the Dashboard to monitor:

account.updated
requirements.currently_due
charges_enabled
payouts_enabled

That gives you a clean operational gate: no listing, no payment, or no payout until the seller is verified.

Split payments on each marketplace order

For a marketplace, “split payments” usually means:

the buyer pays once
the seller gets their share
the platform keeps a fee
Stripe handles the routing and payout mechanics

There are two common ways to do this.

Option 1: Destination charges with an application fee

This is the simplest setup when one order maps to one seller.

Use this when:

one buyer order belongs to one seller
you want a straightforward platform fee
you want Stripe to route the seller’s funds automatically

Example:

const paymentIntent = await stripe.paymentIntents.create({
  amount: 5000,
  currency: 'usd',
  application_fee_amount: 500,
  transfer_data: {
    destination: connectedAccountId,
  },
});

How it works

The buyer pays $50
Your platform takes $5
The seller receives the remaining share, subject to Stripe fees and payout timing

This is the cleanest “split payment” model for most marketplaces.

Option 2: Separate charges and transfers

Use this when you need more control over timing or allocation.

Choose this model if you need to:

collect payment now and transfer later
hold funds until fulfillment
split one order across complex internal rules
manage marketplace settlement from your own ledger

This is more flexible, but it also means your app owns more of the routing logic.

Important rule for multi-seller carts

If one checkout can include items from multiple sellers, do not treat it like a single flat split. Build an order ledger that assigns each line item to a seller, then create the transfers or charge allocation per seller.

In practice:

allocate the line items in your app
calculate each seller’s net amount
use Connect to move the money
reconcile every transfer against the order record

What Stripe handles vs. what you handle

Stripe handles

seller onboarding and verification
connected account creation
fund routing and payouts
fraud tooling with Radar
webhook infrastructure and account status
dispute handling surfaces
payout orchestration across markets

You handle

marketplace rules
seller eligibility logic
product catalog and listings
fulfillment status
commission rules
refund policy
when an order is considered complete

That separation is the main reason Connect works well for marketplaces. Stripe handles the financial infrastructure. Your app handles the marketplace logic.

Add fraud controls before launch

If you are moving money between buyers and sellers, fraud and disputes matter from day one.

Use:

Radar for risk scoring and rules
3D Secure where appropriate
Webhook-driven fulfillment so you do not ship before payment is confirmed
Dispute monitoring so you can pause risky accounts early

If your marketplace needs onboarding alerts or risk actions inside your product, Stripe’s embedded components can surface required steps directly in the dashboard or app experience.

Recommended implementation path

If you want the fastest path to production, use this order:

1. Start with Express

You get a Stripe-hosted seller onboarding flow and less compliance overhead.

2. Use destination charges

This gives you a simple platform fee plus seller payout model.

3. Add Radar rules

Protect against fraud, abuse, and high-risk sellers.

4. Add webhooks

Use them for onboarding status, payment success, disputes, and payout events.

5. Move to embedded components only if needed

Do this when you need more brand control or deeper workflow integration.

Launch checklist

Before you go live, verify these items in test mode:

sellers can complete onboarding end to end
charges_enabled and payouts_enabled turn on correctly
payment intents succeed for the right amount
application fees are correct
seller transfers or payouts match your order ledger
refunds reverse the right amounts
disputes are visible in your support flow
webhook retries are handled safely
your reconciliation reports match Stripe balances

When to use Connect embedded components

Use embedded components if you want Stripe surfaces inside your marketplace dashboard instead of sending sellers to multiple separate pages.

Useful surfaces include:

onboarding status
required actions banners
payout setup
risk and verification prompts

That reduces friction for sellers and keeps the admin experience in one place.

The short answer

If you are building a marketplace, the most common setup is:

Connect Express for seller onboarding
Payments for the buyer checkout
Destination charges + application_fee_amount for the split
Radar for fraud protection
Webhooks for order, verification, and payout automation

That is the simplest Stripe-native way to onboard sellers and split payments without stitching together multiple providers.

If you want, I can also show you:

a Node.js example for the full Connect onboarding flow, or
a fund flow diagram for destination charges vs. separate charges and transfers.