# Podia

- Tool: Bubble
- Difficulty: Intermediate
- Time required: 2–4 hours
- Last updated: July 2026

## TL;DR

Connect Bubble to Podia by adding the free API Connector plugin, pointing it at `https://api.podia.com/v1`, and storing your Podia API key as a Private Bearer token header. Podia's API covers five product types — courses, downloads, webinars, coaching, and memberships — letting you build a fully branded creator storefront in Bubble while Podia handles all payments and content delivery. API access requires the Mover plan ($33/mo) or above.

## Bubble + Podia: a fully branded creator storefront for all five product types

Podia's core value proposition is that one platform covers every revenue stream a digital creator needs — online courses, downloadable files, live webinars, one-on-one coaching, and community memberships. Its native storefront is clean and functional, but it is Podia-branded and fixed in layout. Connecting Bubble to Podia's REST API gives you the best of both worlds: Podia continues to handle payments, content delivery, email, and community infrastructure, while Bubble provides a fully custom, branded frontend that you design pixel-by-pixel.

The integration centers on Podia's `/products` endpoint, which returns your entire catalog in a single response. Each product in the response includes a `type` field that identifies which of the five product categories it belongs to. In Bubble, you use this `type` field to build a segmented UI — separate tabs or sections for courses, downloads, webinars, coaching slots, and memberships — each with the appropriate information architecture. A webinar card needs a date/time field; a digital download needs a file-type badge; a coaching product needs a session-length call-to-action.

The one area where Podia imposes a hard boundary is payments: Bubble must never process Podia transactions. Every product in the `/products` response includes a `url` field — this is the Podia-hosted checkout URL. Bubble's role is to display the product attractively and link the purchase button to that URL. Podia's checkout handles payment, confirmation email, and content access.

For creators who want a revenue dashboard inside their Bubble app, the `/sales` endpoint returns transaction records. Because Podia's sales endpoint can be slow for accounts with large transaction histories, the right architecture is a scheduled API Workflow (available on Bubble's paid plans) that syncs sales data into a Bubble Data Type once daily, then displays from Bubble's fast native database throughout the day. RapidDev has built creator dashboards and storefront apps using this exact pattern — reach out for a free scoping call at rapidevelopers.com/contact if you want help designing the sync architecture.

## Before you start

- A Podia account on the Mover plan ($33/mo) or Shaker plan ($89/mo) — the Free plan has no API section in Podia Store Settings
- Your Podia API key from Podia Store Settings → API (generated once your account is on a paid plan)
- A Bubble app (any plan for read-only display; paid Bubble plan required for scheduled Backend Workflows to sync sales data)
- The free API Connector plugin by Bubble installed in your app (Plugins → Add plugins → search 'API Connector')
- At least one published product in your Podia store so the Initialize call returns a real response shape

## Step-by-step guide

### 1. Step 1 — Verify your Podia plan and generate your API key

Before opening Bubble, confirm that your Podia account is on the Mover ($33/mo) or Shaker ($89/mo) plan. The Free plan does not include API access — the API section simply does not appear in Store Settings on Free accounts. Log in to Podia at podia.com. In the top-right, click your account avatar and select 'Store Settings' from the dropdown. Look for an 'API' section in the left navigation of Store Settings. If it appears, click it. You will see an option to generate or reveal your API key. Click 'Generate API Key' (or 'Reveal' if one already exists). Copy the key immediately and save it in a secure location such as a password manager — treat it with the same care as a password. This single API key grants access to your entire Podia store data including products, sales, and subscriber information. You will also want to note your store's base URL pattern; all Podia API calls use `https://api.podia.com/v1` as the base URL regardless of your store's custom domain. If the API section does not appear in Store Settings, you are on the Free plan and must upgrade before proceeding.

```
// Podia API reference
// Base URL: https://api.podia.com/v1
//
// Authentication: Bearer token in Authorization header
// Header Key:   Authorization
// Header Value: Bearer YOUR_PODIA_API_KEY
//
// Key endpoints:
// GET /products          - list all products (all 5 types)
// GET /products/{id}     - single product detail
// GET /sales             - transaction records
// GET /subscribers       - email subscriber list
//
// Plan requirement: Mover ($33/mo) or Shaker ($89/mo)
// Free plan: NO API section in Store Settings
```

