Zoom

Open your browser and go to marketplace.zoom.us. Click 'Develop' in the top navigation and select 'Build App'. Choose 'Server-to-Server OAuth' as the app type — this replaces the deprecated JWT app type and is the correct choice for server-side API access where there is no user login to Zoom required. Give your app a name (e.g., 'FlutterFlow Integration'), fill in the short and long description, and click Continue. On the Scopes page, add the scopes your Cloud Function needs: `meeting:write:admin` to create meetings on behalf of account users, `meeting:read:admin` to list and retrieve meetings, and `recording:read:admin` if you want to pull cloud recording links. If you plan to access participant reports, add `report:read:admin`. Click Continue to complete the app registration. On the App Credentials page, copy three values: **Account ID**, **Client ID**, and **Client Secret**. These are your Zoom credentials. Keep them in a secure location — you will add them to Firebase Functions environment config in the next step, and they must never be copied into FlutterFlow.

This Cloud Function is the heart of the integration. It holds the Zoom credentials securely, exchanges them for a 1-hour Bearer token, and creates (or lists) Zoom meetings. To avoid re-minting the token on every request, cache the token and its expiry time in memory (function-level variable) or in Firestore — and invalidate it when it nears the 3600-second TTL. Set your Zoom credentials in Firebase Functions config by running in your terminal: `firebase functions:config:set zoom.account_id="your-account-id" zoom.client_id="your-client-id" zoom.client_secret="your-client-secret"`. Then deploy the function below with `firebase deploy --only functions`. The function exposes an HTTP endpoint that FlutterFlow calls. It accepts the meeting parameters in the JSON body (topic, start time, duration, timezone) and returns the created meeting's `join_url` and `id`. For a simpler architecture, the function does everything: get token + create meeting + return URL — one call from FlutterFlow, one result.

1// functions/index.js — Zoom meeting creator
2const functions = require('firebase-functions');
3const fetch = require('node-fetch');
4
5const ZOOM_ACCOUNT_ID = functions.config().zoom.account_id;
6const ZOOM_CLIENT_ID = functions.config().zoom.client_id;
7const ZOOM_CLIENT_SECRET = functions.config().zoom.client_secret;
8const ZOOM_TOKEN_URL = 'https://zoom.us/oauth/token';
9const ZOOM_API_BASE = 'https://api.zoom.us/v2';
10
11// In-memory token cache (valid for ~55 min)
12let cachedToken = null;
13let tokenExpiresAt = 0;
14
15async function getZoomToken() {
16  const now = Date.now();
17  // Refresh if cached token expires within 5 minutes
18  if (cachedToken && now < tokenExpiresAt - 300000) {
19    return cachedToken;
20  }
21  const credentials = Buffer.from(`${ZOOM_CLIENT_ID}:${ZOOM_CLIENT_SECRET}`).toString('base64');
22  const res = await fetch(
23    `${ZOOM_TOKEN_URL}?grant_type=account_credentials&account_id=${ZOOM_ACCOUNT_ID}`,
24    {
25      method: 'POST',
26      headers: {
27        Authorization: `Basic ${credentials}`,
28        'Content-Type': 'application/x-www-form-urlencoded',
29      },
30    }
31  );
32  const data = await res.json();
33  if (!data.access_token) throw new Error('Failed to get Zoom token: ' + JSON.stringify(data));
34  cachedToken = data.access_token;
35  tokenExpiresAt = now + data.expires_in * 1000;
36  return cachedToken;
37}
38
39exports.createZoomMeeting = functions.https.onRequest(async (req, res) => {
40  res.set('Access-Control-Allow-Origin', '*');
41  if (req.method === 'OPTIONS') { res.status(204).send(''); return; }
42  if (req.method !== 'POST') { res.status(405).json({ error: 'POST only' }); return; }
43
44  const {
45    topic = 'Meeting',
46    type = 2, // 2 = scheduled, 1 = instant
47    start_time,
48    duration = 60,
49    timezone = 'UTC',
50    userId = 'me',
51  } = req.body;
52
53  try {
54    const token = await getZoomToken();
55    const zoomRes = await fetch(`${ZOOM_API_BASE}/users/${userId}/meetings`, {
56      method: 'POST',
57      headers: {
58        Authorization: `Bearer ${token}`,
59        'Content-Type': 'application/json',
60      },
61      body: JSON.stringify({ topic, type, start_time, duration, timezone }),
62    });
63    const meeting = await zoomRes.json();
64    if (!zoomRes.ok) {
65      return res.status(zoomRes.status).json({ error: meeting.message || 'Zoom API error', code: meeting.code });
66    }
67    res.status(200).json({
68      id: meeting.id,
69      join_url: meeting.join_url,
70      start_url: meeting.start_url,
71      topic: meeting.topic,
72      start_time: meeting.start_time,
73      duration: meeting.duration,
74    });
75  } catch (err) {
76    res.status(500).json({ error: err.message });
77  }
78});

