# Stripe Connect

- Tool: Bubble
- Difficulty: Advanced
- Time required: 3–5 hours
- Last updated: July 2026

## TL;DR

Connect Bubble to Stripe Connect by setting your platform secret key as a Private header in the API Connector, then add calls to create Express accounts, generate Account Links for hosted onboarding, and split charges using application_fee_amount plus transfer_data. A Backend Workflow (paid plan) receives Stripe webhooks to keep your database in sync.

## Why Bubble's Official Stripe Plugin Isn't Enough for Marketplaces

Bubble's built-in Stripe plugin handles single-merchant checkout — it lets one business accept payments from customers. The moment you want to build a marketplace (freelancers, rental owners, multi-vendor store, service platform), you need Stripe Connect: a separate layer that creates individual seller accounts, routes a portion of each payment to them, and handles their payouts.

The Stripe Connect API is entirely server-side. Your platform secret key (sk_*) must never appear in JavaScript or a browser request. Bubble makes this straightforward: everything in an API Connector group with a Private-checked Authorization header runs through Bubble's own servers. This means no CORS errors, no middleware functions, and no extra backend infrastructure.

The two-sided architecture: (1) your customer pays on your Bubble app using the Stripe.js plugin (publishable key only, safe client-side) — the plugin returns a PaymentMethod ID; (2) your API Connector workflow takes that ID and charges the customer via a server-side POST /v1/payment_intents call that includes the seller's Stripe account ID in transfer_data[destination] and your platform fee in application_fee_amount. The seller receives funds automatically.

Onboarding sellers is handled by Stripe's hosted Account Link flow — you call POST /v1/accounts (server-side) to create an Express account, then POST /v1/account_links to generate a URL where the seller completes their KYC. You open that URL in a Bubble popup or redirect the user, and Stripe handles the rest.

Webhooks (payment_intent.succeeded, account.updated, payout.paid) arrive at your Bubble Backend Workflow endpoint and update your database automatically — keeping seller statuses and payment records current without polling.

## Before you start

- A Stripe account with Connect enabled — go to stripe.com/connect and click 'Get started with Connect' to activate the platform features on your account
- Your Stripe platform secret key (sk_test_* for development, sk_live_* for production) — found in Stripe Dashboard → Developers → API keys
- Your Stripe publishable key (pk_test_* or pk_live_*) — for the client-side Stripe.js plugin
- A Bubble app on any plan for API Connector outbound calls; a paid plan (Starter $32/mo or above) if you want to receive Stripe webhooks via Backend Workflows
- A published Bubble app with a real HTTPS domain (not preview.bubble.io) — Stripe's Account Link return_url requires a live HTTPS URL

## Step-by-step guide

### 1. Enable Stripe Connect and Save Your Keys

Before writing a single line of configuration in Bubble, you need to activate the Connect platform in your Stripe account and gather your credentials.

Log in to your Stripe Dashboard at dashboard.stripe.com. In the left sidebar, look for 'Connect' under the Payments section. Click it and then click 'Get started' to enable Connect for your account. Stripe will prompt you to describe your platform type — select the option that best fits your use case (marketplace, software platform, or other).

Once Connect is active, navigate to Developers → API keys in the top-right menu. You will see two keys:
- Publishable key (pk_test_* or pk_live_*): safe to use client-side in the Stripe.js plugin
- Secret key (sk_test_* or sk_live_*): must NEVER appear in browser JavaScript; you will paste this into Bubble's API Connector as a Private header only

Copy both keys and store them temporarily in a secure note. Also take note of your account ID (acct_* shown at the top of the Dashboard) — this is your platform account ID, distinct from the connected seller accounts you will create.

For development, use the test mode keys (toggle 'Test mode' in the Stripe Dashboard top bar). Test mode Stripe Connect lets you create test Express accounts, generate real (but sandbox) Account Links, and simulate payments without charging real cards.

```
// Stripe Connect credentials to collect:
// pk_test_... or pk_live_...  → Stripe.js plugin (publishable, client-safe)
// sk_test_... or sk_live_...  → API Connector Private header (secret, server-only)
// Your platform account ID:   → acct_... (visible in Stripe Dashboard top-right)
```

**Expected result:** Stripe Connect is active on your account, and you have both your publishable and secret keys ready. You can see 'Connect' in your Stripe Dashboard left navigation.