**Expected result:** You have your Podia API key copied and saved securely. You have confirmed that your Podia account is on the Mover or Shaker plan. You know the base URL is `https://api.podia.com/v1`.

### 2. Step 2 — Install the API Connector and configure the Podia API group

Open your Bubble app editor and click 'Plugins' in the left sidebar. If the API Connector by Bubble is not already installed, click 'Add plugins,' search for 'API Connector,' and install it — it is free. Return to the Plugins tab and click 'API Connector.' Click 'Add another API.' Name this API group 'Podia.' In the 'Root URL' field, enter `https://api.podia.com/v1`. Under 'Shared headers across all calls,' click 'Add a shared header.' For the key, type `Authorization`. For the value, type `Bearer ` followed immediately by your Podia API key — for example: `Bearer abc123yourkeyhere`. Check the 'Private' checkbox next to this header. This is critical: the Private flag tells Bubble to use this header only on server-side calls and never expose it in the browser's network requests, protecting your API key from any visitor who opens DevTools. Add a second shared header: key `Accept`, value `application/json` — no Private checkbox needed. This tells Podia to always return JSON. Your API group is now configured. All API calls you add under 'Podia' will automatically send both headers with every request.

```
// Bubble API Connector — Podia group configuration
{
  "api_group_name": "Podia",
  "root_url": "https://api.podia.com/v1",
  "shared_headers": [
    {
      "key": "Authorization",
      "value": "Bearer YOUR_PODIA_API_KEY",
      "private": true
    },
    {
      "key": "Accept",
      "value": "application/json"
    }
  ]
}
```

**Expected result:** The Podia API group appears in your API Connector with root URL `https://api.podia.com/v1` and two shared headers: Authorization (marked Private) and Accept. No individual API calls have been added yet.

### 3. Step 3 — Add the 'Get Products' API call and initialize it

Inside the Podia API group, click 'Add call.' Name this call 'Get Products.' Set the method to GET. In the endpoint field, type `/products` — Bubble will append this to the root URL, resulting in a call to `https://api.podia.com/v1/products`. Set 'Use as' to 'Data' — this tells Bubble the response should be mappable to a list data type that you can bind to Repeating Groups. Now click 'Initialize call.' Bubble fires a real GET request to Podia using your Private Bearer token. If your API key is valid and your Podia account has at least one published product, Podia returns a JSON response containing an array of product objects. Bubble detects the response structure and makes all fields available in the editor's dynamic data dropdowns. Pay close attention to the `type` field in each product object — this will be your key to filtering products by category (`online_course`, `digital_download`, `webinar`, `coaching`, `membership`). Also note the `price` field: Podia returns prices as integers in **cents** — a $49 product returns `4900`. Every price display in Bubble must divide this value by 100. Click 'Save.' If the Initialize call returns an error, check that your API key is correct and that your Podia store has at least one published product (an empty catalog returns an empty array and Bubble cannot detect field names).

```
// GET /products — Podia API response structure
{
  "products": [
    {
      "id": "12345",
      "name": "Mastering Content Strategy",
      "type": "online_course",
      "price": 4900,
      "currency": "usd",
      "url": "https://yourstore.podia.com/mastering-content-strategy",
      "image_url": "https://cdn.podia.com/images/...",
      "description": "Learn to build a content engine...",
      "published": true
    },
    {
      "id": "12346",
      "name": "Brand Toolkit PDF",
      "type": "digital_download",
      "price": 1500,
      "currency": "usd",
      "url": "https://yourstore.podia.com/brand-toolkit",
      "image_url": "https://cdn.podia.com/images/...",
      "published": true
    }
  ]
}

// IMPORTANT: price is in CENTS
// Display: Current cell's product's price / 100 → format as currency
// $49.00 product → price field = 4900
```

**Expected result:** The 'Get Products' call is initialized with a green checkmark. Bubble shows detected response fields including product `id`, `name`, `type`, `price`, `url`, `image_url`, and `published`. The call is set to 'Use as: Data.' You can see the `price` field contains an integer (cents value).

### 4. Step 4 — Build a segmented product storefront with type-based tabs

