Bubble Docs
  • Introduction
  • New? Start Here
  • What is Bubble?
  • The Glossary
  • User manual
    • Getting started
      • What is Bubble?
      • Building your first app
        • Planning features
        • Database structure
        • Design and UX
        • eCommerce and payments
          • Shopping cart
          • Checkout page
          • One-time payments
          • Subscriptions
          • Marketplace
      • Creating and managing apps
      • The Bubble editor
        • Tabs and sections
          • Design tab
            • The element tree
            • The property editor
          • Workflow tab
          • Data tab
          • Styles tab
          • Plugins tab
          • Settings tab
            • Application settings
              • Custom headers/body
              • Visual settings
              • Social media sharing
              • Translating your app
              • Email settings
              • Collaboration
            • Custom domain and DNS
          • Logs tab
        • Tools
          • Key features
          • The search tool
          • The Issue Checker
          • The element tree
          • The element property editor
          • The debugger
          • Notes
        • Previewing your app
      • Transitioning to Bubble from...
        • JavaScript
        • HTML and CSS
        • SQL
    • Design
      • Elements
        • The element hierarchy
          • The element tree
        • The page
        • Containers
          • Groups
          • Repeating groups
          • Table elements
          • Popups
          • Floating groups
          • Group focus
        • Visual elements
        • Input forms
          • Text and numbers
          • Dates and time
          • File uploads
          • Selection controls
        • Reusable Elements
      • Styling
        • Color variables
        • Font variables
        • Styles
        • Custom Fonts
      • Responsive design
        • Building responsive pages
        • Legacy articles
          • The Basics (Legacy)
          • Building Responsive Pages (Legacy)
          • Migrating Legacy Pages
          • Tips When Designing (Legacy)
      • Templates
      • The Component Library
      • Importing from Figma
    • Data
      • The database
        • Data types and fields
        • Creating, saving and deleting data
        • Finding data
        • Displaying data
        • Protecting data with privacy rules
        • The database editor
        • Export/import data
          • Exporting data
          • Importing data (CSV)
        • Working with location data
        • Using Algolia
        • Database structure by app type
          • Marketplace Apps
          • Directory & Listings Apps
          • Social Network Apps
          • SaaS Apps
          • Project Management Apps
          • CRM Apps
          • Professional Services Apps
          • On-demand Apps
          • Documentation/ CMS Apps
          • Applicant Tracking System (ATS) Apps
          • Portfolio Apps
          • Gallery Apps
          • Online Store / Ecommerce Apps
          • Blog Apps
          • Messaging App
          • Dashboards
          • Building Block Apps
          • Bubble as a backend
      • Files
      • Images
      • Static data
        • App texts (translations)
        • Option sets
      • Temporary data
        • Custom states
        • URL parameters
      • User accounts
        • Authentication plugins
          • Facebook plugin
          • Fitbit plugin
          • Google plugin
          • Instagram plugin
          • LinkedIn plugin
          • Pinterest plugin
          • Slack plugin
          • Wistia plugin
          • YouTube plugin
        • Cookies set by Bubble
      • Time, dates and time zones
    • Logic
      • The frontend and backend
      • Workflows
        • Events
          • Frontend events
            • Recurring workflows
            • Custom events
          • Backend events
            • Database trigger events
        • Actions
        • API Workflows
      • Dynamic expressions
      • Conditions
      • Navigation
        • Single-page applications (SPA)
        • Multi-page applications
        • Page slugs
    • Workload
      • Understanding workload
        • Activity types
        • The workload calculation
        • Client-side and server-side processing
      • Tracking workload
        • Measuring
          • Using App Metrics
        • Monitoring
          • Workload notifications
          • Infinite recursion protection
      • Optimizing workload
        • Optimization framework
        • Optimization checklist
          • Page load
          • Searches
          • Workflows and actions
          • Backend workflows
        • Agency showcases
          • Minimum Studio
          • Neam
          • Support Dept
    • Security
      • Bubble's security features
      • Planning app security
      • Client-side and server-side
      • Bubble account security
      • App security
      • Page security
      • Database security
      • API security
        • API Connector security
        • Data API security
        • Workflow API security
      • Flusk
        • Overview
        • Flusk plan features
        • Getting started with Flusk
        • Flusk security tools
          • The Issues Explorer
          • Issue details
          • Tools and settings
            • Pages rating
            • Database rating
        • Flusk FAQ
      • Cookies
      • Security checklist
    • Publishing your app
      • Web app
      • Native mobile app
        • Global native mobile settings
        • iOS App Store
        • Google Play Store
        • Publishing FAQ
    • AI
      • Generate apps with AI
        • About AI app generation
      • AI page designer
      • Connect to AI agents
    • Maintenance
      • Collaborators
      • Version control
        • Best practices: Version control
        • Transitioning from the legacy version control
        • Terminology: Version control
        • Version Control (legacy)
      • Commenting
      • Database maintenance
        • Copying the database
        • Restoring database backups
        • Bulk operations
          • Bulk operation methods compared
        • Wiping change history
      • Performance
        • Hard limits
        • Capacity Usage (legacy)
        • Notes on queries
      • SEO
        • Introduction to SEO
        • SEO: App
        • SEO: Page
      • Testing and debugging
        • Introduction to testing and debugging
        • The debugger
        • The server logs
        • Supported browsers
      • API workflow scheduler
    • Integrations
      • API
        • Introduction to APIs
          • What is a RESTful API?
        • The Bubble API
          • Bubble API terminology
          • Authentication
            • How to authenticate
            • No authentication
            • As a User
            • As an admin
          • The Data API
            • Data API Privacy Rules
            • Data API endpoints
            • Data API requests
          • The Workflow API
            • Workflow API privacy rules
            • Workflow API endpoints
            • API workflows
              • Creating API workflows
              • Scheduling API workflows
              • Recursive API workflows
              • API Workflow Scheduler
              • Case: Stripe notifications
        • The API Connector
          • Authentication
          • API Connector security
          • API guides
            • OpenAI
              • Authentication
              • Calls
                • ChatGPT
                  • Chat
            • Google Translate
              • How to setup Google API keys
          • Streaming API
        • API security
        • Plugins that connect to APIs
        • API Glossary
      • Plugins
        • What Plugins Can Do
        • Installing and using Plugins
        • Authentication plugins
        • Special Plugins
      • SQL Database Connector
      • Bubble App Connector
      • WorkOS
        • WorkOS SSO
        • WorkOS API
    • Infrastructure
      • Sub-apps
      • Bubble release tiers
      • Hosting and scaling
        • How Bubble hosting works
        • Scaling with Bubble
        • CDN (Cloudflare)
        • Bubble app names
        • Domain and DNS
      • Compliance
        • GDPR
        • SOC 2 Type II
        • HIPAA
        • Other frameworks and standards
    • Bubble for Enterprise
      • Hosting and infrastructure
        • Dedicated instance
          • The Dedicated editor experience
          • Technical specs
          • Main cluster dependencies
          • Customizable options
          • Migration process
            • Pre-migration
            • During migration
            • Post-migration
      • Security and compliance
        • Single sign-on (SSO)
        • GDPR
        • SOC 2 Type II
        • HIPAA
        • Other frameworks
        • Bubble's security features
      • Admin and collaboration
      • Priority support
      • Billing and Payment Guideline for Dedicated Instances
  • Core Reference
    • Using the core reference
    • Bubble's Interface
      • Design tab
      • Design tab (Legacy)
      • Workflow tab
      • Data tab
      • Styles tab
      • Styles tab (Legacy)
      • Plugins tab
      • Settings tab
      • Logs tab
      • Template tab
      • Toolbar
      • Top and context menu options
      • Deployment and version control
        • Deployment & Version Control Dropdown (legacy)
      • Notes
    • Elements
      • General properties
      • General properties (Legacy)
      • Styling properties
      • Styling Properties (Legacy)
      • Responsive Properties
      • Responsive Properties (Legacy)
      • Conditional formatting
      • States
      • Page Element
        • Page Element (Legacy)
      • Visual Elements
      • Containers
      • Container Layout Types
      • Containers (Legacy)
      • Input Forms
      • Reusable Elements
      • Element Templates (legacy)
    • Workflows
    • Events
      • General events
      • Element events
      • Custom events
      • Recurring event
      • Database trigger event
    • Actions
      • Account
      • Navigation
      • Data (things)
      • Email
      • Element
      • Custom
    • Data
      • Data Sources
      • Operators and comparisons
      • Search
      • Privacy
    • Styles
    • API
      • The Bubble API
        • The Data API
          • Authentication
          • Data API endpoints
          • Data API requests
        • The Workflow API
      • The API Connector
        • Authentication
        • Adding calls
    • Bubble-made Plugins
      • AddtoAny Share Buttons
      • Airtable
      • API Connector
      • Blockspring
      • Box
      • Braintree
      • Bubble App Connector
      • Chart.js
      • Circle Music Player
      • Draggable Elements
      • Dropzone
      • Facebook
      • Fitbit
      • Full Calendar
      • Google
      • Google Analytics
      • Google Optimize
      • Google Places
      • Ionic Elements
      • iTunes
      • Slidebar Menu
      • LinkedIn
      • Localize Translation
      • Mixpanel
      • Mouse & Keyboard Interactions
      • Multiselect Dropdown
      • Progress Bar
      • Rich Text Editor
      • Rich Text Editor (Legacy)
      • Screenshotlayer
      • SelectPDF
      • Slack
      • Segment
      • Slick Slideshow
      • SQL Database Connector
      • Star Rating
      • Stripe
      • Tinder-like Element
      • Twitter
      • YouTube
      • Zapier
    • Application Settings
      • App plan
      • General
      • Domain / email
      • Languages
      • SEO / metatags
      • API
      • Collaboration
      • Sub-apps
      • Versions
  • Account & Marketplace
    • Account and billing
      • Pricing and plans
        • Plans and billing
        • Billing cycle
        • FAQ: Pricing and Workload
      • Account Management
      • Building Apps for Others
      • Selling on the Marketplace
      • Plans & Billing (legacy)
    • Official Bubble Certification
      • Hiring certified developers
    • Building Plugins
      • The Plugin Editor
      • General Settings
      • Updating to Plugin API v4
      • Adding API Connections
      • Building Elements
      • Building Actions
      • Loading Data
      • Publishing and versioning
      • Github Integration
    • Building Templates
    • Application and data ownership
    • Marketplace policies
    • Bug reports
  • Vulnerability Disclosure Policy
  • Beta features
    • About the Beta features section
    • Native mobile apps 🔒
      • Introduction
        • What is a native mobile app?
        • Native mobile vs. web development
        • Differences in native and web elements
        • Native mobile app terminology
      • Building
        • Views and navigation
        • Native mobile actions
        • Components and gestures
        • Device resources
          • Location services
          • Camera/photo library
      • Previewing
      • Publishing