### 2. Configure the API Connector Group with a Private Secret Key

In Bubble, every Stripe Connect call will live in one API Connector group that shares a single Private Authorization header. This one configuration step is what keeps your secret key off the browser.

In your Bubble editor, click Plugins in the left sidebar, then click 'Add plugins'. Search for 'API Connector' — it is a free plugin by Bubble. Click Install.

Once installed, the API Connector appears in your Plugins list. Click 'Add another API' and name the group 'Stripe Connect'. You will now see a section for shared headers and parameters that apply to every call in this group.

In the shared headers section, add one header:
- Key: Authorization
- Value: Bearer sk_test_YOUR_SECRET_KEY (paste your actual secret key here)
- Check the 'Private' checkbox next to this header — this is the critical step. The Private checkbox tells Bubble's infrastructure to store this value encrypted on their servers and inject it only at call time, never sending it to the browser.

With this group set up, you can now add individual API calls inside 'Stripe Connect' — each one will automatically use the private Authorization header. You will never need to copy-paste the secret key again.

Add your first call: click 'Add another call'. Set Method to POST and URL to https://api.stripe.com/v1/accounts. Name this call 'Create Express Account'. Set 'Use as' to Action (since you are creating a resource, not fetching data to display).

```
{
  "api_group": "Stripe Connect",
  "shared_headers": [
    {
      "key": "Authorization",
      "value": "Bearer sk_test_YOUR_SECRET_KEY",
      "private": true
    }
  ],
  "calls": [
    {
      "name": "Create Express Account",
      "method": "POST",
      "url": "https://api.stripe.com/v1/accounts",
      "body_params": [
        { "key": "type", "value": "express" }
      ],
      "use_as": "Action"
    },
    {
      "name": "Create Account Link",
      "method": "POST",
      "url": "https://api.stripe.com/v1/account_links",
      "body_params": [
        { "key": "account", "value": "<acct_id dynamic>" },
        { "key": "refresh_url", "value": "https://yourapp.com/reauth" },
        { "key": "return_url", "value": "https://yourapp.com/onboarding-complete" },
        { "key": "type", "value": "account_onboarding" }
      ],
      "use_as": "Action"
    },
    {
      "name": "Create PaymentIntent",
      "method": "POST",
      "url": "https://api.stripe.com/v1/payment_intents",
      "body_params": [
        { "key": "amount", "value": "<integer cents dynamic>" },
        { "key": "currency", "value": "usd" },
        { "key": "application_fee_amount", "value": "<fee integer cents dynamic>" },
        { "key": "transfer_data[destination]", "value": "<acct_id dynamic>" },
        { "key": "payment_method", "value": "<pm_id dynamic>" },
        { "key": "confirm", "value": "true" }
      ],
      "use_as": "Action"
    }
  ]
}
```

**Expected result:** You have a 'Stripe Connect' API Connector group with a Private Authorization header. The 'Create Express Account' call is initialized and Bubble has detected the 'id' (acct_*) field in the response.

### 3. Set Up the Bubble Database and User Fields for Stripe

Before building workflows, you need to store the Stripe account data in Bubble's database. Every connected seller needs a Stripe Express account ID and an onboarding status — these live on the User data type.

Go to the Data tab in your Bubble editor. Click on the 'User' data type. Add two new fields:
- stripe_account_id (type: text) — stores the acct_* ID of the seller's Express account
- onboarding_complete (type: yes/no, default: no) — tracks whether the seller has finished Stripe's KYC onboarding

If you are building a marketplace where a single user can be both a buyer and a seller, add a third field:
- is_seller (type: yes/no, default: no) — marks which users are registered sellers

For storing customer payment data (on the buyer side), create a separate data type called 'Stripe Customer' with fields:
- stripe_customer_id (text) — the cus_* Stripe customer ID
- user (User) — link to the Bubble user who owns this record

Now go to Data → Privacy. Click on your User type and add a rule: 'Find this in searches' should be restricted to 'Current User's stripe_account_id = User's stripe_account_id' or simply 'This User is the Current User'. This prevents sellers from seeing each other's Stripe account IDs through Bubble's API responses.

The privacy rule on stripe_account_id is not optional — without it, any user who queries your app's User list in a Repeating Group will be able to read other sellers' Stripe account IDs, which should be considered sensitive credentials.