With the Get Products call initialized, you can now build the core creator storefront page. The design pattern is a segmented tab interface where each tab shows products of one type, each with a type-appropriate card layout. In your Bubble page, add a Tab Group element (or use a Group with custom states to simulate tabs) with five tabs: 'Courses,' 'Downloads,' 'Webinars,' 'Coaching,' and 'Memberships.' Inside each tab, add a Repeating Group. For the 'Courses' tab Repeating Group: set 'Type of content' to 'Podia - Get Products - product' (or similar — Bubble names this from the call name). Set 'Data source' to 'Get data from external API → Podia → Get Products.' Inside the Repeating Group cell, add: an Image element bound to `Current cell's product's image_url`; a Text element for `Current cell's product's name`; a Text element for price — use the expression `Current cell's product's price / 100 :formatted as $#,##0.00` to convert cents to dollars; a Button labeled 'Buy Now' whose 'Open an external website' action links to `Current cell's product's url`. For each additional tab Repeating Group, change the data source filter: add a ':filtered' condition where `type = 'digital_download'` (or whichever type matches that tab). Webinar cards should additionally display a date/time field if Podia's response includes it for webinar products. Coaching cards should display a session-length field and a CTA like 'Book a Session.' Do NOT implement any payment processing in Bubble — the `url` field always points to Podia's hosted checkout, and that is where the transaction happens.

```
// Bubble Repeating Group setup — Courses tab
// Type of content: Podia - Get Products - product
// Data source: Get data from external API → Podia - Get Products
// :filtered where type = 'online_course'

// Inside RG cell:
// Image element:   Source = Current cell's product's image_url
// Text (name):     Current cell's product's name
// Text (price):    Current cell's product's price / 100 :formatted as $#,##0.00
// Text (type):     'Online Course'  (static label for visual badge)
// Button (Buy):    Open external URL = Current cell's product's url

// For Downloads tab:
// :filtered where type = 'digital_download'
// Add file-type badge (static text or icon based on product name extension)

// For Webinars tab:
// :filtered where type = 'webinar'
// Add date/time display if available in response

// For Coaching tab:
// :filtered where type = 'coaching'
// CTA text: 'Book a Session'

// For Memberships tab:
// :filtered where type = 'membership'
// Consider monthly vs. annual price display
```

**Expected result:** Your storefront page displays five tabs. Each tab shows the appropriate Podia products in a Repeating Group. Product names, images, and prices (in dollars, not cents) display correctly. The 'Buy Now' button on each card opens Podia's hosted checkout in a new tab. Bubble never sees payment information.

### 5. Step 5 — Add a sales revenue endpoint and sync to a Bubble Data Type

For creators who want a revenue dashboard alongside the storefront, add a second API Connector call under the Podia group. Click 'Add call' → name it 'Get Sales.' Method: GET. Endpoint: `/sales`. Set 'Use as' to 'Data.' Click 'Initialize call' to detect the response structure, which includes fields like `product_id`, `product_type`, `amount` (in cents), `created_at`, and `status`. Rather than displaying sales data live from Podia's API on every page load (which can be slow for accounts with many transactions), build a Bubble Backend Workflow that syncs this data into a Bubble Data Type. First, create a Bubble Data Type called 'PodiaSale' with fields: `podia_product_id` (text), `product_type` (text), `product_name` (text), `amount_cents` (number), `sale_date` (date), `status` (text). In Bubble's editor, go to the Backend Workflows section (requires a paid Bubble plan — Settings → API → enable 'This app exposes a Workflow API' and then look for the Backend Workflows section). Create a workflow called 'Sync Podia Sales.' Inside this workflow, add a step to call the Podia 'Get Sales' API, then for each record in the response, create or update a PodiaSale record in Bubble's database. Schedule this workflow to run once daily using Bubble's recurring schedule feature. Your revenue dashboard page then queries `Search for PodiaSales` from Bubble's native database — fast, no Podia API rate limits, and data is always available even if Podia's API is momentarily slow.

```
// Bubble Data Type: PodiaSale
// Fields:
//   podia_product_id  (text)   — Podia's product ID
//   product_type      (text)   — 'online_course', 'digital_download', etc.
//   product_name      (text)   — product name at time of sale
//   amount_cents      (number) — sale amount in cents
//   sale_date         (date)   — when the sale occurred
//   status            (text)   — 'completed', 'refunded', etc.

// Revenue dashboard expressions:
// Total revenue: Search for PodiaSales:sum of amount_cents / 100
// Sales by type: Search for PodiaSales:filtered where product_type = 'online_course':count
// Monthly revenue: Search for PodiaSales:filtered where sale_date > 30 days ago:sum of amount_cents / 100

// GET /sales — sample response
{
  "sales": [
    {
      "id": "sale_999",
      "product_id": "12345",
      "product_type": "online_course",
      "amount": 4900,
      "status": "completed",
      "created_at": "2026-06-15T14:22:00Z"
    }
  ]
}
```

