Zoom Developer Platform Skills

https://github.com/zoom/skills
Admin
A collection of AI-powered skills for building with Zoom SDKs, APIs, and integrations, providing...
Tokens:1,780,376
Snippets:14,120
Trust Score:8.2
License:MIT
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Complete Navigation Example: SDK Singleton to Session, Users, Helpers, and Raw Data Pipes

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/linux/concepts/singleton-hierarchy.md

A complete example showing the singleton hierarchy: initialize SDK, join session, get session info, get users, subscribe to remote video, control audio/video, send chat, and start cloud recording. Demonstrates the typical flow from SDK initialization to using various helpers.

```cpp
// Level 1: SDK Singleton
IZoomVideoSDK* sdk = CreateZoomVideoSDKObj();
sdk->initialize(init_params);
sdk->joinSession(session_context);

// Level 2A: Session Info
IZoomVideoSDKSession* session = sdk->getSessionInfo();

// Level 3: Users
IZoomVideoSDKUser* myself = session->getMyself();
IVideoSDKVector<IZoomVideoSDKUser*>* remote = session->getRemoteUsers();

// Level 4: Subscribe to remote user's video
IZoomVideoSDKUser* remoteUser = remote->GetItem(0);
IZoomVideoSDKRawDataPipe* videoPipe = remoteUser->GetVideoPipe();
videoPipe->subscribe(ZoomVideoSDKResolution_720P, videoDelegate);

// Level 2B: Control my audio
IZoomVideoSDKAudioHelper* audio = sdk->getAudioHelper();
audio->startAudio();
audio->subscribe();  // For raw audio callbacks

// Level 2B: Control my video
IZoomVideoSDKVideoHelper* video = sdk->getVideoHelper();
video->startVideo();

// Level 2B: Send chat
IZoomVideoSDKChatHelper* chat = sdk->getChatHelper();
chat->sendChatToAll("Hello!");

// Level 2B: Start recording
IZoomVideoSDKRecordingHelper* rec = sdk->getRecordingHelper();
if (rec->canStartRecording() == ZoomVideoSDKErrors_Success) {
    rec->startCloudRecording();
}
```

--------------------------------

### Quick Start: Join Session and Render Video

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/examples/react-hooks.md

Quick start example showing how to join a session, list participants, and render video players. Uses useSession with a topic, JWT token, and user name, and useSessionUsers to get participants.

```tsx
import { 
  useSession, 
  useSessionUsers, 
  VideoPlayerComponent, 
  VideoPlayerContainerComponent 
} from '@zoom/videosdk-react';

function VideoChat() {
  const { isInSession, isLoading, isError } = useSession(
    "session123", 
    "your_jwt_token", 
    "User Name"
  );
  
  const participants = useSessionUsers();
  
  if (isLoading) return <div>Joining session...</div>;
  if (isError) return <div>Error joining session</div>;
  
  return (
    <div>
      {isInSession && (
        <VideoPlayerContainerComponent>
          {participants.map(participant => (
            <VideoPlayerComponent 
              key={participant.userId} 
              user={participant} 
            />
          ))}
        </VideoPlayerContainerComponent>
      )}
    </div>
  );
}
```

--------------------------------

### Build and run GTK quickstart

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/linux/linux.md

Install GTKmm3, SDL2, and other dependencies, build the GTK quickstart project, and run the SkeletonDemo binary.

```bash
# Prerequisites
sudo apt install -y libgtkmm-3.0-dev libsdl2-dev libasound2-dev libcurl4-openssl-dev cmake

# Build
cd videosdk-linux-gtk-quickstart/src
mkdir build && cd build
cmake .. && make

# Run
cd ../bin && ./SkeletonDemo
```

--------------------------------

### Build and run Qt quickstart

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/linux/linux.md

Install Qt6 dependencies, build the Qt quickstart project, and run the demo. Requires the videosdk-linux-qt-quickstart repository.

```bash
# Prerequisites
sudo apt install -y qt6-base-dev qt6-tools-dev libasound2-dev cmake

# Build
cd videosdk-linux-qt-quickstart/src
mkdir build && cd build
export Qt6_DIR=/usr/lib/x86_64-linux-gnu/cmake/Qt6
cmake .. && make -j$(nproc)

# Run
./run_qt_demo.sh
```

--------------------------------

### Complete whiteboard integration example

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/references/features/whiteboard.md

Complete integration example showing how to initialize the client, join a session, get the whiteboard client, check availability, set up event listeners for whiteboard state changes, start the whiteboard as a presenter, and export before stopping. Note that in-session whiteboards are not persisted by default and data is lost when stopping the whiteboard or on session end.

```javascript
const client = ZoomVideo.createClient();
let whiteboardClient;
client.init("en-us", "Global");

// Initialize after joining session
await client.join("session name", "jwt token", "name");
whiteboardClient = client.getWhiteboardClient();

// Check if whiteboard is available
if (!whiteboardClient.isWhiteboardEnabled()) {
    console.warn("Whiteboard not available on this platform");
    return;
}

// Set up event listeners
client.on("peer-whiteboard-state-change", async (payload) => {
    const { action, userId } = payload;

    if (action === "Start") {
        await whiteboardClient.startWhiteboardView(whiteboardElement, userId);
    } else if (action === "Stop") {
        await whiteboardClient.stopWhiteboardView();
    }
});

client.on("whiteboard-status-change", (status) => {
    updateUIBasedOnStatus(status);
});

// Start whiteboard as presenter (host/manager only)
if (whiteboardClient.canStartWhiteboard()) {
    try {
        await whiteboardClient.startWhiteboardScreen(whiteboardElement);
        console.log("Whiteboard started successfully");
    } catch (error) {
        console.error("Failed to start whiteboard:", error);
    }
}

// Export before stopping
async function stopWithExport() {
    await whiteboardClient.exportWhiteboard("pdf", "session-whiteboard");
    await whiteboardClient.stopWhiteboardScreen();
}
```