Powered by GitBook
On this page
  • Defining marketplace apps
  • Planning marketplace apps
  • Stripe Connect for building marketplace apps in Bubble
  • Fees
  • Managing marketplace Bubble apps in Stripe
  • Registering sellers
  • Identifying the correct seller
  • Charging a sale on behalf of a seller
  • Seller payouts in your Bubble app
  • Other ways to learn

Was this helpful?

  1. User manual
  2. Getting started
  3. Building your first app
  4. eCommerce and payments

Marketplace

Last updated 2 days ago

Was this helpful?

Disclaimer: Note that while Stripe is mentioned in this document as an example of a payment platform, this should not be interpreted as an endorsement or recommendation of Stripe's services. The information provided here does not constitute legal advice. As an app builder, it is your responsibility to select a payment platform that meets your specific needs. You are also responsible for ensuring compliance with the terms and conditions of the chosen payment platform.

We encourage you to conduct thorough research and, if necessary, consult with a legal professional to make an informed decision.

This article describes how you can use the Stripe plugin as a payment provider in your Bubble app. If you are looking for information about earning regarding the Bubble template and plugin marketplace, see this article.

This article looks into how to plan for building a marketplace app.

Defining marketplace apps

Marketplace apps are somewhat different from one-time paments and subscriptions, in that they involve a third party. In this article, we'll refer to the different roles in this transaction as the following:

  • The marketplace is your app (the Stripe account)

  • The customer is the person buying something

  • The seller is the third party selling something (the Connected Stripe account)