**Expected result:** A 'Sync Podia Sales' Backend Workflow is created and scheduled to run daily. The PodiaSale Data Type is populated with transaction records from Podia. Your revenue dashboard page queries PodiaSale records from Bubble's database and displays total revenue, sales count by product type, and a date-based trend — without making live Podia API calls on each page load.

### 6. Step 6 — Apply privacy rules to stored sales and subscriber data

Any Podia data that Bubble stores in its database — sales records, subscriber emails, revenue figures — must be protected by Bubble's privacy rules. Without privacy rules, logged-in users of your Bubble app could query stored data types via the browser using Bubble's native API. This is especially important for creator revenue data: a competitor or curious user should never be able to extract your sales figures from your Bubble app. In the Bubble editor, go to the Data tab → Privacy. Select the 'PodiaSale' Data Type (and any other Data Types you created, such as 'PodiaProduct'). Under 'Define rules for who can see this,' set the rule to restrict access. For a single-creator dashboard, the most practical rule is: 'This Privacy Rule applies when → Current User is logged in AND Current User's email is admin@yourdomain.com' (or better, add an `is_admin` boolean field to the Bubble User type and set the rule to 'Current User's is_admin = yes'). Under 'When this rule applies,' check 'Find this in searches' and 'See these fields.' Under 'When this rule does NOT apply,' uncheck all options. This ensures that only your admin user can query PodiaSale records — no other logged-in or anonymous user can access the data. Apply the same rule to any Data Type that stores subscriber emails or personal information synced from Podia.

```
// Bubble Privacy Rule for PodiaSale Data Type
// Data tab → Privacy → PodiaSale
//
// Rule: 'Admin Only'
// Condition: Current User's is_admin = yes
//
// When rule applies:
//   [x] Find this in searches
//   [x] See these fields → All Fields
//
// When rule does NOT apply:
//   [ ] Find this in searches    (blocked)
//   [ ] See any fields           (blocked)
//
// Bubble User Data Type: add field
//   is_admin (yes/no, default: no)
//
// Set is_admin = yes only for your account via
// Bubble's App Data tab → User records → edit your user
```

**Expected result:** The PodiaSale Data Type (and any other Podia-related Data Types) has a privacy rule that restricts visibility to admin users only. Anonymous visitors and non-admin logged-in users cannot query or see revenue data even if they inspect Bubble's API calls in the browser.

## Best practices

- Always mark the Podia Authorization header as 'Private' in the API Connector — this single checkbox ensures your API key is used only server-side on Bubble's infrastructure and never appears in a visitor's browser DevTools network tab
- Divide every Podia `price` field by 100 before displaying it — Podia returns all prices in cents as integers, and forgetting this step produces prices 100× larger than the actual amount
- Link purchase buttons to Podia's `product.url` (the hosted checkout page) rather than building any payment flow in Bubble — Podia handles payment, fulfillment, content access, and receipt emails through its own checkout
- Build the revenue dashboard with a scheduled sync to a Bubble Data Type rather than querying `/sales` live on each page load — Podia's sales endpoint can be slow with large catalogs, and Bubble's native database is significantly faster for display queries
- Apply Bubble Data tab → Privacy rules to any Data Type that stores Podia sales, revenue, or subscriber data — without privacy rules, logged-in users can query this data via Bubble's database API
- Consume Bubble Workload Units (WU) mindfully: schedule the sales sync to run once daily rather than hourly, and serve storefront product data from a cached Bubble Data Type during high-traffic periods rather than calling Podia's API per page load
- Re-initialize your Podia API Connector calls after any Podia platform update — Podia's API is explicitly described as evolving, and field names or response structures can change without a version bump
- Store the Podia API key in Bubble's Environment Variables (App Data → Environment Variables) and reference the variable in the API Connector header value, rather than pasting the key directly in the header field — this makes it easier to rotate the key across all API calls simultaneously

