Zoom

Open marketplace.zoom.us and sign in with your Zoom admin account. Click 'Develop' in the top navigation, then 'Build App.' Select 'Server-to-Server OAuth' from the app type list — do not choose 'OAuth' (user-level) or 'JWT' (deprecated). Give your app a name like 'Bubble Integration' and click 'Create.' On the app dashboard you will see your Account ID, Client ID, and Client Secret — copy all three and store them somewhere safe. Next, navigate to the 'Scopes' tab and add at minimum the scope `meeting:write:admin` (to create meetings) and `meeting:read:admin` (to retrieve meeting details). If you plan to pull participant reports, also add `report:read:admin`. Once scopes are saved, go to the 'Activation' tab and click 'Activate your app.' The app must be active before the token endpoint will return tokens. Activation typically requires agreeing to Zoom's API terms for Server-to-Server apps.

1// Scopes to add in Zoom Marketplace → Scopes tab:
2meeting:write:admin
3meeting:read:admin
4report:read:admin   // only if you need participant reports

In your Bubble editor, click 'Plugins' in the left sidebar, then 'Add plugins.' Search for 'API Connector' (by Bubble), click 'Install,' and close the plugins panel. Now click 'Plugins' → 'API Connector.' Click 'Add another API' and name it 'Zoom.' Under this API you will add two separate calls. Call 1 — Token Exchange: Click 'Add another call.' Name it 'Get Access Token.' Set Method to POST and URL to `https://zoom.us/oauth/token`. Click 'Add header' and add `Content-Type` with value `application/x-www-form-urlencoded`. Now add the authentication: click 'Add parameter,' name it `grant_type`, set value to `account_credentials`, and leave 'Private' unchecked (this is a body param, not a secret). For authentication, Zoom's token endpoint requires Basic Auth where the username is your Client ID and the password is your Client Secret — NOT Base64-encoded manually; Bubble's built-in Basic Auth does the encoding for you. Click the authentication dropdown at the top of the call (default is 'None'), change it to 'Basic auth,' enter your Client ID as Username and Client Secret as Password, and check 'Private' on both. Add a second body param named `account_id` with your Account ID value — also mark it Private. Call 2 — Create Meeting: Click 'Add another call.' Name it 'Create Meeting.' Set Method to POST and URL to `https://api.zoom.us/v2/users/me/meetings`. Add a header: `Authorization` with value `Bearer <access_token>` — check 'Private' and change it to a dynamic parameter so you can pass the stored token at runtime. Add a header `Content-Type: application/json`. In the Body section select 'JSON body' and add your meeting fields with dynamic placeholders.

1// Call 1 — Token Exchange configuration
2{
3  "method": "POST",
4  "url": "https://zoom.us/oauth/token",
5  "headers": {
6    "Content-Type": "application/x-www-form-urlencoded",
7    "Authorization": "Basic <Base64(ClientID:ClientSecret)>"  // Bubble sets this via Basic Auth — mark Private
8  },
9  "body": {
10    "grant_type": "account_credentials",
11    "account_id": "<your_account_id>"  // mark Private
12  }
13}
14
15// Call 2 — Create Meeting configuration
16{
17  "method": "POST",
18  "url": "https://api.zoom.us/v2/users/me/meetings",
19  "headers": {
20    "Authorization": "Bearer <dynamic_token>",  // mark Private, set dynamically
21    "Content-Type": "application/json"
22  },
23  "body": {
24    "topic": "<dynamic_topic>",
25    "type": 2,
26    "start_time": "<dynamic_start_time>",
27    "duration": "<dynamic_duration_minutes>",
28    "settings": {
29      "join_before_host": false,
30      "waiting_room": true
31    }
32  }
33}

Go to your Bubble editor's 'Data' tab, then click 'Data types.' Click 'Add a data type' and name it `Zoom_Tokens`. Add two fields to this data type. The first field is `token` — set its type to 'text' — this will store the access_token string returned by Zoom's token endpoint. The second field is `expires_at` — set its type to 'date' — this will store the exact timestamp when the token expires so your Backend Workflow can check whether a refresh is needed before making API calls. You only need one record in this data type at any time (it gets updated in place), but it is useful to also add an `account_id` field (text) if you ever integrate multiple Zoom accounts. While you are in the Data tab, also go to 'Privacy' and add a privacy rule for the Zoom_Tokens data type: only your app's admin users or server-side workflows should be able to read token records. Regular end users should never see stored tokens — set the rule to 'Everyone else → no access' and use 'Ignore privacy rules when using workflows' for the Backend Workflows that need to read the token.

1// Zoom_Tokens data type fields:
2// token        → text
3// expires_at   → date
4// account_id   → text (optional, for multi-account setups)