--------------------------------

### JavaScript example: startVideo and attachVideo (async/await)

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/references/video/video.md

Starts the video stream and attaches the self view using async/await. Equivalent to the promise-based example, but with cleaner syntax.

```javascript
await stream.startVideo();

let userVideo = await stream.attachVideo(
    client.getCurrentUserInfo().userId,
    RESOLUTION,
);

document.querySelector("video-player-container").appendChild(userVideo);
```

--------------------------------

### Complete working example: join and setup command channel

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/examples/command-channel.md

Full example showing initialization, joining, activating the command channel, and handling status and message events. Includes functions to send commands to all or specific participants and a handler for incoming commands.

```javascript
import ZoomVideo from '@zoom/videosdk';

const client = ZoomVideo.createClient();

async function joinAndSetupCommandChannel(topic, jwt, userName) {
    // 1. Initialize
    await client.init('en-US', 'Global', { patchJsMedia: true });

    // 2. Join session
    await client.join(topic, jwt, userName);

    // 3. Activate command channel (MUST be after join)
    const cmdClient = client.getCommandClient();

    // 4. Listen for connection status
    client.on('command-channel-status', (status) => {
        console.log('Command channel status:', status);
        if (status === true) {
            console.log('Command channel connected - ready to send');
        }
    });

    // 5. Listen for incoming commands
    client.on('command-channel-message', (payload) => {
        try {
            const data = JSON.parse(payload.text);
            console.log('Command received:', data);
            handleCommand(data);
        } catch (e) {
            console.log('Raw command received:', payload.text);
        }
    });

    return cmdClient;
}

// Send a command (broadcast to all participants in session)
function sendCommand(cmdClient, type, data) {
    const message = JSON.stringify({ type, data });
    cmdClient.send(message);
}

// Send to a specific participant
function sendCommandToUser(cmdClient, userId, type, data) {
    const message = JSON.stringify({ type, data });
    cmdClient.send(message, userId);
}

// Handle incoming commands
function handleCommand(data) {
    switch (data.type) {
        case 'ping':
            console.log('Received ping');
            break;
        case 'transfer':
            console.log('Transfer info:', data);
            break;
        default:
            console.log('Unknown command type:', data.type);
    }
}
```

--------------------------------

### Headless Linux Audio Setup with PulseAudio

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/linux/linux.md

Setup for headless Linux environments (Docker/WSL). Installs and starts PulseAudio, creates virtual audio devices, and writes a zoomus.conf configuration file. Alternatively, use the IZoomVideoSDKVirtualAudioSpeaker and IZoomVideoSDKVirtualAudioMic interfaces.

```bash
# Install PulseAudio
sudo apt install -y pulseaudio
pulseaudio --start

# Create virtual devices
pactl load-module module-null-sink sink_name=virtual_speaker
pactl load-module module-null-source source_name=virtual_mic

# Configure
mkdir -p ~/.config
cat > ~/.config/zoomus.conf << EOF
[General]
system.audio.type=default
EOF
```

--------------------------------

### Start and Join Sessions

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/references/sessions.md

Code examples for starting and joining a Video SDK session, including initialization and media stream retrieval.

```APIDOC
## [JS] ZoomVideo.createClient()

### Description
Creates a new Video SDK client instance.

### Method
createClient()

### Endpoint
ZoomVideo.createClient()

### Parameters
None

### Request Example
```javascript
var client = ZoomVideo.createClient();
```

### Response
#### Success Response
- **client** (VideoClient) - The Video SDK client instance.

#### Response Example
```javascript
var client = ZoomVideo.createClient();
```
```

```APIDOC
## [JS] client.init(language, env, options)

### Description
Initializes the Video SDK. Must be called before joining a session.

### Method
init()

### Endpoint
client.init(language, env, options)

### Parameters
#### Parameters
- **language** (string) - Required - The language code for the SDK (e.g., "en-US").
- **env** (string) - Required - The environment (e.g., "Global").
- **options** (object) - Optional - Initialization options.
  - **patchJsMedia** (boolean) - Optional - Set to `true` to automatically receive non-breaking enhancements and fixes.
  - **stayAwake** (boolean) - Optional - Prevents devices from sleeping while the user is in a session.
  - **leaveOnPageUnload** (boolean) - Optional - Removes the user from the session when they refresh or close the page.

### Request Example
```javascript
client.init("en-US", "Global", { patchJsMedia: true })
```

### Response
#### Success Response
- **Promise** - Resolves when initialization is complete.

#### Response Example
```javascript
client.init("en-US", "Global", { patchJsMedia: true }).then(() => { });
```
```

```APIDOC
## [JS] client.join(sessionName, token, userName, sessionPasscode)

### Description
Joins a Video SDK session. The session begins when the first user joins.

### Method
join()

### Endpoint
client.join(sessionName, token, userName, sessionPasscode)

### Parameters
#### Parameters
- **sessionName** (string) - Required - The session name. Must match the `tpc` in the Video SDK JWT.
- **token** (string) - Required - The Video SDK JWT.
- **userName** (string) - Required - The display name of the user.
- **sessionPasscode** (string) - Optional - The session passcode. If set for a session, it's required for other users joining that session.

### Request Example
```javascript
client.join("sessionName", "VIDEO_SDK_JWT", "userName", "sessionPasscode")
```

### Response
#### Success Response
- **Promise** - Resolves when the user has joined the session.

#### Response Example
```javascript
client.join("sessionName", "VIDEO_SDK_JWT", "userName", "sessionPasscode").then(() => { });
```
```