## Use cases

### Branded multi-type creator storefront

A creator with five product types — courses, downloads, webinars, coaching, and memberships — wants a custom storefront that matches their brand instead of Podia's default layout. A Bubble page fetches all products from `/products` and segments them into tabs by `type`. Each tab renders a type-appropriate card: course cards show curriculum previews, download cards show file-type badges, webinar cards show upcoming dates, and coaching cards show session-length CTAs. The Buy button on every card links to the Podia-hosted checkout URL so Podia handles payment.

Prompt example:

```
On page load, call Podia API 'Get Products'; display results in a Tab Group where each tab filters the Repeating Group by product type: 'online_course', 'digital_download', 'webinar', 'coaching', 'membership'; format price as Current cell's product's price / 100 formatted as currency
```

### Creator revenue and sales dashboard

A course creator wants a private Bubble dashboard showing their monthly revenue breakdown by product, total sales count, and a trend chart. A Backend Workflow runs daily, calls Podia's `/sales` endpoint, and stores each transaction in a Bubble `PodiaSale` Data Type with fields for product ID, product type, amount (cents), and sale date. The dashboard page queries from Bubble's database rather than Podia's API, calculating totals and percentages with Bubble's built-in aggregation expressions and rendering a trend chart with the Charts plugin.

Prompt example:

```
Schedule daily Backend Workflow: call Podia '/sales', create PodiaSale record for each new transaction with product_id, product_type, amount_cents, and sale_date; on Dashboard page, display sum of amount_cents / 100 by product_type in a bar chart
```

### Membership gating with Podia subscriber check

A creator runs a Podia membership community and wants their Bubble app's premium content to be gated behind active membership status. When a user logs into the Bubble app, a workflow calls Podia's `/subscribers` or `/memberships` endpoint to check whether the logged-in user's email has an active membership. If yes, Bubble stores an `is_member = true` custom state and shows premium content. If no, Bubble redirects to the Podia membership purchase URL.

Prompt example:

```
On page load, call Podia 'Check Subscriber' with email = Current User's email; if response active = true, set Custom State is_member = yes; if not, show 'Join Membership' button linking to Podia membership URL
```

## Troubleshooting

### No 'API' section appears in Podia Store Settings — cannot find the API key

Cause: Your Podia account is on the Free plan. Podia restricts API access to paid plans (Mover at $33/mo or Shaker at $89/mo). The API section is hidden entirely for Free plan accounts.

Solution: Log in to Podia and go to Account Settings → Billing to upgrade to the Mover plan. Once upgraded, Store Settings → API should appear within a few minutes. If you are building for a client, confirm their Podia plan before starting development.

### Bubble's 'Initialize call' returns an error or empty fields for the /products endpoint

Cause: Either your API key is incorrect (Bubble gets a 401 Unauthorized from Podia), or your Podia store has no published products (Podia returns an empty array and Bubble cannot detect field names from empty responses).

Solution: First, verify your API key: open Podia Store Settings → API and confirm the key matches exactly what you pasted in Bubble — no extra spaces, no truncation. Check that the Authorization header value starts with 'Bearer ' (with a space) followed by the key. Second, confirm you have at least one published product in your Podia store. Unpublished drafts may not appear in the `/products` response. Add a test product and publish it, then click Initialize call again.

```
// Correct header in Bubble API Connector:
// Key:   Authorization
// Value: Bearer abc123yourkeyhere
//               ^ space after 'Bearer'
// Private checkbox: CHECKED
```

### Product prices display as enormous numbers like '4900' or '15000' instead of '$49.00' or '$150.00'

Cause: Podia's API returns the `price` field as an integer in cents, not dollars. Displaying the raw value without dividing by 100 shows the cents amount as if it were dollars.

Solution: In every Bubble text element or expression that displays a Podia price, add the division: `Current cell's product's price / 100 :formatted as $#,##0.00`. In Bubble's expression editor, after referencing the `price` field, click 'More' → 'Arbitrary math' or use the division operator to divide by 100, then format as currency. Apply this fix to every price field across your storefront — it is the most common first-timer mistake.

```
// Bubble expression for price display:
// Current cell's Podia - Get Products - product's price / 100
// Then: :formatted as $#,##0.00
//
// Example: price = 4900 → 4900 / 100 = 49.00 → displays as $49.00
// Example: price = 1500 → 1500 / 100 = 15.00 → displays as $15.00
```