In your FlutterFlow project, click 'API Calls' in the left navigation panel. Click '+ Add' and select 'Create API Group'. Name it 'ZoomMeetings'. For the base URL, enter the root of your Firebase Cloud Function: `https://us-central1-your-project.cloudfunctions.net`. Add a `Content-Type: application/json` header. Now add an API Call inside the group: click '+ Add API Call', name it 'createMeeting', set the method to POST, and enter `/createZoomMeeting` as the endpoint path. Open the Variables tab and add the fields your function accepts: `topic` (String), `start_time` (String — ISO 8601 format, e.g., `2024-07-15T10:00:00`), `duration` (Integer, minutes), and `timezone` (String, e.g., `America/New_York`). In the Body tab, set the type to JSON and map the variables: `{ "topic": "{{ topic }}", "start_time": "{{ start_time }}", "duration": {{ duration }}, "timezone": "{{ timezone }}" }`. In the Response & Test tab, paste a sample response and generate JSON Paths for `$.join_url`, `$.id`, and `$.topic`. Test the API Call with real values to confirm a meeting is created in your Zoom account. Save the configuration.

1{
2  "topic": "{{ topic }}",
3  "start_time": "{{ start_time }}",
4  "duration": {{ duration }},
5  "timezone": "{{ timezone }}"
6}

Now wire the Zoom API Call to a user interaction in your FlutterFlow app. Common patterns include a 'Schedule Meeting' form with topic, date picker, and duration fields, or a simple 'Start Instant Meeting' button. For the button approach: add a Button widget, open its Actions panel, and click '+ Add Action'. Choose 'Backend/API Call', select the 'ZoomMeetings' group, and pick the 'createMeeting' call. Map `topic` to a text field value or a static string, set `duration` to a number field, and set `start_time` to a formatted date value. After the API Call action, add a second action to store the response: either set a Page State variable `joinUrl` to the response JSON Path `$.join_url`, or write it to Firestore alongside a booking record. Display the join URL using a Text widget bound to the `joinUrl` page state variable, or use a 'Launch URL' action after the API Call to immediately open the join link in the device browser. If you're building a scheduling feature, save the `id`, `join_url`, and `start_time` to a Firestore collection like `meetings` so you can display upcoming meetings in a ListView.

After meetings end, Zoom provides cloud recording links and detailed participant reports — useful for building a dashboard in your FlutterFlow app where admins can review recordings and attendance. Add two more Cloud Functions: one for listing recordings (`GET /users/me/recordings?from={date}`) and one for participant reports (`GET /report/meetings/{meetingId}/participants`). Both reuse the same `getZoomToken()` helper from the create-meeting function. Important caveats: participant reports are only available 30–60 minutes after a meeting ends (and require `report:read:admin` scope), and cloud recordings require cloud recording to be enabled in the Zoom account settings. In FlutterFlow, add two new API Calls to your ZoomMeetings group pointing at these Cloud Function endpoints. Bind a ListView to the recordings response JSON Path `$.recording_files[*].download_url` and another to the participants response `$.participants[*].name`. For a dashboard that auto-updates, write the fetched data to Firestore after each meeting ends and bind the FlutterFlow list to that collection — more reliable than polling Zoom live.

1// Add to functions/index.js — Zoom recordings endpoint
2exports.getZoomRecordings = functions.https.onRequest(async (req, res) => {
3  res.set('Access-Control-Allow-Origin', '*');
4  if (req.method === 'OPTIONS') { res.status(204).send(''); return; }
5  const { from, userId = 'me' } = req.query;
6  try {
7    const token = await getZoomToken();
8    const zoomRes = await fetch(
9      `${ZOOM_API_BASE}/users/${userId}/recordings?from=${from || new Date().toISOString().slice(0, 10)}`,
10      { headers: { Authorization: `Bearer ${token}` } }
11    );
12    const data = await zoomRes.json();
13    res.status(200).json(data);
14  } catch (err) {
15    res.status(500).json({ error: err.message });
16  }
17});