```APIDOC
## [JS] client.getMediaStream()

### Description
Returns the media stream namespace used to build out features.

### Method
getMediaStream()

### Endpoint
client.getMediaStream()

### Parameters
None

### Request Example
```javascript
stream = client.getMediaStream();
```

### Response
#### Success Response
- **stream** (MediaStream) - The media stream object.

#### Response Example
```javascript
stream = client.getMediaStream();
```
```

--------------------------------

### Set Up Token Server with Auth Endpoint Sample

Source: https://github.com/zoom/skills/blob/main/skills/cobrowse-sdk/get-started.md

Sets up the official auth endpoint sample. Clones the repository, installs dependencies, creates a .env file with SDK credentials and port, then starts the server.

```bash
# Clone the sample
git clone https://github.com/zoom/cobrowsesdk-auth-endpoint-sample.git
cd cobrowsesdk-auth-endpoint-sample

# Install dependencies
npm install

# Create .env file
cat > .env << EOF
ZOOM_SDK_KEY=your_sdk_key_here
ZOOM_SDK_SECRET=your_sdk_secret_here
PORT=4000
EOF

# Start the server
npm start
```

--------------------------------

### Start and Render Own Video with attachVideo()

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/examples/video-rendering.md

JavaScript example showing how to start video capture and attach the returned video-player element to a container. Requires joining a session first.

```javascript
import ZoomVideo, { VideoQuality } from '@zoom/videosdk';

const client = ZoomVideo.createClient();
let stream;

async function startOwnVideo() {
  // Ensure you're joined first
  stream = client.getMediaStream();
  
  // Step 1: Start capturing video
  await stream.startVideo();
  
  // Step 2: Get current user ID
  const currentUser = client.getCurrentUserInfo();
  
  // Step 3: Attach video to DOM
  const videoElement = await stream.attachVideo(
    currentUser.userId,
    VideoQuality.Video_360P
  );
  
  // Step 4: Add to container
  document.getElementById('my-video-container').appendChild(videoElement);
}
```

--------------------------------

### Set up PulseAudio for headless raw audio

Source: https://github.com/zoom/skills/blob/main/skills/meeting-sdk/linux/SKILL.md

Install PulseAudio, create the required zoomus.conf config file, and start PulseAudio with virtual null-sink devices for raw audio in headless/Docker environments. This is the critical setup for raw audio capture.

```bash
apt-get install -y pulseaudio pulseaudio-utils

# Create config file
mkdir -p ~/.config
cat > ~/.config/zoomus.conf << EOF
[General]
system.audio.type=default
EOF

# Start PulseAudio with virtual devices
pulseaudio --start --exit-idle-time=-1
pactl load-module module-null-sink sink_name=virtual_speaker
pactl load-module module-null-sink sink_name=virtual_mic
```

--------------------------------

### Complete Working Code for main.cpp

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/windows/examples/session-join-pattern.md

This example demonstrates the full implementation of the IZoomVideoSDKDelegate interface and the necessary setup for session management in a C++ Windows application.

```cpp
#include <windows.h>
#include <cstdint>
#include <iostream>
#include <fstream>
#include <string>
#include <thread>
#include <chrono>

// SDK headers
#include "zoom_video_sdk_api.h"
#include "zoom_video_sdk_interface.h"
#include "zoom_video_sdk_delegate_interface.h"

// JSON parsing (optional - for config file)
#include <json/json.h>

USING_ZOOM_VIDEO_SDK_NAMESPACE

// Global state
IZoomVideoSDK* g_sdk = nullptr;
bool g_inSession = false;
bool g_exit = false;

// Configuration
std::wstring g_jwt;
std::wstring g_sessionName;
std::wstring g_sessionPassword;
std::wstring g_userName;

//─────────────────────────────────────────────────────────────────────────────
// DELEGATE IMPLEMENTATION
//─────────────────────────────────────────────────────────────────────────────

class MyDelegate : public IZoomVideoSDKDelegate {
public:
    // === SESSION LIFECYCLE ===
    
    void onSessionJoin() override {
        std::cout << "[EVENT] Session joined successfully!" << std::endl;
        g_inSession = true;
        
        // Connect audio
        IZoomVideoSDKAudioHelper* audioHelper = g_sdk->getAudioHelper();
        if (audioHelper) {
            audioHelper->startAudio();
            std::cout << "[ACTION] Audio connected" << std::endl;
        }
        
        // Start video
        IZoomVideoSDKVideoHelper* videoHelper = g_sdk->getVideoHelper();
        if (videoHelper) {
            videoHelper->startVideo();
            std::cout << "[ACTION] Video started" << std::endl;
        }
    }
    
    void onSessionLeave() override {
        std::cout << "[EVENT] Session left" << std::endl;
        g_inSession = false;
        g_exit = true;
    }
    
    void onError(ZoomVideoSDKErrors errorCode, int detailErrorCode) override {
        std::cout << "[ERROR] Code: " << errorCode 
                  << ", Detail: " << detailErrorCode << std::endl;
    }
    
    // === USER EVENTS ===
    
    void onUserJoin(IZoomVideoSDKUserHelper* helper,
                    IVideoSDKVector<IZoomVideoSDKUser*>* userList) override {
        for (int i = 0; i < userList->GetCount(); i++) {
            IZoomVideoSDKUser* user = userList->GetItem(i);
            std::wcout << L"[EVENT] User joined: " << user->getUserName() << std::endl;
        }
    }
    
    void onUserLeave(IZoomVideoSDKUserHelper* helper,
                     IVideoSDKVector<IZoomVideoSDKUser*>* userList) override {
        for (int i = 0; i < userList->GetCount(); i++) {
            IZoomVideoSDKUser* user = userList->GetItem(i);
            std::wcout << L"[EVENT] User left: " << user->getUserName() << std::endl;
        }
    }
    
    void onUserVideoStatusChanged(IZoomVideoSDKVideoHelper* helper,
                                  IVideoSDKVector<IZoomVideoSDKUser*>* userList) override {
        for (int i = 0; i < userList->GetCount(); i++) {
            IZoomVideoSDKUser* user = userList->GetItem(i);
            bool isOn = user->GetVideoPipe()->getVideoStatus().isOn;
            std::wcout << L"[EVENT] Video " << (isOn ? L"ON" : L"OFF") 
                       << L": " << user->getUserName() << std::endl;
        }
    }
    
    void onUserAudioStatusChanged(IZoomVideoSDKAudioHelper* helper,
                                  IVideoSDKVector<IZoomVideoSDKUser*>* userList) override {
        for (int i = 0; i < userList->GetCount(); i++) {
            IZoomVideoSDKUser* user = userList->GetItem(i);
            bool isMuted = user->getAudioStatus().isMuted;
            std::wcout << L"[EVENT] Audio " << (isMuted ? L"muted" : L"unmuted") 
                       << L": " << user->getUserName() << std::endl;
        }
    }
    
    // === CHAT ===
    
    void onChatNewMessageNotify(IZoomVideoSDKChatHelper* helper,
                                IZoomVideoSDKChatMessage* msg) override {
        std::wcout << L"[CHAT] " << msg->getSendUser()->getUserName() 
                   << L": " << msg->getContent() << std::endl;
    }
    
    // === REQUIRED EMPTY IMPLEMENTATIONS ===
    // (All pure virtual methods must be implemented)
    
    void onSessionLeave(ZoomVideoSDKSessionLeaveReason reason) override {}
    void onSessionNeedPassword(IZoomVideoSDKPasswordHandler* handler) override {}
    void onSessionPasswordWrong(IZoomVideoSDKPasswordHandler* handler) override {}
    void onUserHostChanged(IZoomVideoSDKUserHelper* helper, IZoomVideoSDKUser* user) override {}
    void onUserManagerChanged(IZoomVideoSDKUser* user) override {}
    void onUserNameChanged(IZoomVideoSDKUser* user) override {}
```

