How to Integrate Replit with Zoom

1# Python — verify Zoom credentials are set
2import os
3
4required = ["ZOOM_ACCOUNT_ID", "ZOOM_CLIENT_ID", "ZOOM_CLIENT_SECRET"]
5for key in required:
6    val = os.environ.get(key)
7    if not val:
8        raise EnvironmentError(f"{key} not found. Add it in Replit Secrets (lock icon).")
9    print(f"{key}: loaded")
10print("All Zoom credentials verified.")

1// Node.js — Zoom OAuth token manager (zoom-auth.js)
2const ZOOM_ACCOUNT_ID = process.env.ZOOM_ACCOUNT_ID;
3const ZOOM_CLIENT_ID = process.env.ZOOM_CLIENT_ID;
4const ZOOM_CLIENT_SECRET = process.env.ZOOM_CLIENT_SECRET;
5
6let tokenCache = { token: null, expiresAt: 0 };
7
8async function getZoomToken() {
9  const now = Date.now();
10  // Return cached token if it has more than 5 minutes remaining
11  if (tokenCache.token && tokenCache.expiresAt > now + 5 * 60 * 1000) {
12    return tokenCache.token;
13  }
14
15  const credentials = Buffer.from(`${ZOOM_CLIENT_ID}:${ZOOM_CLIENT_SECRET}`).toString('base64');
16
17  const response = await fetch(
18    `https://zoom.us/oauth/token?grant_type=account_credentials&account_id=${ZOOM_ACCOUNT_ID}`,
19    {
20      method: 'POST',
21      headers: {
22        'Authorization': `Basic ${credentials}`,
23        'Content-Type': 'application/x-www-form-urlencoded'
24      }
25    }
26  );
27
28  if (!response.ok) {
29    const error = await response.json();
30    throw new Error(`Failed to get Zoom token: ${JSON.stringify(error)}`);
31  }
32
33  const data = await response.json();
34  tokenCache = {
35    token: data.access_token,
36    expiresAt: now + (data.expires_in * 1000)
37  };
38
39  return tokenCache.token;
40}
41
42module.exports = { getZoomToken };

1// Node.js — Zoom meeting operations (zoom-api.js)
2const { getZoomToken } = require('./zoom-auth');
3
4const ZOOM_BASE = 'https://api.zoom.us/v2';
5
6async function zoomRequest(method, path, body = null) {
7  const token = await getZoomToken();
8  const options = {
9    method,
10    headers: {
11      'Authorization': `Bearer ${token}`,
12      'Content-Type': 'application/json'
13    }
14  };
15  if (body) options.body = JSON.stringify(body);
16
17  const response = await fetch(`${ZOOM_BASE}${path}`, options);
18  if (!response.ok) {
19    const error = await response.json();
20    throw new Error(`Zoom API ${response.status}: ${JSON.stringify(error)}`);
21  }
22  if (response.status === 204) return null; // No content
23  return response.json();
24}
25
26async function createMeeting({ userId = 'me', topic, startTime, durationMinutes, agenda = '' }) {
27  return zoomRequest('POST', `/users/${userId}/meetings`, {
28    topic,
29    type: 2, // Scheduled meeting
30    start_time: startTime, // ISO 8601, e.g. '2026-04-15T14:00:00Z'
31    duration: durationMinutes,
32    agenda,
33    settings: {
34      host_video: true,
35      participant_video: true,
36      waiting_room: true,
37      auto_recording: 'none'
38    }
39  });
40}
41
42async function getMeeting(meetingId) {
43  return zoomRequest('GET', `/meetings/${meetingId}`);
44}
45
46async function deleteMeeting(meetingId) {
47  return zoomRequest('DELETE', `/meetings/${meetingId}`);
48}
49
50module.exports = { createMeeting, getMeeting, deleteMeeting, zoomRequest };