```
// Bubble Data Types to create:

// User data type — add these fields:
// stripe_account_id   → Text
// onboarding_complete → Yes/No (default: No)
// is_seller           → Yes/No (default: No)

// Stripe Customer data type:
// stripe_customer_id  → Text
// user                → User

// Privacy Rule on User (Data → Privacy → User):
// Field: stripe_account_id
// Rule: only visible to Current User (This User = Current User)
```

**Expected result:** Your User data type has stripe_account_id and onboarding_complete fields. A privacy rule restricts stripe_account_id to the owning user only. The Stripe Customer data type is created for buyer-side data.

### 4. Build the Seller Onboarding Workflow with Account Links

The seller onboarding flow has three steps: create a Stripe Express account, generate a hosted onboarding URL, and open that URL so the seller can complete KYC. This entire flow runs in one Bubble workflow triggered by a 'Become a Seller' button.

In the Workflow editor, create a new workflow triggered by a button click (e.g., 'Apply as Seller' button on your seller registration page).

Action 1 — Create Express Account: Add a 'Plugins → Stripe Connect - Create Express Account' action. This calls the API Connector with no extra parameters needed — Stripe creates an empty Express account and returns an acct_* ID.

Action 2 — Save acct_* to User: Add a 'Make changes to current user' action. Set stripe_account_id to the result from the previous step: 'Result of step 1's id'.

Action 3 — Create Account Link: Add a 'Plugins → Stripe Connect - Create Account Link' action. Set the 'account' parameter to 'Current User's stripe_account_id' (the value you just saved in step 2). Set 'return_url' to your live app's onboarding complete page — for example, https://yourapp.com/seller-onboarding-complete. Set 'refresh_url' to your re-authorization page. Set 'type' to account_onboarding.

IMPORTANT: The return_url and refresh_url must be your published app's real HTTPS domain (e.g., https://yourapp.bubbleapps.io or your custom domain). Stripe rejects preview.bubble.io URLs. This means you must test this flow on a published version of your app, not in Bubble's editor preview.

Action 4 — Open Onboarding URL: Add an 'Open external website' action. Set the URL to 'Result of step 3's url' (the Account Link URL). Check 'Open in new tab' to keep your app open in the background.

Create a separate workflow for the seller's return from Stripe: when the page /seller-onboarding-complete loads, run 'Make changes to current user' → set onboarding_complete to yes. You can also call GET /v1/accounts/{id} to verify the onboarding status before marking it complete — Stripe returns charges_enabled: true when the account is fully activated.

```
// Workflow: 'Become a Seller' button click
// Step 1: Call API → Stripe Connect - Create Express Account
//         (no body params needed for a basic Express account)
//         Response: { "id": "acct_1ABC...", "type": "express", ... }

// Step 2: Make changes to Current User
//         stripe_account_id = Result of Step 1's id

// Step 3: Call API → Stripe Connect - Create Account Link
//         account         = Current User's stripe_account_id
//         return_url      = https://yourapp.com/seller-onboarding-complete
//         refresh_url     = https://yourapp.com/seller-reauth
//         type            = account_onboarding
//         Response: { "object": "account_link", "url": "https://connect.stripe.com/..." }

// Step 4: Open external website
//         URL = Result of Step 3's url
//         Open in new tab: yes

// Separate page workflow: /seller-onboarding-complete page is loaded
// Step 1: Make changes to Current User
//         onboarding_complete = yes
```

**Expected result:** Clicking 'Become a Seller' creates a Stripe Express account for the user, saves their acct_* ID, generates a hosted onboarding URL, and opens Stripe's KYC flow in a new tab. Returning to /seller-onboarding-complete marks them as onboarded.

### 5. Create the Marketplace Payment Workflow with Fee Splits

This is the core payment action: a customer pays for a service or product, Bubble charges their card server-side via the API Connector, splits the payment between your platform and the seller, and stores the result in your database.

The payment flow assumes you have already collected the customer's card using the Stripe.js plugin (or Zeroqode's Stripe Payments plugin), which returns a PaymentMethod ID (pm_*). This pm_* is the bridge between the client-side card collection and the server-side charge.

In your Workflow editor, create a 'Checkout' button workflow:

Action 1 — Get the seller's Stripe account ID: This is already stored on the User or Listing record — retrieve it with 'Search for Products's seller's stripe_account_id' or however your data model links listings to sellers.