--------------------------------

### Docker/headless setup commands

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/linux/troubleshooting/pulseaudio-setup.md

Installs PulseAudio, creates virtual audio devices, and configures Zoom for Docker or headless environments.

```bash
# Install PulseAudio
apt-get update && apt-get install -y pulseaudio

# Create virtual devices
pactl load-module module-null-sink sink_name=virtual_speaker
pactl load-module module-null-source source_name=virtual_mic

# Configure Zoom
mkdir -p ~/.config
echo "[General]" > ~/.config/zoomus.conf
echo "system.audio.type=default" >> ~/.config/zoomus.conf
```

--------------------------------

### Clone and run the token server sample

Source: https://github.com/zoom/skills/blob/main/skills/cobrowse-sdk/SKILL.md

Clones the official Zoom Cobrowse SDK auth endpoint sample, installs dependencies, creates a .env file with SDK credentials and port, and starts the server.

```bash
git clone https://github.com/zoom/cobrowsesdk-auth-endpoint-sample.git
cd cobrowsesdk-auth-endpoint-sample
npm install

# Create .env file
cat > .env << EOF
ZOOM_SDK_KEY=your_sdk_key_here
ZOOM_SDK_SECRET=your_sdk_secret_here
PORT=4000
EOF

npm start
```

--------------------------------

### Get Singleton: Navigate SDK Tree

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/windows/concepts/sdk-architecture-pattern.md

C++ example showing how to navigate the Zoom Video SDK singleton tree to obtain helpers, session, users, and per-user canvas/pipe objects. Objects are not constructed but navigated to.

```cpp
// Root singleton
IZoomVideoSDK* sdk = CreateZoomVideoSDKObj();

// Level 1: Helpers (control YOUR streams)
IZoomVideoSDKVideoHelper* videoHelper = sdk->getVideoHelper();
IZoomVideoSDKAudioHelper* audioHelper = sdk->getAudioHelper();
IZoomVideoSDKShareHelper* shareHelper = sdk->getShareHelper();
IZoomVideoSDKChatHelper* chatHelper = sdk->getChatHelper();

// Level 2: Session
IZoomVideoSDKSession* session = sdk->getSessionInfo();

// Level 3: Users
IZoomVideoSDKUser* myself = session->getMyself();
IVideoSDKVector<IZoomVideoSDKUser*>* remoteUsers = session->getRemoteUsers();

// Level 4: Canvas/Pipe (per user)
IZoomVideoSDKCanvas* canvas = user->GetVideoCanvas();
IZoomVideoSDKRawDataPipe* pipe = user->GetVideoPipe();
```

--------------------------------

### JavaScript example: startVideo and attachVideo (Promise-based)

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/references/video/video.md

Starts the video stream and attaches the self view to the video container using promises. Must be tied to a user button click to avoid browser blocking camera access.

```javascript
stream.startVideo().then(() => {
    stream
        .attachVideo(client.getCurrentUserInfo().userId, RESOLUTION)
        .then((userVideo) => {
            document
                .querySelector("video-player-container")
                .appendChild(userVideo);
        });
});
```

--------------------------------

### Get Meeting Details with Node.js

Source: https://github.com/zoom/skills/blob/main/skills/rest-api/examples/meeting-lifecycle.md

Node.js function to retrieve meeting details using the Zoom API. It uses fetch with a GET request and returns the parsed JSON response. The usage example logs the meeting topic, start time, and join URL.

