How to Integrate Retool with Zoom

Navigate to Zoom App Marketplace at marketplace.zoom.us and sign in with your Zoom admin account. Click the Develop button in the top-right navigation, then select Build App from the dropdown menu. In the app type selector, find and choose Server-to-Server OAuth — this app type is specifically designed for server-side integrations that don't require individual user authorization. Name your app something descriptive like 'Retool Integration' and click Create. The app configuration page opens and immediately displays three critical credentials under the App Credentials section: Account ID, Client ID, and Client Secret. Copy all three values and store them securely — you will need them in the next step. The Client Secret is shown only once and cannot be retrieved later, though it can be regenerated. Next, configure the API scopes your Retool integration needs. Click the Scopes tab in the left navigation of the app configuration page. Use the search box to find and add the following scopes based on your use case: - meeting:read:admin — read meeting details and participant data for all users in your account - recording:read:admin — access cloud recording data for all users - webinar:read:admin — read webinar details, registrants, and attendees - report:read:admin — access usage reports and participant reports Add only the scopes you actually need — unnecessary scopes increase your security surface area. After adding scopes, click Save. Then navigate to the Activation tab and click Activate your app. The app status changes to Active, meaning you can now exchange your credentials for API access tokens. Note: Zoom's Server-to-Server OAuth access tokens expire after one hour. Your Retool JavaScript query will need to fetch a fresh token before each session's queries — you will handle this in step two.

Before creating the Retool resource, store your three Zoom credentials securely in Retool's Configuration Variables system. Navigate to your Retool instance's Settings page — click the gear icon in the bottom-left corner of the Retool home page, then select Configuration Variables from the settings navigation. Click Add Variable three times to create the following variables, marking each one as Secret: - Name: ZOOM_ACCOUNT_ID — Value: paste your Zoom Account ID - Name: ZOOM_CLIENT_ID — Value: paste your Zoom Client ID - Name: ZOOM_CLIENT_SECRET — Value: paste your Zoom Client Secret Variables marked as Secret are stored encrypted and are only accessible in resource configurations and Retool Workflows — they are never exposed to the browser frontend, meaning your Zoom credentials remain completely server-side. Click Save for each variable. Once saved, you can reference these variables in resource configurations and JavaScript queries using the syntax {{ environment.variables.ZOOM_ACCOUNT_ID }}, {{ environment.variables.ZOOM_CLIENT_ID }}, and {{ environment.variables.ZOOM_CLIENT_SECRET }}. This approach means you can rotate your Zoom credentials by updating just the configuration variable, without touching any individual queries or resource settings — especially important because Zoom Client Secrets can be regenerated, and when they are, you only need to update one place in Retool.

Navigate to the Resources tab in Retool (top navigation bar) and click Add Resource. Select REST API from the resource type list. Configure the resource: - Name: enter 'Zoom API' - Base URL: enter https://api.zoom.us/v2 - Authentication: select None at the resource level (you will handle auth dynamically per-query using the token exchange pattern) Click Save Changes. The resource is created but without static auth — this is intentional because Zoom's Server-to-Server OAuth tokens expire after one hour, so you need to fetch a fresh token dynamically. Open your Retool app and in the Code panel, click + New to create a JavaScript query. Name it 'getZoomToken'. Set the query type to JavaScript. Write the following token exchange code in the query editor — this calls Zoom's OAuth endpoint to get a fresh access token using your stored credentials: Paste the code shown below. This query makes a POST request to Zoom's token endpoint using Basic Auth (Client ID:Client Secret encoded as Base64) and the grant type account_credentials with your Account ID. The response contains an access_token valid for one hour. Enable 'Run this query automatically when inputs change' and set the trigger to 'On page load' so a fresh token is always available when the app opens. The fetched token is now accessible as getZoomToken.data.access_token from any other query in the app. Create a second query for your first actual Zoom API call: - Resource: Zoom API - Method: GET - Path: /users/me/meetings - Headers: add Authorization with value Bearer {{ getZoomToken.data.access_token }} This pattern — token exchange query runs first, subsequent queries reference its output in headers — is the standard approach for any OAuth 2.0 integration where tokens expire and must be refreshed.

1// JavaScript query: getZoomToken
2// Exchanges Zoom Server-to-Server OAuth credentials for an access token
3// Run this on page load; reference the token as getZoomToken.data.access_token
4
5const accountId = retoolContext.configVars.ZOOM_ACCOUNT_ID;
6const clientId = retoolContext.configVars.ZOOM_CLIENT_ID;
7const clientSecret = retoolContext.configVars.ZOOM_CLIENT_SECRET;
8
9// Encode credentials as Base64 for Basic Auth
10const credentials = btoa(`${clientId}:${clientSecret}`);
11
12const response = await fetch(
13  `https://zoom.us/oauth/token?grant_type=account_credentials&account_id=${accountId}`,
14  {
15    method: 'POST',
16    headers: {
17      'Authorization': `Basic ${credentials}`,
18      'Content-Type': 'application/x-www-form-urlencoded'
19    }
20  }
21);
22
23if (!response.ok) {
24  const error = await response.text();
25  throw new Error(`Zoom token exchange failed: ${error}`);
26}
27
28const tokenData = await response.json();
29return tokenData; // access_token, token_type, expires_in