Marketplace apps have transformed the way we engage in commerce, creating digital spaces where buyers and sellers converge to exchange products, services, or information. Instead of an app selling a set catalog of products and services, marketplace apps allow sellers to sell their products and services in your app.

We define marketplace app as an app where a transaction is split between these three parties. The Bubble platform, for example, allows users to set up an app and generate revenue with it, but Bubble is not a marketplace app under this definition, as we're not a part of the customer transaction.

There are a variety of marketplaces live today, selling stuff like:

  • Tangible goods

  • Video content, such as courses

  • Live sessions, such as coaching, counseling, and music lessons

  • Services like transportation and food delivery

  • Specialized product categories such as art and collectibles

  • Rental of real estate properties

  • Accommodation in hotels

Many marketplaces started out serving a niche, and then grew over time to handle multiple categories. As you plan your app, it's worth keeping in mind that everything starts with the first step.

In this article, we will use the term "product" to refer to any item or service being offered in a marketplace, regardless of its specific nature.

Planning marketplace apps

Stripe Connect offers various customization options to suit different business models, but this article primarily focuses on the model described below. If you are new to Bubble and/or Stripe, it's likely you will find this setup the easiest to set up.

While marketplace apps can have very different structures, many employ a revenue model that bears a resemblance to the following structure. We'll define the app user as end-user in this example, to separate them from sellers.