```javascript
async function getMeeting(accessToken, meetingId) {
  const response = await fetch(
    `https://api.zoom.us/v2/meetings/${meetingId}`,
    {
      headers: {
        'Authorization': `Bearer ${accessToken}`
      }
    }
  );

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Failed to get meeting: ${error.message}`);
  }

  return await response.json();
}

// Usage
const meeting = await getMeeting(accessToken, 93123456789);
console.log('Meeting:', meeting.topic);
console.log('Start time:', meeting.start_time);
console.log('Join URL:', meeting.join_url);
```

--------------------------------

### ngrok setup and tunnel creation

Source: https://github.com/zoom/skills/blob/main/skills/general/use-cases/testing-development.md

Install ngrok globally, start a local server on port 3000, and create a tunnel to expose it. The output shows the forwarding URL to use as the webhook endpoint.

```bash
# Install ngrok
npm install -g ngrok

# Start your local server
node server.js  # Running on port 3000

# In another terminal, create tunnel
ngrok http 3000
```

```text
Forwarding  https://abc123.ngrok.io -> http://YOUR_DEV_HOST:3000
```

--------------------------------

### Get Meeting Summary with REST API

Source: https://github.com/zoom/skills/blob/main/skills/general/use-cases/ai-companion-integration.md

JavaScript function to fetch a meeting summary from the Zoom REST API. It double-encodes the meeting UUID if it starts with a slash, then sends a GET request with a bearer token. The response example shows the structure of the returned summary data. Requires admin role and an admin-managed app to avoid permission issues.

```javascript
// Get meeting summary
async function getMeetingSummary(meetingUUID) {
  // Double-encode UUID if it contains / or //
  const encodedUUID = meetingUUID.startsWith('/') 
    ? encodeURIComponent(encodeURIComponent(meetingUUID))
    : encodeURIComponent(meetingUUID);
  
  const response = await fetch(
    `https://api.zoom.us/v2/meetings/${encodedUUID}/meeting_summary`,
    {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );
  
  return response.json();
}
```

```json
// Response example
{
  "meeting_uuid": "abc123...",
  "meeting_id": 12345678901,
  "meeting_topic": "Weekly Team Sync",
  "meeting_start_time": "2024-01-15T10:00:00Z",
  "meeting_end_time": "2024-01-15T10:45:00Z",
  "summary_start_time": "2024-01-15T10:00:00Z",
  "summary_end_time": "2024-01-15T10:45:00Z",
  "summary_content": {
    "summary": "The team discussed Q1 roadmap priorities...",
    "next_steps": [
      "John to finalize design specs by Friday",
      "Sarah to schedule customer interviews"
    ],
    "keywords": ["roadmap", "Q1", "design", "customers"]
  }
}
```

--------------------------------

### Basic Setup with connect() and postMessage()

Source: https://github.com/zoom/skills/blob/main/skills/zoom-apps-sdk/examples/app-communication.md

Basic setup for app instance communication. Both instances must call connect() independently. Messages are JSON strings that must be stringified and parsed.

```javascript
import zoomSdk from '@zoom/appssdk';

await zoomSdk.config({
  capabilities: ['connect', 'postMessage', 'onConnect', 'onMessage'],
  version: '0.16'
});

// Both instances must call connect()
await zoomSdk.connect();

// Know when the other instance connects
zoomSdk.addEventListener('onConnect', (event) => {
  console.log('Other instance connected');
});

// Send a message
await zoomSdk.postMessage({
  payload: JSON.stringify({ type: 'greeting', data: 'Hello from this instance!' })
});

// Receive messages
zoomSdk.addEventListener('onMessage', (event) => {
  const message = JSON.parse(event.payload);
  console.log('Received:', message.type, message.data);
});
```

--------------------------------

### Docker Deployment with setup-pulseaudio.sh

Source: https://github.com/zoom/skills/blob/main/skills/general/use-cases/transcription-bot-linux.md

Docker deployment setup for a transcription bot. The Dockerfile installs dependencies, configures PulseAudio for headless audio, copies the SDK and app, and runs setup-pulseaudio.sh which starts PulseAudio and creates virtual speaker and microphone devices.

```dockerfile
FROM ubuntu:22.04

# Install dependencies
RUN apt-get update && apt-get install -y \
    build-essential cmake \
    libx11-xcb1 libxcb-xfixes0 libxcb-shape0 libxcb-shm0 \
    libxcb-randr0 libxcb-image0 libxcb-keysyms1 libxcb-xtest0 \
    libglib2.0-dev libcurl4-openssl-dev \
    pulseaudio pulseaudio-utils

# Setup PulseAudio for headless audio
RUN mkdir -p ~/.config && \
    echo "[General]\nsystem.audio.type=default" > ~/.config/zoomus.conf

# Copy SDK and app
COPY zoom_meeting_sdk/ /app/lib/
COPY transcription_bot /app/

# Setup PulseAudio virtual devices
COPY setup-pulseaudio.sh /app/
RUN chmod +x /app/setup-pulseaudio.sh

CMD ["/app/setup-pulseaudio.sh && /app/transcription_bot"]
```

```bash
#!/bin/bash
# Start PulseAudio daemon
pulseaudio --start --exit-idle-time=-1

# Create virtual speaker
pactl load-module module-null-sink sink_name=virtual_speaker

# Create virtual microphone
pactl load-module module-null-sink sink_name=virtual_mic