Backend Workflows (API Workflows) are available only on Bubble paid plans — if you are on Bubble Free, upgrade before proceeding. In your Bubble editor, go to 'Backend Workflows' in the left sidebar. Click 'Add workflow' and name it `Refresh Zoom Token`. This workflow will: (1) call the Token Exchange API Connector call, (2) calculate the expiry timestamp, and (3) upsert the Zoom_Tokens record. Step-by-step within the workflow: 1. Add action: 'Plugins → API Connector - Zoom - Get Access Token.' This fires the token exchange call you configured in the previous step. 2. Add action: 'Data (Things) → Make changes to a list of Things' or 'Create a new Thing.' Search for an existing Zoom_Tokens record first. If one exists, update its `token` field to the result of step 1 (Result of step 1's body access_token) and update `expires_at` to 'Current date/time + 3600 seconds.' If no record exists, create a new Zoom_Tokens record with the same values. In practice, you can simplify this by always deleting the old record and creating a new one, or using Bubble's 'Do a search for' to find the existing record. 3. The workflow does not need to return anything — it is triggered by the 'Create Zoom Meeting' workflow (next step) when the token is stale.

1// Backend Workflow: Refresh Zoom Token
2// Step 1: Call API Connector → Zoom → Get Access Token
3// Step 2: Search for Zoom_Tokens (first item)
4//   IF found: Make changes → token = Step1's access_token
5//                           expires_at = Current date/time + 3600 seconds
6//   IF not found: Create new Zoom_Tokens → token = Step1's access_token
7//                                          expires_at = Current date/time + 3600 seconds

Create a second Backend Workflow named `Create Zoom Meeting`. This workflow accepts input parameters — at minimum `topic` (text), `start_time` (date), and `duration_minutes` (number) — so the frontend can pass meeting details when triggering it. Inside the workflow: 1. Add a condition check: 'Do a search for Zoom_Tokens' — get the first result. Check if it exists AND if `expires_at > Current date/time`. If the token is missing or expired, add an action: 'Schedule API Workflow → Refresh Zoom Token' (call it synchronously using 'Run Backend Workflow' from the Workflow editor, or by making 'Refresh Zoom Token' a precondition step). In practice, the cleanest approach is to add the token-refresh logic as step 1 of this workflow with a condition: 'Only when Zoom_Tokens's first item's expires_at is before Current date/time OR Zoom_Tokens count is 0.' 2. After ensuring a valid token exists, add action: 'Plugins → API Connector - Zoom - Create Meeting.' In the dynamic header field for Authorization, reference `Do a search for Zoom_Tokens first item's token`. Pass the topic, start_time (formatted as ISO 8601: YYYY-MM-DDTHH:MM:SS), and duration from the workflow's input parameters. 3. Add action: save the meeting data. Create a new Meeting record (or update an existing booking record) with `join_url = Result of step 2 - join_url`, `start_url = Result of step 2 - start_url`, and `zoom_meeting_id = Result of step 2 - id`. 4. Return the join_url as the workflow's return value so the frontend can display it immediately after the workflow completes.

1// Backend Workflow: Create Zoom Meeting
2// Input params: topic (text), start_time (date), duration_minutes (number)
3//
4// Step 1 (conditional): IF Zoom_Tokens is empty OR expires_at < Current date/time
5//   → Run Backend Workflow: Refresh Zoom Token
6//
7// Step 2: API Connector → Zoom → Create Meeting
8//   Authorization header: Bearer [Zoom_Tokens first item's token]
9//   Body:
10//     topic: [input topic]
11//     type: 2
12//     start_time: [input start_time formatted ISO 8601]
13//     duration: [input duration_minutes]
14//
15// Step 3: Create new Meeting record
16//   join_url: [Step 2 result - join_url]
17//   start_url: [Step 2 result - start_url]
18//   zoom_meeting_id: [Step 2 result - id]
19//
20// Step 4: Return join_url to the triggering workflow

Now connect everything to your app's UI. On your Bubble page, design a simple meeting scheduler: add a date/time picker input, a text input for the meeting topic, and a number input or dropdown for duration in minutes. Add a 'Create Meeting' button. In the button's workflow, add a single action: 'Backend Workflows → Schedule API Workflow → Create Zoom Meeting,' passing the page's input values as the workflow's parameters. Set the scheduled time to 'Current date/time' so it runs immediately (not delayed). To display the result, add a text element with the placeholder 'Your meeting link will appear here.' After the Backend Workflow runs and creates the Meeting record, redirect the user to a confirmation page or use Bubble's 'Go to page' action with URL parameters carrying the join_url. Alternatively, if you store the Meeting record linked to the Current User, display the most recently created Meeting's join_url in a text element using 'Do a search for Meetings where host = Current User, sorted by Created Date descending, first item's join_url.' For the host view, show an additional 'Start Meeting' button that links to the start_url in a new tab. Label it clearly so the host knows this is their private host link. RapidDev's team has built dozens of Bubble apps with Zoom and similar integrations — if you want a free scoping call on architecture decisions, visit rapidevelopers.com/contact.

1// Frontend button workflow:
2// Event: Button is clicked
3// Action 1: Schedule API Workflow → Create Zoom Meeting
4//   topic: Input_Topic's value
5//   start_time: DateTimePicker_StartTime's value
6//   duration_minutes: Input_Duration's value
7//
8// After the workflow runs, display the Meeting record:
9// Text element dynamic expression:
10//   Do a search for Meetings where Created by = Current User
11//   Sort by Created Date descending | First item | join_url