As illustrated the process is as follows:

  1. End-user (customer) browses products in the marketplace.

  2. End-user purchases one or more products.

  3. End-user makes a payment through Stripe.

  4. The amount is split between the three parties:

    1. Stripe retains its transaction fee

    2. A portion of the payment is retained in the seller's Stripe account.

    3. Another portion is transferred to the marketplace owner's Stripe account.

Stripe's product, Stripe Connect, automates the allocation of payments and fees.

Stripe Connect for building marketplace apps in Bubble

Stripe Connect is Stripe's solution for helping platforms and marketplaces efficiently manage payments and payouts for multiple sellers or service providers within their ecosystem. Whether you're building a marketplace for various types of products, services, or a combination of both, Stripe Connect simplifies the process of handling financial transactions. This section explores how Stripe Connect functions and how you can use it to establish a secure and streamlined payment system for your platform.

First, let's see how Stripe Connect relates to each of the three parties involved in a marketplace transaction:

  1. Platform: The platform is your app, that facilitates transactions between buyers and sellers. The platform uses Stripe Connect to handle payments and payouts for its users.

  2. Seller: Sellers are individuals or businesses that offer products or services on the platform. They receive payments from buyers through the platform. Each seller has their own Stripe account connected to the platform.

  3. Customer: Customers are the users who purchase products or services from sellers within the platform. They make payments to the platform, which then distributes the appropriate portion to the seller after deducting any fees or commissions.

Stripe Connect acts as the intermediary that facilitates the flow of funds between these three parties, ensuring secure and transparent transactions within the platform.

Fees

The part of the transaction that the platform (your app) keeps, is often called the platform fee. To understand how this is structured, let's look at the total fee structure for each of these two parties (platform and seller).

In the example below, we show the calculation for each party, and how much is party is left with. Please note that these values are purely for demonstration and are not reflective of actual fees:

Description
Fee
Total

Transaction

$100

0,5%

$0.5

5%

$5

Seller's payout

$94,5

Stripe keeps

$0.05

Platform keeps

$5

As the table illustrates, both the platform fee and Stripe transaction fee is paid by the seller, and whichever platform fee you've set is calculated on the total transaction value. The buyer is never made aware of the calculation going on behind the scenes, and is simply asked to pay the full $100 amount in one transaction.

The fee is set when you initiate the transaction, using the Charge the current user action (described below).

Managing marketplace Bubble apps in Stripe

Registering sellers

Every seller who sells something through your app needs to have their own individual Stripe account. This setup ensures that each seller can receive payments directly and manage their financial transactions independently within your platform.

The official Stripe plugin supports setting up seller accounts automatically. This will work whether the seller has an existing Stripe account, or wants to create a new one. To set up sellers on Stripe, use the action. Keep in mind that the must be installed and correctly set up to work.