echo "PulseAudio configured for headless operation"
```

--------------------------------

### Build and run the demo

Source: https://github.com/zoom/skills/blob/main/skills/meeting-sdk/linux/linux.md

Build the demo with CMake and run the resulting binary. Assumes the project structure and SDK files are already set up.

```bash
cd demo
cmake -B build
cd build
make
cd ../bin
./meetingSDKDemo
```

--------------------------------

### Initialize SDK and join session (C++)

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/linux/SKILL.md

C++ example showing how to create and initialize the Zoom Video SDK, add a listener, and join a session with audio and video options. Includes a virtual audio speaker for headless operation.

```cpp
#include "zoom_video_sdk_api.h"
#include "zoom_video_sdk_interface.h"
#include "zoom_video_sdk_delegate_interface.h"

USING_ZOOM_VIDEO_SDK_NAMESPACE

// 1. Create SDK
IZoomVideoSDK* sdk = CreateZoomVideoSDKObj();

// 2. Initialize
ZoomVideoSDKInitParams init_params;
init_params.domain = "https://zoom.us";
init_params.enableLog = true;
init_params.logFilePrefix = "bot";
init_params.videoRawDataMemoryMode = ZoomVideoSDKRawDataMemoryModeHeap;
init_params.shareRawDataMemoryMode = ZoomVideoSDKRawDataMemoryModeHeap;
init_params.audioRawDataMemoryMode = ZoomVideoSDKRawDataMemoryModeHeap;

sdk->initialize(init_params);

// 3. Add delegate
sdk->addListener(myDelegate);

// 4. Join session
ZoomVideoSDKSessionContext ctx;
ctx.sessionName = "my-session";
ctx.userName = "Linux Bot";
ctx.token = "jwt-token";
ctx.audioOption.connect = true;
ctx.audioOption.mute = false;
ctx.videoOption.localVideoOn = false;

// For headless: Virtual audio speaker
ctx.virtualAudioSpeaker = new VirtualSpeaker();

IZoomVideoSDKSession* session = sdk->joinSession(ctx);
```

--------------------------------

### Start Annotation and Get Controller

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/references/screen-share.md

Starts annotation after sharing or viewing share, then retrieves the annotation controller.

```typescript
// After starting share or viewing share
await stream.startAnnotation();

// Get annotation controller
const controller = stream.getAnnotationController();
```

--------------------------------

### Initialize Project

Source: https://github.com/zoom/skills/blob/main/skills/team-chat/examples/chatbot-setup.md

Commands to create the project directory and initialize npm.

```bash
mkdir my-zoom-chatbot
cd my-zoom-chatbot
npm init -y
```

--------------------------------

### Start Live Transcription and Get Status

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/references/features.md

Starts live transcription and retrieves the current status, including supported languages.

```typescript
await transcription.startLiveTranscription();

// Get supported languages
const status = transcription.getLiveTranscriptionStatus();
const languages = status.transcriptionLanguage;
```

--------------------------------

### C# Quick Start: Initialize and Join Session

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/windows/SKILL.md

C# example using the ZoomVideoSDK namespace to initialize the SDK manager and join a session with a JWT token. Requires .NET Framework 4.8 or later and C++/CLI support in Visual Studio.

```csharp
using ZoomVideoSDK;

var sdkManager = new ZoomSDKManager();
sdkManager.Initialize();
sdkManager.JoinSession("my-session", "jwt-token", "User Name", "");
```

--------------------------------

### Complete Transcription Manager with Usage

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/examples/transcription.md

Complete TranscriptionManager class that wraps the live transcription client. It handles caption messages, status changes, and provides methods to start transcription, set languages, disable translation, get status, and retrieve history. Includes usage example with event handlers and UI element wiring.

```javascript
import { LiveTranscriptionLanguage } from '@zoom/videosdk';

class TranscriptionManager {
  constructor(client) {
    this.client = client;
    this.transcriptionClient = null;
    this.transcriptions = [];
    this.interimMap = new Map(); // Track interim results by speaker
    this.onTranscriptionUpdate = null;
    this.onStatusChange = null;
  }

  init() {
    this.transcriptionClient = this.client.getLiveTranscriptionClient();
    this.setupEventListeners();
  }

  setupEventListeners() {
    // Transcription messages
    this.client.on('caption-message', (payload) => {
      this.handleCaptionMessage(payload);
    });

    // Status changes
    this.client.on('caption-status', (payload) => {
      if (this.onStatusChange) {
        this.onStatusChange(payload);
      }
    });

    // Captions enabled/disabled
    this.client.on('caption-enable', (isEnabled) => {
      if (this.onStatusChange) {
        this.onStatusChange({ enabled: isEnabled });
      }
    });
  }

  handleCaptionMessage(payload) {
    const { userId, displayName, text, done, source, timestamp } = payload;
    const key = `${userId}-${source}`;

    if (done) {
      // Final result - move from interim to final
      this.interimMap.delete(key);
      this.transcriptions.push({
        userId,
        displayName,
        text,
        source,
        timestamp,
        isFinal: true,
      });
    } else {
      // Interim result - update in place
      this.interimMap.set(key, {
        userId,
        displayName,
        text,
        source,
        timestamp,
        isFinal: false,
      });
    }

    if (this.onTranscriptionUpdate) {
      this.onTranscriptionUpdate(this.getAllTranscriptions());
    }
  }

  getAllTranscriptions() {
    // Combine final transcriptions with current interim results
    const interim = Array.from(this.interimMap.values());
    return [...this.transcriptions, ...interim];
  }

  async start() {
    await this.transcriptionClient.startLiveTranscription();
  }

  async setSpeakingLanguage(language) {
    await this.transcriptionClient.setSpeakingLanguage(language);
  }

  async setTranslationLanguage(language) {
    await this.transcriptionClient.setTranslationLanguage(language);
  }

  async disableTranslation() {
    await this.transcriptionClient.setTranslationLanguage();
  }

