Best Boilerplates for Marketplace Platforms 2026

TL;DR

Building a marketplace is 10x harder than a regular SaaS because you have two customer types (buyers + sellers) with different flows, and money movement between them. The core complexity is always Stripe Connect for split payments and payouts. No boilerplate handles this fully — you combine a SaaS starter + custom Stripe Connect implementation. The most important decision: standard (seller can't touch funds) vs express accounts (seller has a Stripe dashboard).

Key Takeaways

Stripe Connect: Non-negotiable for any real marketplace with money movement
Connect account type: Express (seller has Stripe dashboard) vs Standard vs Custom
Application fee: Stripe's built-in mechanism for platform fee on each transaction
Transfers: Separate payment from payout — hold funds, release after service delivery
Seller onboarding: OAuth flow for Standard; hosted onboarding for Express
Tax reporting: Stripe handles 1099 generation for US marketplaces with Connect

Why Marketplace Boilerplates Are Rare

Marketplaces are popular business models but poor candidates for generic boilerplates. The reason is structural: every marketplace makes different choices about who pays whom, when, and how. A freelance services marketplace (Fiverr-like) holds payment in escrow until delivery. A product marketplace (Etsy-like) collects payment immediately and pays out on a schedule. A booking marketplace (Airbnb-like) might hold payment until check-in. These workflows require different Stripe configurations, different order state machines, and different dispute flows.

What you can boilerplate is the infrastructure layer: Stripe Connect account management, seller onboarding flows, listing management, and search. The business logic on top — when to release funds, how disputes work, review systems, trust and safety — is custom to each marketplace.

The practical approach in 2026: pick the best general SaaS starter (ShipFast, T3, Makerkit) and build the Stripe Connect layer on top. The Connect implementation is well-documented and takes 3–7 days for a competent team.

Best Boilerplates for Marketplace Projects

1. ShipFast + Stripe Connect

ShipFast's clean codebase and Stripe integration make it the fastest starting point for marketplace MVPs. You add the Connect layer (seller onboarding, payment splitting, payout management) on top of ShipFast's existing auth, billing, and email infrastructure.

Why ShipFast for marketplaces:

Stripe is already integrated — adding Connect is an extension, not a rework
Next.js App Router + TypeScript — good foundation for complex state
Fast to deploy (Vercel-ready)
Active community with marketplace-specific examples in Discord

What to build on top: Seller onboarding flow, listing management, Stripe Connect account creation, payment splitting, payout dashboard.

Time to MVP: 2–4 weeks with dedicated engineering time.

Price: $349 one-time.

2. T3 Stack + Custom Connect

The T3 Stack (TypeScript + tRPC + Prisma + Next.js) is the right choice when you want full type safety through your marketplace's payment flows. tRPC lets you define the buyer and seller APIs with complete TypeScript coverage, which is valuable when money is moving.

Why T3 for marketplaces:

End-to-end type safety across all payment operations
Prisma gives you a clean schema for marketplace-specific models (Listing, Order, Seller, Payout)
No vendor lock-in — you own everything
Best for teams comfortable building from primitives

Tradeoff: More setup time than ShipFast. Authentication, email, and billing need more configuration.

Price: Free (open source).

3. Medusa.js

Medusa is an open-source commerce engine with a marketplace plugin. It's built specifically for product-based marketplaces and ships with inventory management, order management, and multi-vendor support.

Best for: Physical product marketplaces (handmade goods, digital downloads, merchandise). Not well-suited for service marketplaces.

Architecture: Medusa runs as a separate backend service (Node.js + PostgreSQL). Your frontend is a separate Next.js app that calls Medusa's API. This adds complexity but gives you a mature commerce foundation.

Marketplace plugin: Medusa's marketplace plugin handles multi-vendor orders, per-vendor shipping, and split fulfillment. It's not officially maintained by Medusa's team, so evaluate the specific plugin's maturity before committing.

Price: Free (open source). Hosted Medusa Cloud starts at $1,000/month.

4. Directus + Next.js (Headless)

For service marketplaces where the CMS flexibility of Directus is valuable (complex listing schemas, custom fields per category), a headless approach works well. Directus handles the data layer and admin panel; Next.js handles the buyer/seller UX.

Best for: Marketplaces with complex, category-specific listing schemas (like a marketplace for professional services where different service types have different fields).

Tradeoff: More infrastructure to manage. You're running Directus + a Next.js app + Stripe Connect.

Feature Comparison

Boilerplate	Auth	Stripe Connect	Seller Onboarding	Listings	Search	Price
ShipFast	✅	❌ Add it	❌ Add it	❌ Add it	❌ Add it	$349
T3 Stack	Add Auth.js	❌ Add it	❌ Add it	❌ Add it	❌ Add it	Free
Medusa.js	✅	✅ Plugin	✅ Plugin	✅	✅ Basic	Free
Makerkit	✅	❌ Add it	❌ Add it	❌ Add it	❌ Add it	$299
Directus	✅	❌ Add it	❌ Add it	✅ CMS	✅ Filter	Free

No boilerplate ships with a complete, production-ready Stripe Connect integration. Plan to build this regardless of your starter.

Marketplace Architecture

Buyer pays → Stripe (platform account)
                   ↓
           Split: 85% → Seller account
                   +  15% → Platform fee (your revenue)
                   
Timeline:
  1. Buyer pays → Funds held in platform Stripe account
  2. Service delivered / product shipped
  3. Platform releases funds → Seller's Stripe account
  4. Seller transfers to bank account (2-7 day payout)

Stripe Connect: Express Accounts (Recommended)

// lib/stripe-connect.ts:
import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

// Step 1: Create Express account onboarding link for seller:
export async function createSellerOnboardingLink(sellerId: string) {
  // First, create (or get existing) Connect account:
  const account = await stripe.accounts.create({
    type: 'express',
    metadata: { sellerId },
    capabilities: {
      transfers: { requested: true },
      card_payments: { requested: true },
    },
  });
  
  // Save account ID to your DB:
  await db.seller.update({
    where: { id: sellerId },
    data: { stripeAccountId: account.id },
  });
  
  // Generate onboarding link:
  const link = await stripe.accountLinks.create({
    account: account.id,
    refresh_url: `${process.env.NEXT_PUBLIC_URL}/seller/onboarding/refresh`,
    return_url: `${process.env.NEXT_PUBLIC_URL}/seller/dashboard`,
    type: 'account_onboarding',
  });
  
  return link.url;  // Redirect seller to this URL
}

// Check if seller completed onboarding:
export async function checkSellerOnboarded(stripeAccountId: string) {
  const account = await stripe.accounts.retrieve(stripeAccountId);
  return account.details_submitted && !account.requirements?.currently_due?.length;
}

// Step 2: Create payment with application fee (the platform fee):
export async function createMarketplacePayment(params: {
  amount: number;               // Total amount in cents ($100 = 10000)
  platformFeePercent: number;   // e.g., 0.15 for 15%
  sellerStripeAccountId: string;
  metadata: Record<string, string>;
}) {
  const { amount, platformFeePercent, sellerStripeAccountId } = params;
  const applicationFeeAmount = Math.round(amount * platformFeePercent);
  
  const paymentIntent = await stripe.paymentIntents.create({
    amount,
    currency: 'usd',
    application_fee_amount: applicationFeeAmount,  // Platform gets this
    transfer_data: {
      destination: sellerStripeAccountId,           // Seller gets the rest
    },
    metadata: params.metadata,
  });
  
  return paymentIntent;
}

Service Marketplace: Escrow Pattern

// For service marketplaces (Fiverr-like) — hold funds until delivery:

// 1. Capture payment but don't transfer yet:
const paymentIntent = await stripe.paymentIntents.create({
  amount: 10000,  // $100
  currency: 'usd',
  capture_method: 'manual',  // Don't capture yet (auth only)
  transfer_data: { destination: sellerAccountId },
  application_fee_amount: 1500,  // $15 platform fee
});

// 2. When buyer confirms delivery — capture and release:
async function releasePayment(paymentIntentId: string) {
  await stripe.paymentIntents.capture(paymentIntentId);
  
  // The transfer to seller happens automatically
  await db.order.update({
    where: { stripePaymentIntentId: paymentIntentId },
    data: { status: 'completed', completedAt: new Date() },
  });
}

// 3. If dispute — refund buyer:
async function refundBuyer(paymentIntentId: string) {
  await stripe.paymentIntents.cancel(paymentIntentId);
  // or for already captured: stripe.refunds.create({ payment_intent: id })
}

Building Seller Trust: Reviews and Ratings

Two-sided marketplaces live and die by trust. Buyers need to trust that sellers deliver, and sellers need to trust that buyers won't abuse the dispute process. The review system is the primary trust mechanism.

The technical implementation is straightforward — a review model with buyer, seller, order, rating (1–5), and text body. The hard part is the policy design: when can buyers leave reviews (only after confirmed delivery, or anytime?), can sellers respond to reviews publicly, how do you handle review brigading or fake reviews?

From a product perspective, make reviews visible prominently on seller profiles and listing pages. Sellers with high ratings should appear higher in search results. New sellers need a mechanism to build initial reputation — consider allowing sellers to bring over external reviews or offering a free "starter listings" program to build history.

model Review {
  id          String   @id @default(cuid())
  orderId     String   @unique
  buyerId     String
  sellerId    String
  listingId   String
  rating      Int      // 1-5
  body        String?
  sellerReply String?
  createdAt   DateTime @default(now())
  
  buyer   User    @relation("ReviewsGiven", fields: [buyerId], references: [id])
  seller  User    @relation("ReviewsReceived", fields: [sellerId], references: [id])
  order   Order   @relation(fields: [orderId], references: [id])
}

Calculate seller ratings on the application layer with weighted recency (recent reviews count more) rather than a simple average. Stripe's own seller rating guidance suggests showing the review count alongside the rating — "4.8 (127 reviews)" is more credible than just "4.8".

Marketplace Discovery: Search and Browse

The listing search experience directly determines whether buyers find what they need and whether sellers get orders. A poor search experience means revenue left on the table.

For smaller marketplaces (under 50K listings), PostgreSQL full-text search with tsvector columns is sufficient. Add pg_trgm for fuzzy matching that handles typos. For larger catalogs, Meilisearch or Elasticsearch provide better relevance ranking and faceted filtering.

The browse experience — category navigation, filtering by price/location/rating/availability — is equally important. Implement faceted filters with accurate counts before filtering. Users trust filters that show "(23 listings)" next to each option; they abandon pages with empty filter results.

Featured listings (sellers pay to be highlighted) should appear in search results and category pages, but clearly labeled as "Featured." Users tolerate featured listings if they're relevant and labeled honestly. If featured listings are irrelevant to the search query, it damages trust in the entire platform.

Critical Marketplace Edge Cases

Partial refunds. When a buyer disputes part of a delivery, you need to issue a partial refund and adjust the seller payout. Stripe supports partial refunds, but you need to track the exact amounts in your DB for reconciliation.

Seller KYC failures. If a seller fails Stripe's identity verification mid-operation (they've already listed and received orders), you need a graceful degradation path. Don't block the buyer experience — but hold payouts until the seller resolves their verification.