1// Node.js — Zoom webhook handler (webhook.js)
2const crypto = require('crypto');
3
4const ZOOM_WEBHOOK_SECRET = process.env.ZOOM_WEBHOOK_SECRET;
5
6app.post('/zoom-webhook', express.json(), (req, res) => {
7  const { event, payload } = req.body;
8
9  // Zoom URL validation challenge (required when setting up webhook)
10  if (event === 'endpoint.url_validation') {
11    const { plainToken } = payload;
12    const encryptedToken = crypto
13      .createHmac('sha256', ZOOM_WEBHOOK_SECRET)
14      .update(plainToken)
15      .digest('hex');
16    return res.json({
17      plainToken,
18      encryptedToken
19    });
20  }
21
22  // Verify webhook signature for security
23  const message = `v0:${req.headers['x-zm-request-timestamp']}:${JSON.stringify(req.body)}`;
24  const expectedHash = 'v0=' + crypto
25    .createHmac('sha256', ZOOM_WEBHOOK_SECRET)
26    .update(message)
27    .digest('hex');
28
29  if (req.headers['x-zm-signature'] !== expectedHash) {
30    return res.status(401).json({ error: 'Invalid webhook signature' });
31  }
32
33  // Handle specific events
34  console.log(`Zoom event: ${event}`);
35  switch (event) {
36    case 'meeting.started':
37      console.log(`Meeting started: ${payload.object.id}`);
38      break;
39    case 'meeting.ended':
40      console.log(`Meeting ended: ${payload.object.id}, duration: ${payload.object.duration}`);
41      break;
42    case 'meeting.participant_joined':
43      console.log(`Participant joined: ${payload.object.participant?.user_name}`);
44      break;
45    case 'recording.completed':
46      console.log(`Recording ready for meeting: ${payload.object.id}`);
47      break;
48  }
49
50  res.json({ status: 'ok' });
51});

1# Python — Flask Zoom integration (app.py)
2import os
3import time
4import hmac
5import hashlib
6import requests
7from flask import Flask, request, jsonify
8
9app = Flask(__name__)
10
11ZOOM_ACCOUNT_ID = os.environ["ZOOM_ACCOUNT_ID"]
12ZOOM_CLIENT_ID = os.environ["ZOOM_CLIENT_ID"]
13ZOOM_CLIENT_SECRET = os.environ["ZOOM_CLIENT_SECRET"]
14ZOOM_WEBHOOK_SECRET = os.environ.get("ZOOM_WEBHOOK_SECRET", "")
15ZOOM_BASE = "https://api.zoom.us/v2"
16
17_token_cache = {"token": None, "expires_at": 0}
18
19def get_zoom_token():
20    if _token_cache["token"] and _token_cache["expires_at"] > time.time() + 300:
21        return _token_cache["token"]
22    resp = requests.post(
23        f"https://zoom.us/oauth/token?grant_type=account_credentials&account_id={ZOOM_ACCOUNT_ID}",
24        auth=(ZOOM_CLIENT_ID, ZOOM_CLIENT_SECRET)
25    )
26    resp.raise_for_status()
27    data = resp.json()
28    _token_cache["token"] = data["access_token"]
29    _token_cache["expires_at"] = time.time() + data["expires_in"]
30    return _token_cache["token"]
31
32@app.route("/meetings", methods=["POST"])
33def create_meeting():
34    data = request.get_json()
35    token = get_zoom_token()
36    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
37    resp = requests.post(f"{ZOOM_BASE}/users/me/meetings",
38        json={
39            "topic": data["topic"],
40            "type": 2,
41            "start_time": data["start_time"],
42            "duration": data["duration"],
43            "settings": {"waiting_room": True}
44        },
45        headers=headers, timeout=10)
46    resp.raise_for_status()
47    meeting = resp.json()
48    return jsonify({"id": meeting["id"], "join_url": meeting["join_url"]})
49
50@app.route("/zoom-webhook", methods=["POST"])
51def zoom_webhook():
52    body = request.get_json()
53    event = body.get("event")
54    payload = body.get("payload", {})
55
56    if event == "endpoint.url_validation":
57        plain_token = payload["plainToken"]
58        encrypted = hmac.new(ZOOM_WEBHOOK_SECRET.encode(),
59                              plain_token.encode(), hashlib.sha256).hexdigest()
60        return jsonify({"plainToken": plain_token, "encryptedToken": encrypted})
61
62    print(f"Zoom event: {event}")
63    return jsonify({"status": "ok"})
64
65if __name__ == "__main__":
66    app.run(host="0.0.0.0", port=3000)