Identifying the correct seller

When building a marketplace app, accurately identifying the appropriate seller for each sale is important to ensure proper payment to the respective seller. What you should keep in mind, is to structure your database so as to keep track of which seller is connected to a particular product.

You likely have a product data type (or similar) in your app, that contains information about the item being sold, such as price and description. You can store which user is the registered seller of that particular product on that data type, Alternatively, you can use a more over-arching data type that contains the user.

Using the Created by field on the product

Whenever a thing is created in your Bubble database, the Created by (user) field on that thing is populated automatically with the user that created it. This is an easy way to identify the correct seller. However, there are some potential pitfalls that are worth considering:

  • The user needs to be logged in, to be associated with the record they create

  • The Created by field can't be edited

    • If you want to be able to move a product to a different user, you need to create a separate field of type user for this

  • If a user is deleted, the Created by field will be left empty

In a Bubble expression, you would refer to the seller as Product's Created by, provided that the data type is called Product.

Using a separate User field on the product

If you prefer to use a field that you can edit, you can instead set up a field on the product data type that identifies the seller. To do this, simply add a field of type User, and give it a descriptive name such as Seller or Owner. Keep in mind the following:

  • The field will not be populated automatically, meaning that you need to specify the seller in the workflow where the thing is created

  • If the user is deleted, the field will be left empty

In a Bubble expression, you would refer to the seller as Product's Seller.

Using a separate data type

You can also consider using a broader data type to contain seller information. For example, if you have a marketplace where each user sets up a virtual "shop", you may use this data type to store the seller information.

For example, let's imagine that a seller called John Doe sets up a shop called John's Shop. In this case, each product would likely be connected to the shop, instead of directly to the user, looking something like this: Product's Shop. To identify the seller to register with the sale, you would set up the expression like this: Product's Shop's Owner.

This approach can be valuable in certain situations. For instance, if your application facilitates collaborative product management among teams, the shop entity can serve as the data type that connects them.

Let's look at some of the potential pitfalls:

  • The seller sent to Stripe needs to be a user. As such, you will still need to refer to one registered user when sending the charge to Stripe.

  • The initial setup and maintenance is slightly more complex, as you will be dealing with more data types.

  • If privacy rules apply to the products, you may need to as you structure your database

Charging a sale on behalf of a seller

When you are ready to bill a buyer for a purchase linked to a seller, you use the , just like you would with any other one-time payment. The difference is that for this charge, you need to define which seller is responsible for the sale, so that the seller's fee can be registered with Stripe. The seller needs to be registered (see the above step) for this to work.

To instruct Bubble to sell on behalf of another user, and to identify that user, follow these steps:

  1. Check the The payee of this transaction is another user

  2. Assign the seller in the

If your app is to impose a fee on the sale, you can also fill out the field.

Seller payouts in your Bubble app

As the default setting, any funds transferred to a connected account are held in the connected account's (seller's) Stripe balance and are scheduled for daily rolling payouts. If you want to modify the payout frequency, you can do so by changing settings in the Stripe dashboard's payout settings.

For up-to-date information on that process, please check the documentation below:

External page: Stripe Connect Payouts

Other ways to learn

Articles
  • The Bubble API - how to send up API workflows that can receive webhooks from Stripe

  • The API Connector - to set up additional Stripe API calls not supported by the official Stripe plugin, you can use the API Connector

Core reference

The Stripe plugin

External documentation

Stripe docs

  • Stripe Connect (Stripe's marketplace solution)

  • Webhooks (returning data from Stripe to your app upon an event)

As illustrated in our , marketplace apps encompass a broad spectrum of products and services. Interestingly, some apps operate as marketplaces without users always realizing their marketplace nature: for example, Uber and Lyft don't actually own any vehicles, but simply offer a marketplace that connects passengers with drivers and organizes the transaction.

list of different marketplace examples
Marketplace apps connect sellers with customers – whether they are selling physical products, online courses, or something completely different.
The Register the user as a seller action lets you easily create seller accounts in your app. The user will be forwarded to Stripe, but you can pre-populate many of the fields as illustrated above