Chargeback handling. Stripe Connect passes chargebacks through to connected accounts by default. If your seller loses a chargeback, Stripe debits their account. If their balance is insufficient, the debit flows to your platform account. Implement a reserve model (withhold 5% of payouts into a reserve) to protect against this.

Platform fee tax. In some jurisdictions, your platform fee is subject to sales tax (you're providing a taxable service). Stripe Tax can handle this but requires configuration per jurisdiction.

Choosing Your Connect Type

Use Express Connect if:

Sellers are individuals (gig economy, freelancers)
You want Stripe to handle seller compliance
Sellers need their own payout dashboard
This covers 95% of marketplace use cases

Use Standard Connect if:

Sellers are businesses with existing Stripe accounts
Sellers want their own Stripe account management
B2B marketplace (SaaS vendors selling through your platform)

Use Custom Connect if:

Complete control over onboarding UI/UX is required
White-label the payment experience
Complex compliance requirements
Significant engineering investment required

Trust and Reputation Infrastructure

Trust is the invisible product of every marketplace. Buyers and sellers transact with strangers, and the platform's job is to reduce the perceived risk of each transaction enough that the deal happens.

The core trust infrastructure has three components: identity verification, escrow, and reputation. Identity verification through Stripe Connect handles the financial identity layer (KYC for sellers, card verification for buyers). Escrow — holding funds until delivery is confirmed — is the structural trust mechanism that Stripe Connect's charge-then-transfer model provides. Reputation accumulates through reviews, which must be collected after the transaction window closes, not before.

Rating systems require careful design to stay useful. Most marketplaces learn too late that a naive five-star average is gamed and inflated — every seller eventually drifts toward 4.8-4.9 because bad sellers leave the platform and good sellers accumulate positive reviews. The useful signal is in the variance: a seller with 4.6 and 300 reviews is more trustworthy than a seller with 4.9 and 7 reviews. Show both the rating and the review count prominently.

Dispute resolution deserves its own admin workflow from day one. Marketplace disputes — "item not as described," "delivery not received," "service not rendered" — require a structured process: claim filed, seller notified and given 48 hours to respond, evidence collected, admin decision, payout adjusted. Implementing this as ad hoc customer support tickets instead of a proper workflow costs significantly more time as volume grows.

Marketplace Product Categories and Their Billing Patterns

Different marketplace categories have distinct billing requirements that affect which boilerplate (or custom implementation) you need:

Service marketplaces (freelancers, tutors, consultants): Billing is time-based or milestone-based. Platform holds funds at booking, releases to the provider on completion. Hourly billing requires time tracking integration. Fixed-price projects release on delivery acceptance. Stripe Connect's capture_method: 'manual' lets you authorize funds at booking and capture on delivery.

Physical goods marketplaces (resale, crafts, collectibles): Billing is transactional — buyer pays, seller fulfills, funds transfer minus platform fee. Stripe Connect's standard charge-then-transfer pattern handles this. The complexity is in shipping label generation (EasyPost, Shippo) and tracking integration, not billing.

Digital product marketplaces (templates, fonts, plugins): Instant delivery after payment. No fulfillment window. Refunds are policy-based, not delivery-based. Lemon Squeezy's Merchant of Record model is often better for digital marketplaces targeting international buyers — it handles VAT/GST automatically. Stripe Connect requires the platform to handle tax compliance.

Booking marketplaces (experiences, rentals, classes): Time-constrained inventory requires calendar availability management alongside payment. Funds authorization at booking, settlement on completion or check-in. Cancellation windows with partial refund policies. This category has the most complex billing logic — see the scheduling boilerplate guides for time-slot management patterns.

For the billing infrastructure foundation, see best boilerplates with Stripe integration. If you're building a booking/appointment variant of a marketplace, best boilerplates for booking and scheduling covers the time-slot management layer. For subscription-based marketplaces, best boilerplates for subscription box products adds recurring billing patterns. For the broader SaaS boilerplate landscape that marketplaces often need to integrate with, see best SaaS boilerplates 2026.

Methodology

Stripe Connect documentation and pricing sourced from Stripe's official docs (April 2026). Boilerplate assessments based on GitHub code review and community reports. No compensation received from any boilerplate vendor.

Find marketplace boilerplates at StarterPick.

The SaaS Boilerplate Matrix (Free PDF)