### Sales sync Backend Workflow cannot be created or scheduled — the Backend Workflows section is missing

Cause: Backend Workflows (including the ability to schedule recurring workflows) require a paid Bubble plan. The free plan does not support Backend Workflows or scheduled API calls.

Solution: Upgrade your Bubble app to the Starter plan or above. Once on a paid plan, go to Settings → API → enable 'This app exposes a Workflow API.' The Backend Workflows section will appear in the editor's left sidebar. If you need the sync functionality but cannot upgrade immediately, add a manual 'Sync Now' admin button on a private admin page that triggers the sync workflow when clicked — no plan upgrade required for single, user-triggered workflow calls.

### Podia API returns a response but field names in Bubble stop working after a Podia update

Cause: Podia's documentation states their API is 'still evolving' — endpoint response shapes can change without a major version bump. If Podia renames or restructures fields in the `/products` response, Bubble's previously initialized schema becomes stale.

Solution: When fields go missing from Bubble's dynamic data dropdown for a Podia API call, click the call in the API Connector and click 'Initialize call' again. Bubble will fire a fresh request to Podia and update the detected field schema. You may need to re-bind Bubble UI elements to renamed fields after reinitializing. Build your integration to use only stable core fields (id, name, type, price, url, image_url) and avoid relying on less-documented nested fields that are more likely to change.

## Frequently asked questions

### Can I process Podia payments inside Bubble instead of linking to Podia's checkout?

No, and you should not attempt to. Podia handles all payment processing on its own hosted checkout pages. Each product in the API response includes a `url` field that points to the Podia-hosted checkout for that product. Your Bubble app should link Buy buttons to this URL. Attempting to recreate a payment flow in Bubble for Podia products would bypass Podia's PCI-compliant payment infrastructure and would likely violate Podia's terms of service.

### Does Podia have webhooks I can receive in Bubble for new sale notifications?

Podia's webhook support for sale events is not consistently documented across plan tiers. If your Podia plan includes webhook support, you can receive sale events in a Bubble Backend Workflow endpoint (Settings → API → enable Workflow API, then create a Backend Workflow with 'Detect request data'). If Podia webhooks are not available on your plan, use a scheduled polling workflow that calls `/sales` daily and stores new transactions in Bubble's database. Check your Podia account's Store Settings for a Webhooks section to confirm availability.

### Will the Bubble integration work with Podia's community memberships?

Yes. Podia memberships appear in the `/products` endpoint response with `type = 'membership'`. You can display membership products in Bubble and link the Join button to Podia's hosted membership checkout URL. For gating Bubble app content behind active membership status, you would need to call a Podia endpoint that returns a subscriber's active membership — check Podia's current API docs for a `/subscribers` or `/memberships` endpoint that lets you query by email address.

### How many API calls does a Bubble + Podia storefront make and will it affect Bubble's Workload Units?

Each page load that triggers a live Podia API call consumes one API Connector WU in Bubble. If your storefront gets significant traffic and every visitor triggers a `/products` call on load, this adds up quickly. The recommended mitigation is caching: store products in a Bubble Data Type via a scheduled sync (every hour or every few hours), and serve the storefront from Bubble's native database rather than live Podia API calls. Reserve live API calls for actions where real-time data is essential, such as checking a subscriber's active membership status.

### Can I use this integration on Bubble's free plan?

Partially. Displaying Podia products from the `/products` endpoint in a Repeating Group works on any Bubble plan because it uses a client-side API Connector call. The limitations on the free plan are: you cannot create Backend Workflows (needed for the scheduled sales sync), and you cannot run scheduled recurring workflows (needed for automated data refresh). For a simple product display storefront with manual content updates, the free Bubble plan is sufficient. For a revenue dashboard with automated syncing, a paid Bubble plan is required.

### How should I handle the case where a product's type is not one of the five expected values?

Podia's API is described as evolving, so new product types could be added in the future. In your Bubble Repeating Groups, use a ':filtered' condition that shows only known product types, and add a fallback 'Other Products' tab that shows items where the type does not match any of the four specific filters. This ensures new product types appear somewhere in your storefront rather than being silently dropped, and you can decide how to handle them when they appear.

---

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