The decision tree in practice: Do you need a commerce engine (products, inventory, shipping)? Yes -> Medusa or Saleor. No -> continue. Do you want to avoid writing payment code entirely? Yes -> Sharetribe Flex. No -> continue. Do you need multi-tenant data isolation? Yes -> MakerKit. No -> continue. Do you need to ship an MVP in under 2 weeks? Yes -> ShipFast. No -> MakerKit for the most complete Connect implementation. For the broader marketplace boilerplate landscape beyond Stripe Connect spec

Best Stripe Connect Marketplace Starters 2026

TL;DR

Stripe Connect is the hardest part of any multi-vendor marketplace build. Seller onboarding, split payments, payout scheduling, and 1099 generation add 4-8 weeks of engineering work if you start from scratch. Five starters now ship Stripe Connect support out of the box: ShipFast Marketplace Edition (fastest MVP, Express accounts), MakerKit Marketplace (Supabase + multi-tenant Connect), Medusa.js (open-source headless commerce with a Connect plugin), Saleor (GraphQL commerce with multi-vendor extensions), and Sharetribe Flex (fully managed Connect, zero payment code). Your choice depends on whether you want to own the code, how much payment customization you need, and whether you're building a product or service marketplace.

Feature Matrix

Starter	Price	Stripe Connect Type	Multi-Vendor	Frontend	Backend	Open Source
ShipFast Marketplace	$349 one-time	Express	Yes (2-sided)	Next.js 15	Next.js API routes	No
MakerKit Marketplace	$299/year	Express + Custom	Yes (multi-tenant)	Next.js 15	Supabase + Edge Functions	No
Medusa.js	Free (MIT)	Express (plugin)	Yes (plugin)	Next.js or custom	Node.js + PostgreSQL	Yes
Saleor	Free (BSD-3)	Standard + Custom	Yes (extension)	Next.js (Storefront)	Django + GraphQL	Yes
Sharetribe Flex	From $299/mo	Express (managed)	Yes (built-in)	Custom React	Sharetribe API	No (frontend only)

What Stripe Connect Actually Requires

Before comparing starters, it helps to understand what "Stripe Connect support" means in practice. A complete implementation has five layers, and most starters cover only the first two or three:

Account creation -- Creating Express, Standard, or Custom connected accounts for each seller
Onboarding flow -- Redirecting sellers through Stripe's hosted identity verification (KYC)
Payment splitting -- Using application_fee_amount and transfer_data on each PaymentIntent to split funds between platform and seller
Payout management -- Configuring payout schedules, handling insufficient-balance scenarios, and exposing a seller earnings dashboard
Tax reporting -- 1099-K generation for US sellers exceeding IRS thresholds (Stripe handles this, but your platform needs to collect the right metadata)

The implementation effort scales with account type. Express accounts delegate most compliance to Stripe (2-3 days to integrate). Custom accounts give you full control over the seller UX but require you to handle identity verification, dispute management, and payout UI yourself (2-4 weeks).

// The core Connect payment flow — every starter implements some version of this:
const paymentIntent = await stripe.paymentIntents.create({
  amount: 10000, // $100
  currency: 'usd',
  application_fee_amount: 1500, // $15 platform fee (15%)
  transfer_data: {
    destination: sellerStripeAccountId, // Connected account
  },
  metadata: {
    orderId: order.id,
    buyerId: buyer.id,
    sellerId: seller.id,
  },
});

For a deeper comparison of payment processors, see our Stripe vs Lemon Squeezy vs Paddle breakdown. Stripe Connect is the only option for true multi-vendor split payments -- Lemon Squeezy and Paddle are Merchant of Record services that don't support marketplace fund routing.

ShipFast Marketplace Edition

Price: $349 one-time | Stack: Next.js 15, MongoDB/Supabase, Stripe Connect Express | Connect integration depth: 3/5

ShipFast is the most popular SaaS boilerplate on the market, and its Marketplace Edition extends the base kit with Stripe Connect Express accounts, seller onboarding, and payment splitting. The implementation is straightforward: sellers sign up, complete Stripe's hosted onboarding, and start receiving payouts on each transaction minus the platform fee.

What ships out of the box:

Express account creation and onboarding link generation
Payment splitting with configurable platform fee percentage
Seller dashboard showing earnings, pending payouts, and transaction history
Webhook handlers for account.updated, payment_intent.succeeded, and transfer.created
Seller verification status tracking (pending, verified, restricted)