  getStatus() {
    return this.transcriptionClient.getLiveTranscriptionStatus();
  }

  async getHistory() {
    const history = this.transcriptionClient.getFullTranscriptionHistory();
    if (history instanceof Promise) {
      return await history;
    }
    return history;
  }
}

// Usage
const transcriptionManager = new TranscriptionManager(client);
transcriptionManager.init();

transcriptionManager.onTranscriptionUpdate = (transcriptions) => {
  renderTranscriptions(transcriptions);
};

// Start transcription
document.getElementById('start-captions').onclick = async () => {
  await transcriptionManager.start();
};

// Change language
document.getElementById('language-select').onchange = async (e) => {
  await transcriptionManager.setSpeakingLanguage(e.target.value);
};
```

--------------------------------

### Client View Full Example with ZoomMtg

Source: https://github.com/zoom/skills/blob/main/skills/meeting-sdk/web/references/web.md

Full client view example: imports ZoomMtg, checks system requirements, preloads WebAssembly, initializes the SDK with a leave URL and CORP setting, then joins a meeting with credentials. Includes success and error callbacks for init and join, and retrieves attendee list and current user info.

```javascript
import { ZoomMtg } from '@zoom/meetingsdk';

// Check system requirements
console.log(ZoomMtg.checkSystemRequirements());

// Preload WebAssembly for faster init
ZoomMtg.preLoadWasm();
ZoomMtg.prepareWebSDK();

// Initialize and join
ZoomMtg.init({
  leaveUrl: '/meeting-ended',
  disableCORP: !window.crossOriginIsolated, // Disable if no COOP/COEP
  success: () => {
    ZoomMtg.join({
      meetingNumber: '123456789',
      userName: 'User Name',
      signature: signature, // From auth endpoint
      userEmail: 'user@example.com',
      passWord: 'meeting-password',
      success: (res) => {
        console.log('Joined meeting');
        ZoomMtg.getAttendeeslist({});
        ZoomMtg.getCurrentUser({
          success: (res) => console.log('Current user:', res.result.currentUser)
        });
      },
      error: (err) => console.error('Join error:', err)
    });
  },
  error: (err) => console.error('Init error:', err)
});
```

--------------------------------

### Set up and run the JWT token generator server

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/references/react.md

Clone the Zoom Video SDK auth endpoint sample, install dependencies with Bun or npm, configure the .env file with your SDK key and secret, and start the JWT token generator server.

```bash
git clone https://github.com/zoom/videosdk-auth-endpoint-sample.git

cd videosdk-auth-endpoint-sample

bun install
# or 
npm install
# Rename .env.example to .env, edit the file contents to include your Zoom Video SDK key and secret, save the file contents, and close the file
mv .env.example .env
# Start the server
# server code https://raw.githubusercontent.com/zoom/videosdk-auth-endpoint-sample/refs/heads/master/src/index.js
bun run start
# call 
# or
npm run start
```

--------------------------------

### Run Zoom App Locally

Source: https://github.com/zoom/skills/blob/main/skills/zoom-apps-sdk/examples/quick-start.md

Commands to install dependencies, start an ngrok tunnel, update the .env file with the ngrok URL, and start the server for local development.

```bash
# 1. Install dependencies
npm install

# 2. Start ngrok tunnel
ngrok http 3000

# 3. Copy the https URL (e.g., https://abc123.ngrok.io)

# 4. Update .env with ngrok URL
# ZOOM_APP_REDIRECT_URI=https://abc123.ngrok.io/auth

# 5. Start server
npm run dev
```

--------------------------------

### Start screen share with async/await

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/web/references/screen-sharing/share.md

Uses the `await` operator to start screen sharing, selecting the video or canvas element based on `isStartShareScreenWithVideoElement()`. Errors are not caught in this example.

```javascript
if (stream.isStartShareScreenWithVideoElement()) {
    await stream.startShareScreen(
        document.querySelector("#my-screen-share-content-video"),
    );
    // screen share successfully started and rendered
} else {
    await stream.startShareScreen(
        document.querySelector("#my-screen-share-content-canvas"),
    );
    // screen share successfully started and rendered
}
```

--------------------------------

### Complete Integration Example for Captions and Transcription

Source: https://github.com/zoom/skills/blob/main/skills/meeting-sdk/windows/examples/captions-transcription.md

Shows the main integration flow: initialize captions, check transcription features, start live transcription, and for hosts enable manual captions and assign caption privilege to self.

```cpp
void onInMeeting(IMeetingService* meetingService) {
    initializeCaptions(meetingService);
    
    // Check available features
    checkTranscriptionFeatures();
    
    // Start live transcription with translation
    startLiveTranscription();
}

// For host: enable manual captions
void onIsHost() {
    enableManualCaptions();
    assignCaptionPrivilege(0, true);  // Assign to self
}
```

--------------------------------

### Project structure: videosdk-linux-qt-quickstart

Source: https://github.com/zoom/skills/blob/main/skills/general/use-cases/sdk-wrappers-gui.md

Directory tree of the videosdk-linux-qt-quickstart project, listing the run script, CMakeLists.txt, config.json, build output, SDK headers/libraries, and the main source files for the Qt demo.

```text
videosdk-linux-qt-quickstart/
├── README.md
├── run_qt_demo.sh                    # Run script
├── src/
│   ├── CMakeLists.txt                # Qt6/Qt5 build config
│   ├── config.json                   # Session config
│   ├── bin/                          # Build output
│   │   └── VideoSDKQtDemo
│   ├── include/                      # SDK headers
│   ├── lib/                          # SDK libraries
│   └── Source Files:
│       ├── zoom_v-sdk_linux_bot_qt.cpp   # Main entry
│       ├── QtMainWindow.h/cpp            # Main window
│       ├── QtVideoWidget.h/cpp           # Video display
│       ├── QtVideoRenderer.h/cpp         # YUV→RGB rendering
│       ├── QtPreviewVideoHandler.h/cpp   # Self video
│       └── QtRemoteVideoHandler.h/cpp    # Remote video
```

--------------------------------

### GET /v2/users/me

Source: https://github.com/zoom/skills/blob/main/skills/oauth/SKILL.md

Calls the Zoom API using an access token. The `me` context targets the token's associated user. This example shows a GET request to retrieve user information.

```APIDOC
## GET /v2/users/me