With token exchange working, create the core Zoom data queries for your dashboard. All queries follow the same pattern: REST API Resource set to 'Zoom API', Authorization header set to Bearer {{ getZoomToken.data.access_token }}, and specific paths for each Zoom endpoint. Create a 'listMeetings' query: - Resource: Zoom API - Method: GET - Path: /users/{{ userSelect.value || 'me' }}/meetings - URL Parameters: type=scheduled, page_size=100, next_page_token={{ '' }} - Headers: Authorization: Bearer {{ getZoomToken.data.access_token }} This returns upcoming scheduled meetings for the selected user or the authenticated account. Add a URL Parameter 'type' set to 'previous_meetings' to list past meetings instead. Create a 'getMeetingParticipants' query for a specific meeting: - Resource: Zoom API - Method: GET - Path: /report/meetings/{{ table1.selectedRow.id }}/participants - URL Parameters: page_size=300 - Headers: Authorization: Bearer {{ getZoomToken.data.access_token }} - Trigger: Manual (fires when a user selects a meeting row) Note: Participant reports require the report:read:admin scope and are only available for meetings that have already ended — this endpoint returns post-meeting data, not live participant status. Create a 'listRecordings' query: - Resource: Zoom API - Method: GET - Path: /users/{{ userSelect.value || 'me' }}/recordings - URL Parameters: from={{ dateRange.start }}, to={{ dateRange.end }}, page_size=100 - Headers: Authorization: Bearer {{ getZoomToken.data.access_token }} Drag Table components onto the canvas for meetings and recordings, setting each one's Data Source to {{ listMeetings.data.meetings }} and {{ listRecordings.data.meetings }} respectively — Zoom's API wraps results in a 'meetings' key in the response object. Wire the getMeetingParticipants query to the meetings Table's onRowClick event handler so selecting a meeting automatically loads its participant list into a second Table below.

1// JavaScript transformer for meeting list — formats Zoom API response for Table component
2const meetings = data.meetings || [];
3return meetings.map(meeting => ({
4  id: meeting.id,
5  topic: meeting.topic,
6  type: meeting.type === 2 ? 'Scheduled' : meeting.type === 3 ? 'Recurring' : 'Instant',
7  start_time: new Date(meeting.start_time).toLocaleString(),
8  duration_min: meeting.duration,
9  host_id: meeting.host_id,
10  join_url: meeting.join_url,
11  participants: meeting.participants_count || 'N/A'
12}));

Elevate the dashboard from a data viewer to an analytics tool by adding Charts and calculated metrics. In the Component panel, drag a Chart component above or beside the meetings Table. Set the Chart's Data Source to a JavaScript transformer that calculates attendance metrics from your participant data: Create a standalone JavaScript transformer (click + New in the Code panel, select Transformer) named 'attendanceTrend'. This transformer reads from the listMeetings query data and calculates a weekly attendance summary. Reference the transformer in the Chart component's Data Source as {{ attendanceTrend.value }}. For the Chart component settings: - Chart Type: Bar Chart - X-axis: week (the week field from the transformer output) - Y-axis series: avg_participants - Title: 'Average Meeting Attendance by Week' Add a Statistics component row above the tables to show key metrics: total meetings this month, average attendance rate, and total recording hours. Wire each Stat component's value to a JavaScript transformer that calculates the metric from the query data. For proactive alerting, build a Retool Workflow that runs weekly and identifies meetings with very low attendance. Navigate to Workflows in the Retool home page sidebar, create a new Workflow, and add a Schedule trigger for Monday mornings. Add a Resource Query block targeting your Zoom API resource, pulling past week's meetings. Add a JavaScript Code block that filters for meetings where participants_count is below a threshold (e.g., less than 3). Add a Slack Resource Query block (if Slack is connected) that posts a summary of low-attendance meetings to a #meeting-ops channel. Click Publish Release to activate the Workflow. For complex cross-tool reporting combining Zoom with CRM and HR data across multiple workflows, RapidDev's team can help architect and build the full Retool solution.

1// Standalone transformer: attendanceTrend
2// Calculates weekly average attendance from past meetings data
3const meetings = listMeetings.data?.meetings || [];
4
5// Group meetings by week
6const weekMap = {};
7meetings.forEach(meeting => {
8  const date = new Date(meeting.start_time);
9  const weekStart = new Date(date);
10  weekStart.setDate(date.getDate() - date.getDay()); // Sunday of that week
11  const weekKey = weekStart.toISOString().split('T')[0];
12
13  if (!weekMap[weekKey]) {
14    weekMap[weekKey] = { total_participants: 0, meeting_count: 0 };
15  }
16  weekMap[weekKey].total_participants += (meeting.participants_count || 0);
17  weekMap[weekKey].meeting_count += 1;
18});
19
20return Object.entries(weekMap)
21  .sort(([a], [b]) => a.localeCompare(b))
22  .map(([week, stats]) => ({
23    week,
24    avg_participants: stats.meeting_count > 0
25      ? Math.round(stats.total_participants / stats.meeting_count)
26      : 0,
27    meeting_count: stats.meeting_count
28  }));