What you still need to build:

Listing/product management (ShipFast is a SaaS starter, not a commerce engine)
Buyer-seller messaging
Dispute resolution workflow
Custom payout schedules (defaults to Stripe's standard 2-day rolling)
Review and rating system

Architecture:

Buyer → Next.js frontend → API route → Stripe PaymentIntent
                                         ├── application_fee → Platform account
                                         └── transfer → Seller Express account

ShipFast's strength is speed to MVP. If you're validating a marketplace idea and need to process real payments within 2 weeks, this is the fastest path. The limitation is that it's a thin layer over Stripe's API -- no escrow, no manual capture for service marketplaces, no multi-party splits (three-way splits require Custom accounts).

Best for: Two-sided product marketplaces where the buyer pays and the seller ships. Think Etsy-like or Depop-like models.

MakerKit Marketplace

Price: $299/year | Stack: Next.js 15, Supabase, Stripe Connect Express + Custom | Connect integration depth: 4/5

MakerKit's marketplace template is the most complete Stripe Connect implementation among SaaS boilerplates. It supports both Express and Custom account types, which means you can start with Express for a quick launch and migrate sellers to Custom accounts later for a white-labeled payment experience.

What ships out of the box:

Express and Custom connected account creation
Multi-tenant architecture -- each seller operates in their own Supabase tenant with isolated data
Seller onboarding flow with progress tracking and verification status
Split payments with per-listing fee configuration (different listings can have different platform fees)
Payout dashboard with balance, pending, and available amounts
Webhook handlers covering the full Connect event lifecycle
Seller subscription billing (charge sellers a monthly fee to list on the platform)

What you still need to build:

Product/listing management specific to your marketplace category
Search and discovery (MakerKit includes basic full-text search via Supabase)
Buyer-seller communication
Review system

The multi-tenant architecture is the differentiator. Each seller's data lives in a separate Supabase schema, which provides real data isolation -- important for marketplaces handling sensitive information (healthcare services, financial products, legal services). Row-Level Security policies enforce tenant boundaries at the database level.

// MakerKit's per-listing fee configuration:
const listing = await db.listing.create({
  data: {
    title: 'Custom Logo Design',
    price: 15000, // $150
    platformFeePercent: 0.12, // 12% on this listing
    sellerId: seller.id,
    sellerStripeAccountId: seller.stripeAccountId,
  },
});

// At checkout, the fee is pulled from the listing:
const paymentIntent = await stripe.paymentIntents.create({
  amount: listing.price,
  currency: 'usd',
  application_fee_amount: Math.round(listing.price * listing.platformFeePercent),
  transfer_data: { destination: listing.sellerStripeAccountId },
});

Best for: Service marketplaces, B2B platforms, and any marketplace where data isolation between vendors matters. The Supabase foundation also gives you real-time subscriptions for order updates and messaging.

For more on the MakerKit ecosystem, see our best Next.js SaaS boilerplates roundup.

Medusa.js with Stripe Connect Plugin

Price: Free (MIT) | Stack: Node.js, PostgreSQL, Next.js storefront | Connect integration depth: 3/5

Medusa is an open-source headless commerce engine. Unlike ShipFast and MakerKit (which are SaaS starters with Connect bolted on), Medusa is a commerce platform first -- product catalog, inventory, orders, shipping, and fulfillment are all built in. The Stripe Connect marketplace plugin adds multi-vendor support on top of this foundation.

What the plugin provides:

Vendor registration and Stripe Express account provisioning
Automatic payment splitting on checkout (per-vendor items in cart)
Per-vendor order management (each vendor sees only their orders)
Vendor-specific shipping and fulfillment workflows
Admin panel with per-vendor revenue reporting

What makes Medusa different:

The fundamental advantage is that Medusa already solves product catalog, inventory, cart, checkout, and order management. You're adding Stripe Connect to a working commerce engine, not building commerce on top of a payment integration. For product marketplaces (physical goods, digital downloads, merchandise), this is the right abstraction level.

# Set up Medusa with the marketplace plugin:
npx create-medusa-app@latest my-marketplace
cd my-marketplace/backend

# Install the marketplace + Stripe Connect plugin:
npm install medusa-marketplace medusa-payment-stripe-connect

# medusa-config.js — register plugins:
module.exports = {
  plugins: [
    {
      resolve: 'medusa-marketplace',
      options: { /* vendor settings */ },
    },
    {
      resolve: 'medusa-payment-stripe-connect',
      options: {
        api_key: process.env.STRIPE_SECRET_KEY,
        application_fee_percentage: 15,
      },
    },
  ],
};

Caveats: The marketplace plugin is community-maintained, not an official Medusa module. Evaluate the plugin's GitHub activity, open issues, and compatibility with your Medusa version before committing. The plugin ecosystem moves quickly -- pin your dependencies and test upgrades in staging.

Best for: Product marketplaces with physical or digital goods where you need a real commerce backend (inventory, shipping, fulfillment) alongside payment splitting.

Saleor with Marketplace Extensions

Price: Free (BSD-3) | Stack: Django (Python), GraphQL, Next.js storefront | Connect integration depth: 3/5

Saleor is a GraphQL-first headless commerce platform with 20k+ GitHub stars. Its multi-vendor marketplace support comes through Saleor's channel and warehouse architecture: each vendor operates as a separate channel with their own products, pricing, and fulfillment configuration. Stripe Connect integration is available through Saleor's payment app system.

Architecture approach:

Saleor doesn't have a single "marketplace plugin" like Medusa. Instead, you compose marketplace functionality from Saleor's existing primitives:

Channels -- Each vendor is a channel with independent pricing, currency, and tax settings
Warehouses -- Each vendor has their own warehouse for inventory and fulfillment
Payment Apps -- Saleor's app system lets you build a Stripe Connect payment processor that routes funds to per-channel connected accounts
Permissions -- Staff accounts with channel-scoped permissions give each vendor access to only their own data

# Saleor's GraphQL API for multi-vendor order queries:
query VendorOrders($channel: String!) {
  orders(filter: { channels: [$channel] }, first: 50) {
    edges {
      node {
        id
        number
        total { gross { amount currency } }
        status
        lines {
          productName
          quantity
          totalPrice { gross { amount } }
        }
      }
    }
  }
}

Tradeoffs:

The Django/Python backend is a plus if your team has Python expertise and a potential friction point if you're an all-TypeScript shop. The GraphQL API is powerful but adds a learning curve compared to REST. Multi-vendor setup requires more configuration than Medusa's plugin approach -- you're assembling the marketplace from commerce primitives rather than installing a turnkey module.

Best for: Teams with Python/Django expertise building product marketplaces that need enterprise-grade commerce features (complex pricing, B2B, multi-currency, multi-region).

Sharetribe Flex

Price: From $299/month | Stack: Sharetribe API (hosted), custom React/Next.js frontend | Connect integration depth: 5/5

Sharetribe Flex is the only option on this list where Stripe Connect is fully managed. You don't write payment code -- Sharetribe handles account creation, onboarding, payment splitting, payouts, and dispute management through their API and dashboard. Your engineering work is limited to the frontend and business logic.

What's fully managed:

Stripe Connect Express account provisioning and onboarding
Payment splitting with configurable commission rates
Escrow and delayed payouts (funds held until service delivery confirmed)
Payout scheduling (daily, weekly, monthly per vendor)
Chargeback and dispute handling
1099-K tax reporting for US marketplaces
Multi-currency support (50+ currencies)

What you build:

Sharetribe Flex provides a headless API. You build the frontend in React or Next.js using their SDK. They ship a Flex Template for Web (FTW) as a starting point -- a full Next.js marketplace frontend with listing creation, search, booking, checkout, user profiles, messaging, and reviews.

# Clone the Flex Template for Web:
git clone https://github.com/sharetribe/ftw-daily my-marketplace
cd my-marketplace
yarn install

# Configure Sharetribe + Stripe Connect:
# .env
REACT_APP_SHARETRIBE_SDK_CLIENT_ID=your-client-id
REACT_APP_STRIPE_PUBLISHABLE_KEY=pk_live_...
REACT_APP_SHARETRIBE_MARKETPLACE_CURRENCY=USD

yarn run dev

Pricing model: Sharetribe charges $299/month (Grow plan) up to $999/month (Scale plan) based on transaction volume. They also take a small percentage of transactions. At $50k/month GMV, Sharetribe costs roughly $500-700/month including their transaction cut. At $500k/month GMV, the economics shift and self-hosted solutions become more cost-effective.

Best for: Non-technical founders or small teams building service marketplaces (tutoring, freelancing, home services, equipment rental) who want to launch in weeks instead of months. The tradeoff is vendor lock-in and ongoing platform fees.

Stripe Connect Account Types Compared

The account type you choose constrains which starters work for you. Here's the practical difference:

Factor	Express	Standard	Custom
Onboarding	Stripe-hosted (redirect)	OAuth (seller has Stripe)	You build the UI
Seller dashboard	Stripe-hosted	Full Stripe dashboard	You build it
KYC/compliance	Stripe handles	Seller's responsibility	You handle
Branding	Stripe-branded	Seller's Stripe brand	Your brand
Setup effort	2-3 days	1-2 days	2-4 weeks
Best for	Most marketplaces	B2B with existing Stripe users	White-label platforms

Express accounts cover 90% of marketplace use cases. Start there unless you have a specific reason not to. Custom accounts are only worth the engineering investment if you need white-labeled payment experiences (the seller never sees Stripe's branding).

Escrow and Delayed Payouts

Service marketplaces -- where the buyer pays before the service is delivered -- need escrow functionality. The implementation pattern is capture_method: 'manual' on the PaymentIntent: authorize the buyer's card at booking, capture funds after delivery confirmation.

// Escrow pattern for service marketplaces:

// 1. At booking — authorize but don't capture:
const paymentIntent = await stripe.paymentIntents.create({
  amount: 25000, // $250
  currency: 'usd',
  capture_method: 'manual', // Auth only
  application_fee_amount: 3750, // 15% platform fee
  transfer_data: { destination: providerStripeAccountId },
});

// 2. After service delivery — capture funds:
await stripe.paymentIntents.capture(paymentIntent.id);
// Funds transfer to provider automatically

// 3. If dispute — cancel the auth (no charge):
await stripe.paymentIntents.cancel(paymentIntent.id);

Starter support for escrow:

Sharetribe Flex: Built-in, configurable per-listing
MakerKit: Supported via manual capture configuration
ShipFast: Not included, requires custom implementation
Medusa: Plugin-dependent, varies by marketplace plugin version
Saleor: Requires custom payment app logic

If escrow is core to your marketplace model, Sharetribe Flex or MakerKit are the strongest starting points. For a broader look at Stripe integration patterns across SaaS starters, see our best boilerplates with Stripe integration guide.

When to Use Which

Scenario	Best Starter	Why
Validate a marketplace idea in 2 weeks	ShipFast Marketplace	Fastest to deploy, proven SaaS foundation
Service marketplace with escrow	Sharetribe Flex or MakerKit	Built-in escrow + managed compliance
Product marketplace (physical goods)	Medusa.js + Connect plugin	Real commerce engine with inventory and fulfillment
Enterprise multi-vendor commerce	Saleor	GraphQL API, multi-currency, B2B pricing
Non-technical founder, budget for SaaS fees	Sharetribe Flex	Zero payment code, fully managed Connect
Multi-tenant with data isolation	MakerKit Marketplace	Supabase Row-Level Security per vendor
White-label payment experience	MakerKit (Custom accounts) or Saleor	Custom Connect account support
Open-source, full code ownership	Medusa.js or Saleor	MIT/BSD licensed, self-hosted

The decision tree in practice:

Do you need a commerce engine (products, inventory, shipping)? Yes -> Medusa or Saleor. No -> continue.
Do you want to avoid writing payment code entirely? Yes -> Sharetribe Flex. No -> continue.
Do you need multi-tenant data isolation? Yes -> MakerKit. No -> continue.
Do you need to ship an MVP in under 2 weeks? Yes -> ShipFast. No -> MakerKit for the most complete Connect implementation.

For the broader marketplace boilerplate landscape beyond Stripe Connect specifically, see our best boilerplates for marketplace platforms guide. And if you're still deciding between payment processors, our Stripe vs Polar vs Lemon Squeezy comparison covers when each makes sense.

Methodology

Stripe Connect integration depth assessed by reviewing each starter's source code and documentation for: account creation, onboarding, payment splitting, payout management, webhook handling, and escrow support. Pricing verified from official websites as of April 2026. No compensation received from any vendor.

Browse marketplace starters in the StarterPick directory.

The SaaS Boilerplate Matrix (Free PDF)