### Description
Calls the Zoom API using an access token. The `me` context targets the token's associated user. This example shows a GET request to retrieve user information.

### Method
GET

### Endpoint
https://api.zoom.us/v2/users/me

### Headers
- **Authorization** (string) - Required - Bearer token obtained from the token endpoint.

### Request Example
```bash
GET https://api.zoom.us/v2/users/me

Headers:
Authorization: Bearer {ACCESS_TOKEN}
```

### Response
#### Success Response (200)
- Response body not specified in source.

### Notes
- The `me` context can be used in place of `userID` for endpoints that accept a user ID. Supported methods for `/v2/users/me` are GET and PATCH.
```

--------------------------------

### Breakout Rooms Complete Workflow Example

Source: https://github.com/zoom/skills/blob/main/skills/meeting-sdk/windows/examples/breakout-rooms.md

Complete workflow for breakout rooms: set up listener, configure and create rooms, assign users, start rooms, and join as attendee. Requires SDK initialization and role callbacks.

```cpp
void OnInMeeting() {
    // Set up listener first
    SetupBreakoutRoomListener();
    
    // Wait for role callbacks...
}

void OnCreatorRoleReceived(IBOCreator* creator, IBOData* data) {
    // Step 1: Configure options
    ConfigureBreakoutRooms(creator);
    
    // Step 2: Create rooms
    creator->CreateBO(L"Team Alpha");
    creator->CreateBO(L"Team Beta");
    
    // Step 3: Wait for onCreateBOResponse callback...
}

void OnRoomsCreated(IBOCreator* creator, IBOData* data, IBOAdmin* admin) {
    // Step 4: Assign users
    PreassignUser(creator, data, L"John", L"Team Alpha");
    PreassignUser(creator, data, L"Jane", L"Team Beta");
    
    // Step 5: Start rooms
    StartBreakoutRooms(admin);
}

void OnAttendeeRoleReceived(IBOAttendee* attendee) {
    // As a participant, join your assigned room
    JoinMyBreakoutRoom(attendee);
}
```

--------------------------------

### .env.example Template

Source: https://github.com/zoom/skills/blob/main/skills/team-chat/concepts/environment-setup.md

Template for .env.example file to be created in project root. Includes placeholders for both API credentials and server configuration.

```bash
# Zoom App Credentials (Required for both APIs)
ZOOM_CLIENT_ID=
ZOOM_CLIENT_SECRET=
ZOOM_REDIRECT_URI=http://YOUR_DEV_HOST:4000/auth/callback

# Chatbot Credentials (Required for Chatbot API only)
ZOOM_BOT_JID=
ZOOM_VERIFICATION_TOKEN=
ZOOM_ACCOUNT_ID=

# Server Configuration
PORT=4000
```

--------------------------------

### Bootstrap TeamChatClient with OAuth installer

Source: https://github.com/zoom/skills/blob/main/skills/rivet-sdk/examples/getting-started-pattern.md

Minimal Rivet bootstrap for Team Chat with OAuth installation support. Creates a TeamChatClient using environment variables for credentials and installer options, subscribes to the chat_message.sent event, and starts the server on the configured port (default 8080).

```javascript
import { TeamChatClient } from "@zoom/rivet/teamchat";

(async () => {
  const teamchatClient = new TeamChatClient({
    clientId: process.env.RIVET_CLIENT_ID,
    clientSecret: process.env.RIVET_CLIENT_SECRET,
    webhooksSecretToken: process.env.RIVET_WEBHOOK_SECRET_TOKEN,
    installerOptions: {
      redirectUri: process.env.RIVET_REDIRECT_URI,
      stateStore: process.env.RIVET_STATE_STORE_SECRET,
    },
    port: Number(process.env.RIVET_PORT || 8080),
  });

  teamchatClient.webEventConsumer.event("chat_message.sent", ({ payload }) => {
    console.log("event", payload);
  });

  const server = await teamchatClient.start();
  console.log("rivet server", server.address());
})();
```

--------------------------------

### Level 2 Audio Feature Example

Source: https://github.com/zoom/skills/blob/main/skills/meeting-sdk/windows/concepts/singleton-hierarchy.md

Level 2 basic feature example for audio: get the audio controller and use it to join VoIP and mute the local user (0 = self).

```cpp
// Get controller
IMeetingAudioController* audioCtrl = meetingService->GetMeetingAudioController();

// Use it
audioCtrl->JoinVoip();
audioCtrl->MuteAudio(0, true);  // 0 = self
```

--------------------------------

### Qt platform run options

Source: https://github.com/zoom/skills/blob/main/skills/video-sdk/linux/linux.md

Run the Qt demo with different platform options: desktop, headless (offscreen), Wayland, or X11 with SSH forwarding.

```bash
# Desktop
./run_qt_demo.sh

# Headless/Server
QT_QPA_PLATFORM=offscreen ./run_qt_demo.sh

# Wayland
QT_QPA_PLATFORM=wayland ./run_qt_demo.sh

# X11 with SSH forwarding
ssh -X user@host
export DISPLAY=:10.0
./run_qt_demo.sh
```
Tokens:
Raw