Action 2 — Calculate amounts: Bubble workflows let you 'Calculate' expressions. Compute two values and store them as Custom States or use them inline:
- total_cents: price × 100 (e.g., $49.99 → 4999)
- fee_cents: total_cents × 0.15 (your 15% platform fee)

Action 3 — Create PaymentIntent: Call the 'Stripe Connect - Create PaymentIntent' API Connector action with:
- amount: total_cents (must be an integer — round the result)
- currency: usd
- application_fee_amount: fee_cents (your platform's cut, in cents)
- transfer_data[destination]: seller's stripe_account_id
- payment_method: the pm_* from the Stripe.js plugin
- confirm: true

Action 4 — Handle the response: Stripe returns a PaymentIntent with a status field. If status = 'succeeded', the payment is complete. If status = 'requires_action', the card requires 3D Secure authentication — you will need to call Stripe.js handleNextAction(client_secret) using a 'Run JavaScript' action (Toolbox plugin required).

Action 5 — Save to database: Create a 'Payment' record in Bubble with the payment_intent_id, amount, buyer, seller, and status. This lets you track all transactions and build a dashboard.

RapidDev's team has configured hundreds of Stripe Connect marketplace flows in Bubble — if your pricing model or payout structure is complex, a free scoping call at rapidevelopers.com/contact can save significant debugging time.

```
{
  "call": "POST https://api.stripe.com/v1/payment_intents",
  "headers": {
    "Authorization": "Bearer sk_test_<private>",
    "Content-Type": "application/x-www-form-urlencoded"
  },
  "body": {
    "amount": "4999",
    "currency": "usd",
    "application_fee_amount": "750",
    "transfer_data[destination]": "acct_1ABCXYZSeller",
    "payment_method": "pm_1DEFGHICard",
    "confirm": "true"
  },
  "response": {
    "id": "pi_1JKLMNOCharge",
    "amount": 4999,
    "application_fee_amount": 750,
    "status": "succeeded",
    "transfer_data": {
      "destination": "acct_1ABCXYZSeller"
    }
  }
}
```

**Expected result:** Clicking Checkout triggers a server-side PaymentIntent that charges the customer's card, routes the platform fee to your Stripe account, and transfers the remainder to the seller's Express account. The payment_intent_id is stored in your Bubble database.

### 6. Set Up Backend Workflows to Receive Stripe Webhooks

Stripe sends webhook events to notify your app of asynchronous events — payment confirmations, seller onboarding completions, and payout updates. In Bubble, these arrive at a Backend Workflow endpoint. This step requires a paid Bubble plan (Starter $32/month or above).

To enable Backend Workflows: go to your Bubble editor → Settings → API tab. Check the box 'This app exposes a Workflow API' and save. This activates the Backend Workflows section in the left sidebar.

Create your first Backend Workflow: click 'Backend Workflows' → 'New API Workflow'. Name it 'stripe_webhook'. Set it to 'Run without authentication' (Stripe's webhook requests don't carry Bubble session tokens).

Click 'Detect request data'. Bubble will generate an endpoint URL like https://yourapp.bubbleapps.io/api/1.1/wf/stripe_webhook. Copy this URL.

In your Stripe Dashboard, go to Developers → Webhooks → Add endpoint. Paste your Bubble Backend Workflow URL. Select the events you want to listen to: payment_intent.succeeded, account.updated, and payout.paid are the most important for a Connect marketplace.

Back in Stripe Dashboard, send a test event (click 'Send test webhook'). In Bubble, click 'Stop detecting' — Bubble will show you the JSON structure of the incoming event. You will see fields like type (event type string) and data.object (the payment or account object).

Now build workflow logic inside your stripe_webhook Backend Workflow:
- Add a condition: when event type = 'payment_intent.succeeded' → find the Payment record matching the payment_intent_id → set status to Paid
- When event type = 'account.updated' → find the User matching the stripe_account_id → set onboarding_complete to yes if charges_enabled = true

Note: Bubble cannot natively verify Stripe's webhook signature header (Stripe-Signature). As a workaround, you can add a secret query parameter to your webhook URL (e.g., ?secret=mytoken) and check it in the workflow condition before processing the event.

```
// Stripe Webhook endpoint for Bubble Backend Workflow:
// https://yourapp.bubbleapps.io/api/1.1/wf/stripe_webhook

// Sample Stripe webhook payload (payment_intent.succeeded):
{
  "id": "evt_1PQRSTEvent",
  "type": "payment_intent.succeeded",
  "data": {
    "object": {
      "id": "pi_1JKLMNOCharge",
      "amount": 4999,
      "currency": "usd",
      "status": "succeeded",
      "transfer_data": {
        "destination": "acct_1ABCXYZSeller"
      }
    }
  }
}

// Stripe Dashboard → Developers → Webhooks → Add endpoint:
// URL: https://yourapp.bubbleapps.io/api/1.1/wf/stripe_webhook
// Events: payment_intent.succeeded, account.updated, payout.paid
```

**Expected result:** Your Backend Workflow is live and registered with Stripe. Stripe successfully sends test events that Bubble receives, and your database updates payment status and seller onboarding state automatically.

## Best practices

- Always mark the Authorization header as Private in the API Connector — this is the single most important security step. Without it, your sk_* secret key is visible in every user's browser network tab.
- Never save Account Link URLs in your Bubble database — they expire after a few minutes. Generate them fresh immediately before redirecting the seller.
- Use Bubble's Privacy Rules to restrict the stripe_account_id field on the User type to the owning user. Without this rule, any Repeating Group querying the User table will expose all sellers' Stripe account IDs.
- Always include both application_fee_amount AND transfer_data[destination] on every marketplace PaymentIntent — omitting either one silently misdirects funds.
- Convert prices to cents immediately before passing to Stripe: multiply your Bubble decimal price field by 100 and use the Round function to avoid floating-point values like 4999.9999 that Stripe will reject.
- Assign unique idempotency keys (Stripe-Idempotency-Key header) to every PaymentIntent creation call — use a combination of the booking ID and a timestamp — to prevent duplicate charges if a workflow re-runs due to a Bubble timeout.
- Monitor your WU (Workload Units) usage in Bubble Settings → Usage. Each API Connector call to Stripe consumes WU — high-volume marketplaces receiving hundreds of webhook events per day should plan for WU costs beyond the plan's base allowance.
- Test the entire onboarding-to-payment flow end-to-end in test mode before going live. Stripe provides test account personas (partial/complete KYC) that let you simulate different seller states without using real identity documents.

## Use cases

### Freelance Marketplace

A platform where clients post projects and freelancers bid. When a client pays for a project, Bubble splits the payment: the freelancer receives their fee and the platform takes a percentage. Each freelancer onboards via Stripe Express using the Account Link flow.

Prompt example:

```
Build a Bubble workflow that calls POST /v1/payment_intents with amount, currency, application_fee_amount set to 15% of the total, and transfer_data[destination] set to the freelancer's Stripe account ID stored in the User data type.
```

### Rental Property Platform

Property owners list spaces and guests book them. On checkout, Bubble charges the guest via Stripe Connect, routes the nightly rate to the property owner's Express account, and keeps a service fee for the platform. Webhook events update booking status in real time.

Prompt example:

```
Set up a Bubble Backend Workflow that listens for payment_intent.succeeded events from Stripe, finds the matching Booking record by payment_intent_id, and changes the booking status from Pending to Confirmed.
```

### Multi-Vendor Marketplace

Multiple sellers list products in one storefront. Buyers check out with a cart containing items from different vendors. Bubble creates a separate PaymentIntent per vendor with per-item splits, using transfer_data to route funds to the correct Express account for each line item.

Prompt example:

```
Design a Bubble workflow that loops through cart items, groups them by seller, creates one PaymentIntent per seller group with the appropriate application_fee_amount and transfer_data[destination], and stores all payment intent IDs in the Order record.
```

## Troubleshooting

### Stripe returns a 400 error on the Account Link call with 'No such account'

Cause: The acct_* ID passed to POST /v1/account_links does not exist in your Stripe account, or the ID is being read from a Bubble state that was not saved correctly after step 2 of the workflow.

Solution: Verify that your workflow Action 2 (Make changes to Current User → stripe_account_id) runs and saves before Action 3 calls Create Account Link. In Bubble, actions run sequentially within a workflow, so the save should complete before the next action reads it. Use the Bubble Debugger (step-by-step mode) to inspect the value of Current User's stripe_account_id at the moment the Account Link call fires.

### Account Link redirect fails with 'Invalid return_url' error from Stripe

Cause: The return_url in your Create Account Link call contains a preview.bubble.io URL or localhost. Stripe requires a published, live HTTPS domain for all Connect redirect URLs.

Solution: Publish your Bubble app (click the Deploy button) and use your live domain in the return_url parameter — for example, https://yourapp.bubbleapps.io/seller-onboarding-complete or your custom domain. Never use the editor preview URL for Stripe Connect testing.

### PaymentIntent shows status 'succeeded' but the seller's Stripe account received no transfer

Cause: The application_fee_amount and/or transfer_data[destination] parameter is missing from the PaymentIntent call. Without transfer_data[destination], the full charge goes to your platform account.

Solution: Open your API Connector → Stripe Connect → Create PaymentIntent call and verify that both transfer_data[destination] and application_fee_amount are listed as body parameters with values. The key notation for nested params in API Connector is exactly transfer_data[destination] (with square brackets). Use the Bubble Logs tab → Workflow logs to see the exact request body that was sent to Stripe.

```
{
  "body": {
    "amount": "4999",
    "currency": "usd",
    "application_fee_amount": "750",
    "transfer_data[destination]": "acct_1ABCXYZSeller",
    "payment_method": "pm_...",
    "confirm": "true"
  }
}
```

### 'Workflow API is not enabled' error when trying to receive Stripe webhooks

Cause: Backend Workflows are not available on the Bubble Free plan. The 'This app exposes a Workflow API' setting is greyed out or missing.

Solution: Upgrade to a paid Bubble plan (Starter $32/month or above) to unlock Backend Workflows. As a temporary workaround on the free plan, you can poll Stripe's GET /v1/payment_intents/{id} from a Bubble scheduled workflow to check payment status — but this is less reliable, adds latency, and consumes WU for every poll.

### Initialize call fails with 'There was an issue setting up your call'

Cause: The API Connector could not get a successful response from Stripe — usually because the secret key is incorrect, or the test body params are insufficient for Stripe to create a test resource.

Solution: For the Create Express Account call, ensure your Authorization header has the correct sk_test_* key. The Private checkbox must be checked. For Initialize, add at least one body param: key='type', value='express'. Click Initialize — Stripe will create a real test account in sandbox mode and return a 200 response with an id field.

## Frequently asked questions

### Can I use the regular Bubble Stripe plugin for Connect marketplace payments?

No. The native Bubble Stripe plugin and the free Stripe.js plugin handle single-merchant checkout only — they do not support Stripe Connect's Express account creation, Account Links, or the application_fee_amount / transfer_data parameters on PaymentIntents. You must use the API Connector for all Connect-specific calls, with your platform secret key stored as a Private header.

### Do I need a paid Bubble plan for Stripe Connect?

For outbound API calls (creating accounts, generating Account Links, charging customers), the Free plan works. However, to receive inbound Stripe webhook events (payment_intent.succeeded, account.updated), you need Backend Workflows — a feature available only on paid Bubble plans (Starter $32/month or above). Without webhooks, you can poll Stripe's API instead, but this is less reliable and consumes more WU.

### How do I test the seller onboarding flow without publishing my app?

You cannot test Stripe's Account Link redirect flow in Bubble's editor preview — Stripe requires a real HTTPS return_url. Publish your app to your Bubble staging environment (e.g., yourapp.bubbleapps.io) and test there with Stripe test mode keys. This gives you a live URL without needing a custom domain.

### What happens if a seller has not completed Stripe onboarding and a customer tries to pay them?

The PaymentIntent will succeed (the payment is captured), but Stripe will hold the funds in your platform account rather than transferring them to the seller. Once the seller completes onboarding and charges_enabled becomes true, Stripe releases the held funds. Always check Current User's onboarding_complete field before allowing customers to book or purchase from a seller.

### How do I handle currency conversion for international sellers?

Stripe Connect handles currency conversion automatically. You charge in the customer's currency (e.g., USD) and configure the seller's payout currency in their Express account settings (e.g., EUR). Stripe applies its own exchange rate and conversion fee. Your API Connector call only needs to specify the charge currency — the seller's payout currency is managed by Stripe directly.

---

Source: https://www.rapidevelopers.com/bubble-integrations/stripe-connect
© RapidDev — https://www.rapidevelopers.com/bubble-integrations/stripe-connect