Zoom Realtime Media Streams (RTMS) SDK

https://github.com/zoom/rtms
Admin
The Zoom Realtime Media Streams (RTMS) SDK provides bindings for developers to connect to live Zoom...
Tokens:38,732
Snippets:304
Trust Score:8.2
License:MIT
Update:8 months ago
Show doc for...
Tokens:
Raw
### Set up Python Virtual Environment and Install RTMS SDK

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This guide details the steps to set up a Python virtual environment and install the necessary dependencies, including the RTMS SDK and python-dotenv, for a Zoom RTMS project.

```bash
# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
pip install python-dotenv rtms
```

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

### Task Build System Examples

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Illustrative examples of using the Task build system for common operations such as building Node.js packages, building Python wheels for specific platforms, publishing Node.js prebuilds, and verifying the development environment.

```bash
task build:js
task build:py:linux
task publish:js
task doctor
```

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

### Configure Environment Variables for Zoom RTMS in Node.js

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This example shows how to set up environment variables for the Zoom RTMS SDK in a Node.js project. It requires client ID and secret, with optional settings for port, path, and log level.

```bash
# Required
ZM_RTMS_CLIENT=your_client_id
ZM_RTMS_SECRET=your_client_secret

# Optional
ZM_RTMS_PORT=8080
ZM_RTMS_PATH=/webhook
ZM_RTMS_LOG_LEVEL=debug
```

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

### Python Environment Setup for RTMS

Source: https://github.com/zoom/rtms/blob/main/README.md

This bash script outlines the steps to set up a Python virtual environment and install necessary dependencies for the RTMS SDK. It includes creating and activating the environment, and installing packages using pip. A sample `.env` file structure is also provided.

```bash
# Create virtual environment
python3 -m venv .venv

# Activate virtual environment
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
pip install python-dotenv

# Install RTMS SDK
pip install rtms
```

```dotenv
# Required - Your Zoom OAuth credentials
ZM_RTMS_CLIENT=your_client_id
ZM_RTMS_SECRET=your_client_secret

# Optional - Webhook server configuration
ZM_RTMS_PORT=8080
ZM_RTMS_PATH=/webhook

# Optional - Logging configuration
ZM_RTMS_LOG_LEVEL=debug          # error, warn, info, debug, trace
ZM_RTMS_LOG_FORMAT=progressive    # progressive or json
ZM_RTMS_LOG_ENABLED=true          # true or false
```

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

### Python - Basic RTMS Client Setup

Source: https://github.com/zoom/rtms/blob/main/README.md

Provides a basic setup for the RTMS client in Python, including necessary imports, client instantiation, and a signal handler for graceful shutdown. This serves as a starting point for RTMS applications in Python. Requires the 'rtms' and 'python-dotenv' packages.

```python
#!/usr/bin/env python3
import rtms
import signal
import sys
from dotenv import load_dotenv

load_dotenv()

client = rtms.Client()

# Graceful shutdown handler
def signal_handler(sig, frame):
    print('\nShutting down gracefully...')
    client.leave()
    sys.exit(0)

signal.signal(signal.SIGINT, signal_handler)

```

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

### Install RTMS SDK for Node.js

Source: https://github.com/zoom/rtms/blob/main/examples/README.md

Installs the Zoom RTMS SDK using npm. Requires Node.js version 20.3.0 or higher, with Node.js 24 LTS recommended.

```bash
npm install @zoom/rtms
```

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

### Install Python Build Tools

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Installs the necessary Python packages for building and uploading Python packages to PyPI. This includes the 'build' package for creating distributions, 'twine' for uploading, and 'wheel' for building wheel packages.

```bash
pip install build twine wheel
```

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

### Configure Environment Variables for Zoom RTMS in Python

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This example illustrates the configuration of environment variables for the Zoom RTMS SDK in a Python project using a .env file. It specifies required credentials and optional settings for logging and server configuration.

```bash
# Required
ZM_RTMS_CLIENT=your_client_id
ZM_RTMS_SECRET=your_client_secret

# Optional
ZM_RTMS_PORT=8080
ZM_RTMS_PATH=/webhook
ZM_RTMS_LOG_LEVEL=debug
ZM_RTMS_LOG_FORMAT=progressive
ZM_RTMS_LOG_ENABLED=true
```

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

### Install RTMS SDK for Python

Source: https://github.com/zoom/rtms/blob/main/examples/README.md

Installs the Zoom RTMS SDK using pip. Requires Python version 3.10 or higher, with Python 3.12 or 3.13 recommended.

```bash
pip install rtms
```

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

### Install Task on Linux

Source: https://github.com/zoom/rtms/blob/main/CONTRIBUTING.md

Commands to install the Go Task task runner on Linux by downloading and executing the installation script, and then exporting the PATH to include the binary.

```bash
# Linux
sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d -b ~/.local/bin
export PATH=$HOME/.local/bin:$PATH
```

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

### Verify Deployment (Python)

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Commands to verify the successful deployment of the rtms package to PyPI. Includes checking PyPI, installing the package with different Python versions, and testing the import.

```bash
# Check PyPI
pip search rtms
# Or visit: https://pypi.org/project/rtms/

# Test installation (try different Python versions)
python3.10 -m pip install rtms
python3.11 -m pip install rtms
python3.12 -m pip install rtms
python3.13 -m pip install rtms

# Test import
python -c "import rtms; print(rtms.__version__)"
```

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

### Initialize Project Dependencies and SDK

Source: https://github.com/zoom/rtms/blob/main/CONTRIBUTING.md

Sets up the project by fetching necessary SDK components and installing required dependencies. This command ensures the local environment is ready for building and testing.

```bash
task setup
```

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

### Handle Webinar RTMS Started Event in Node.js

Source: https://github.com/zoom/rtms/blob/main/examples/webinars.md

This Node.js snippet demonstrates how to listen for the 'webinar.rtms_started' webhook event and join the webinar stream using the RTMS SDK. It includes an example of processing incoming audio data.

```javascript
import rtms from "@zoom/rtms";

rtms.onWebhookEvent(({event, payload}) => {
    if (event !== "webinar.rtms_started") return;

    const client = new rtms.Client();

    client.onAudioData((data, timestamp, metadata) => {
        console.log(`Webinar audio from ${metadata.userName}`);
    });

    client.join(payload);
});
```

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

### Create Node.js Prebuilds

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Creates platform-specific binary packages (prebuilds) for faster Node.js installations. This process generates prebuilds for multiple N-API versions and platforms, ensuring compatibility. The output files are placed in the 'prebuilds/' directory.

```bash
# Create prebuild for specific platform (builds for N-API 9 and 10)
task prebuild:js:darwin   # macOS arm64 (N-API 9 + 10)
task prebuild:js:linux    # Linux x64 (N-API 9 + 10)

# Or create prebuilds for all platforms
task prebuild:js          # All 4 combinations
```

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

### Build RTMS SDK Locally

Source: https://github.com/zoom/rtms/blob/main/README.md

This section provides steps for building the RTMS SDK locally on macOS or Linux. It lists prerequisites including Node.js, Python, CMake, build tools, and Task. The process involves installing system dependencies, cloning the repository, placing SDK files, and running setup tasks.

```bash
# Install system dependencies
## macOS
brew install cmake go-task python@3.13 node@24

## Linux
sudo apt update
sudo apt install -y cmake python3-full python3-pip npm
sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d -b ~/.local/bin

# Clone and set up the repository
git clone https://github.com/zoom/rtms.git
cd rtms

# Place SDK files in the appropriate lib directory
# lib/linux-x64/ or lib/darwin-arm64/

# Verify your environment meets requirements
task doctor

# Setup project (fetches SDK if not present, installs dependencies)
task setup
```

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

### Manual Tag-Based Publishing for Python and Node.js

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Commands to create and push Git tags for Python and Node.js projects, which manually triggers the publishing workflow.

```bash
# For Python
git tag py-v1.0.0
git push origin py-v1.0.0

# For Node.js
git tag js-v1.0.0
git push origin js-v1.0.0
```

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

### Node.js Version Bump Commit Example

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Illustrates the Git commands required to update the Node.js version in `package.json` and commit the change. This process is part of the manual version bumping required before a new release.

```bash
# Edit package.json, update "version" field
vim package.json

# Commit version change
git add package.json
git commit -m "chore(js): bump version to X.Y.Z"
```

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

### Node.js Basic Webhook Integration

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

Integrates with Zoom webhooks to receive RTMS stream events and process audio data. Requires Node.js and the @zoom/rtms package.

```javascript
import rtms from "@zoom/rtms";

rtms.onWebhookEvent(({event, payload}) => {
    if (event !== "meeting.rtms_started") return;

    const client = new rtms.Client();

    client.onAudioData((data, timestamp, metadata) => {
        console.log(`Received audio: ${data.length} bytes from ${metadata.userName}`);
    });

    client.join(payload);
});
```

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

### Upload Node.js Prebuilds

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Bash commands to upload Node.js prebuilds using a GitHub token. Requires setting the `GITHUB_TOKEN` environment variable.

```bash
export GITHUB_TOKEN="your-token"
task publish:js:darwin
task publish:js:linux
```

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

### Install Task Build Tool (Linux)

Source: https://github.com/zoom/rtms/blob/main/CONTRIBUTING.md

Installs the Task build orchestration tool on Linux by downloading and executing an installation script. This command places the executable in ~/.local/bin.

```bash
sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d -b ~/.local/bin
```

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

### Test Python Release on TestPyPI

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Bash commands to publish a Python package to TestPyPI and test its installation. Requires setting `TWINE_USERNAME` and `TWINE_PASSWORD` environment variables for TestPyPI.

```bash
export TWINE_USERNAME="__token__"
export TWINE_PASSWORD="your-testpypi-token"

task publish:py:test

# Test installation
pip install -i https://test.pypi.org/simple/ rtms
python -c "import rtms; print(rtms.__version__)"
```

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

### Install Task on macOS

Source: https://github.com/zoom/rtms/blob/main/CONTRIBUTING.md

Command to install the Go Task task runner on macOS using Homebrew.

```bash
# macOS
brew install go-task
```

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

### Publish to TestPyPI via GitHub Actions

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Configuration options for running the 'Publish Packages' workflow to publish to TestPyPI instead of the production PyPI.

```bash
1. Go to Actions → "Publish Packages"
2. Click "Run workflow"
3. Language: `python`
4. Version: e.g., `1.0.0`
5. Dry run: `false`
6. Target: `test`
7. Run workflow
```

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

### Python Basic Webhook Integration

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

Integrates with Zoom webhooks to receive RTMS stream events and process audio data. Requires Python, rtms package, and dotenv for environment variables.

```python
#!/usr/bin/env python3
import rtms
import signal
import sys
from dotenv import load_dotenv

load_dotenv()

client = rtms.Client()

# Graceful shutdown handler
def signal_handler(sig, frame):
    print('\nShutting down gracefully...')
    client.leave()
    sys.exit(0)

signal.signal(signal.SIGINT, signal_handler)

# Webhook event handler
@client.on_webhook_event()
def handle_webhook(payload):
    if payload.get('event') == 'meeting.rtms_started':
        rtms_payload = payload.get('payload', {})
        client.join(
            meeting_uuid=rtms_payload.get('meeting_uuid'),
            rtms_stream_id=rtms_payload.get('rtms_stream_id'),
            server_urls=rtms_payload.get('server_urls'),
            signature=rtms_payload.get('signature')
        )

# Callback handlers
@client.onJoinConfirm
def on_join(reason):
    print(f'Joined meeting: {reason}')

@client.onAudioData
def on_audio(data, size, timestamp, metadata):
    print(f'Audio from {metadata.userName}: {size} bytes')

if __name__ == '__main__':
    print('Webhook server running on http://localhost:8080')
    import time
    while True:
        client._process_join_queue()
        client._poll_if_needed()
        time.sleep(0.01)
```

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

### Handle Webinar RTMS Started Event in Python

Source: https://github.com/zoom/rtms/blob/main/examples/webinars.md

This Python snippet shows how to handle the 'webinar.rtms_started' webhook event and join a webinar stream using the RTMS SDK. It also includes a callback for processing audio data.

```python
import rtms

client = rtms.Client()

@client.on_webhook_event()
def handle_webhook(payload):
    if payload.get('event') == 'webinar.rtms_started':
        rtms_payload = payload.get('payload', {})
        client.join(
            meeting_uuid=rtms_payload.get('meeting_uuid'),
            rtms_stream_id=rtms_payload.get('rtms_stream_id'),
            server_urls=rtms_payload.get('server_urls')
        )

@client.onAudioData
def on_audio(data, size, timestamp, metadata):
    print(f'Webinar audio from {metadata.userName}: {size} bytes')
```

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

### Configure Audio Parameters (JavaScript)

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This JavaScript snippet shows how to configure audio parameters for the RTMS SDK. It demonstrates setting specific audio configurations to match the raw WebSocket defaults, such as codec, sample rate, and channel. This is useful when precise control over audio quality and compatibility with other systems is required.

```javascript
client.setAudioParams({
    contentType: rtms.AudioContentType.RAW_AUDIO,
    codec: rtms.AudioCodec.L16,
    sampleRate: rtms.AudioSampleRate.SR_16K,
    channel: rtms.AudioChannel.MONO,
    dataOpt: rtms.AudioDataOption.AUDIO_MIXED_STREAM,
    duration: 20,
    frameSize: 320  // 16000 * 0.02 * 1
});

client.onAudioData((data, timestamp, metadata) => {
    // Note: AUDIO_MIXED_STREAM does not provide per-speaker metadata
    console.log(`Mixed audio: ${data.length} bytes`);
});
```

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

### Join RTMS Session with Video SDK Payload (Node.js)

Source: https://github.com/zoom/rtms/blob/main/examples/videosdk.md

Demonstrates how to join a real-time media streaming session using the RTMS SDK in Node.js. It listens for the 'session.rtms_started' webhook event and processes incoming audio and video data. This example expects the payload from the Video SDK webhook.

```javascript
import rtms from "@zoom/rtms";

rtms.onWebhookEvent(({event, payload}) => {
    if (event !== "session.rtms_started") return;

    const client = new rtms.Client();

    client.onAudioData((data, timestamp, metadata) => {
        console.log(`Video SDK audio from ${metadata.userName}`);
    });

    client.onVideoData((data, timestamp, metadata) => {
        console.log(`Video SDK video: ${metadata.width}x${metadata.height}`);
    });

    // Video SDK payload contains session_id (not meeting_uuid)
    // The SDK accepts both - just pass the payload directly
    client.join(payload);
});
```

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

### Copy Environment Configuration

Source: https://github.com/zoom/rtms/blob/main/CONTRIBUTING.md

Copies the example environment file to `.env`. This file should then be edited with specific Zoom developer credentials to configure the local build and runtime environment.

```bash
cp .env.example .env
```

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

### Handle Session and Participant Events with RTMS SDK in Node.js

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This Node.js snippet illustrates how to handle various session lifecycle and participant events using the RTMS SDK. It includes callbacks for join confirmation, session updates, participant events, and leaving the meeting.

```javascript
import rtms from "@zoom/rtms";

const client = new rtms.Client();

// Session lifecycle
client.onJoinConfirm((reason) => {
    console.log("Joined meeting:", reason);
});

client.onSessionUpdate((event, session) => {
    console.log(`Session event: ${event}`);
    console.log(`Session ID: ${session.sessionId}`);
    console.log(`Meeting ID: ${session.meetingId}`);
});

// Participant events
client.onParticipantEvent((event, timestamp, participants) => {
    participants.forEach(p => {
        console.log(`User ${event}: ${p.userName} (${p.userId})`);
    });
});

client.onLeave((reason) => {
    console.log("Left meeting:", reason);
});

client.join({
    meeting_uuid: "your_meeting_uuid",
    rtms_stream_id: "your_stream_id",
    server_urls: "wss://rtms.zoom.us"
});
```

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

### Process Video Data with RTMS SDK in Python

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This Python snippet demonstrates how to receive and process video data from a Zoom meeting using the RTMS SDK. It sets up a client, registers a callback for video frames, and joins a meeting. The client continuously polls for updates.

```python
import rtms

client = rtms.Client()

@client.onVideoData
def on_video(data, size, timestamp, metadata):
    print(f'Video frame from {metadata.userName}:')
    print(f'  Size: {size} bytes')
    print(f'  Resolution: {metadata.width}x{metadata.height}')
    print(f'  Format: {metadata.format}')

client.join(
    meeting_uuid='your_meeting_uuid',
    rtms_stream_id='your_stream_id',
    server_urls='wss://rtms.zoom.us'
)

import time
while True:
    client._poll_if_needed()
    time.sleep(0.01)
```

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

### Install Task Build Tool (macOS)

Source: https://github.com/zoom/rtms/blob/main/CONTRIBUTING.md

Installs the Task build orchestration tool on macOS using Homebrew. Task is used for managing build, test, and documentation tasks within the project.

```bash
brew install go-task
```

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

### Build Node.js Prebuilds for Release

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Bash commands to clean the project and build Node.js prebuilds for Darwin (macOS) and Linux. These commands are part of the release workflow.

```bash
task clean
task prebuild:js:darwin  # On macOS
task prebuild:js:linux   # On Linux or Docker
```

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

### Install Zoom RTMS SDK for Node.js and Python

Source: https://context7.com/zoom/rtms/llms.txt

Instructions for installing the Zoom RTMS SDK using npm for Node.js and pip for Python. Ensure you have Node.js version 20.3.0 or higher, or Python version 3.10 or higher.

```bash
# Node.js
npm install @zoom/rtms

# Python
pip install rtms
```

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

### Commit and Push Version Bump

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Git commands to stage, commit, and push the version bump changes to the main branch, initiating the automatic publishing workflow.

```bash
git add pyproject.toml  # or package.json
git commit -m "chore: bump version to X.Y.Z"
git push origin main
```

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

### Tag and Push Node.js Release

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Bash commands to create and push a Git tag for a Node.js release. The tag format is `js-vX.Y.Z`.

```bash
git tag js-vX.Y.Z
git push origin js-vX.Y.Z
```

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

### Build Node.js for Specific Platform

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Builds the Node.js application for a specific target platform. This is part of the publishing workflow and can be executed on macOS, Linux, or for the current platform.

```bash
# On macOS
task build:js:darwin

# On Linux (or using Docker)
task build:js:linux

# Or build for current platform
task build:js
```

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

### Resolve Import Errors After Installation (Python & Node.js)

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Import errors in Python or Node.js after installation can indicate issues with package installation, SDK library bundling, or runtime path configurations. Verify installation, check for bundled libraries, and inspect RPATH settings.

```bash
# Python checks
pip list | grep rtms
python -c "import rtms; print(rtms.__file__)"
ls -la $(python -c "import rtms; print(rtms.__path__[0])")
otool -L /path/to/_rtms.so  # macOS
ldd /path/to/_rtms.so       # Linux
```

```bash
# Node.js checks
npm list @zoom/rtms
ls -la node_modules/@zoom/rtms/build/Release/
npm rebuild @zoom/rtms
```

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

### Contributor - Setup and Build RTMS Bindings

Source: https://github.com/zoom/rtms/blob/main/README.md

Provides commands for contributors to set up and build the RTMS SDK bindings for Node.js and Python. It requires the 'Task' build tool. Commands include verifying the environment, setting up the project, building specific language bindings, and running tests.

```bash
# Verify your environment meets requirements
task doctor

# Setup the project (fetch SDK, install dependencies)
task setup

# Build for your platform
task build:js          # Build Node.js bindings
task build:py          # Build Python bindings

# Run tests
task test:js           # Test Node.js
task test:py           # Test Python

# See all available commands
task --list
```

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

### PyPI Yank (Python Rollback)

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Command to 'yank' a specific version of a Python package from PyPI. This hides the version from default `pip install` commands but allows explicit installation.

```bash
# Yank the release (hides from default pip install)
twine yank rtms 1.0.0 -r pypi --reason "Critical bug - use 1.0.1"

# What this does:
# - pip install rtms will skip 1.0.0
# - Can still install via: pip install rtms==1.0.0 (if explicitly requested)
# - Existing installs keep working
# - Package is NOT deleted, just hidden from default installs
```

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

### Build Node.js and Python SDKs for Various Platforms

Source: https://github.com/zoom/rtms/blob/main/README.md

Builds the Node.js and Python SDKs for the current platform, Linux (via Docker), and macOS. These commands utilize the Task build tool.

```bash
task build:js             # Build Node.js for current platform
task build:js:linux       # Build Node.js for Linux (via Docker)
task build:js:darwin      # Build Node.js for macOS

task build:py             # Build Python for current platform
task build:py:linux       # Build Python wheel for Linux (via Docker)
task build:py:darwin      # Build Python wheel for macOS
```

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

### Task Build Orchestration Commands

Source: https://github.com/zoom/rtms/blob/main/README.md

Provides essential commands for managing the project using Task, including listing all commands, verifying the environment, setting up the project, and building in different modes (Debug/Release) or with debug logging enabled.

```bash
# See all available commands
task --list

# Verify environment
task doctor                   # Check Node, Python, CMake, Docker versions

# Setup project
task setup                    # Fetch SDK and install dependencies

# Build modes
BUILD_TYPE=Debug task build:js    # Build in debug mode
BUILD_TYPE=Release task build:js  # Build in release mode (default)

# Debug logging for C SDK callbacks
RTMS_DEBUG=ON task build:js       # Enable verbose callback logging
```

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

### npm Deprecate (Node.js Rollback)

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Command to mark a specific version of a Node.js package as deprecated on npm. This warns users attempting to install the deprecated version.

```bash
# Mark version as deprecated (users see warning)
npm deprecate @zoom/rtms@1.0.0 "Critical bug - use 1.0.1 instead"

# What this does:
# - npm install @zoom/rtms will skip 1.0.0
# - Users see deprecation warning when installing 1.0.0 specifically
# - Existing installs keep working
# - Package is NOT deleted, just discouraged
```

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

### Local Testing Commands for Node.js, Python, and Docs

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Provides bash commands for running tests and building documentation locally, mirroring the CI/CD environment. This includes Docker commands for Node.js and documentation builds, and pip/pytest for Python testing.

```bash
# Test Node.js (same as CI)
docker compose run --rm test-js

# Test Python (similar to CI)
pip install pytest python-dotenv
pytest tests/test_rtms.py -v

# Build docs (same as CI)
docker compose run --rm docs-js
pip install pdoc3
pdoc --html --output-dir docs/py --force src/rtms
```

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

### Node.js Advanced Webhook Validation

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

Implements custom webhook signature validation for production environments. Handles Zoom's validation challenge and processes the payload if the signature is valid.

```javascript
import rtms from "@zoom/rtms";

rtms.onWebhookEvent((payload, req, res) => {
    // Access request headers for webhook validation
    const signature = req.headers['x-zoom-signature'];

    // Handle Zoom's webhook validation challenge
    if (req.headers['x-zoom-webhook-validator']) {
        const validationToken = req.headers['x-zoom-webhook-validator'];

        // Echo back the validation token
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ plainToken: validationToken }));
        return;
    }

    // Custom validation logic
    if (!validateWebhookSignature(payload, signature)) {
        res.writeHead(401, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'Invalid signature' }));
        return;
    }

    // Process the webhook payload
    if (payload.event === "meeting.rtms_started") {
        const client = new rtms.Client();
        client.onAudioData((data, timestamp, metadata) => {
            console.log(`Received audio from ${metadata.userName}`);
        });
        client.join(payload.payload);
    }

    // Send custom response
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ status: 'ok' }));
});
```

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

### Publish Python Wheels to Production PyPI

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Uploads the finalized Python wheels for the @zoom/rtms package to the production PyPI registry. This makes the package publicly available for installation via pip.

```bash
# Set production PyPI credentials
export TWINE_USERNAME="__token__"
export TWINE_PASSWORD="pypi-your-production-token"

# Upload to production PyPI
task publish:py --platform=darwin
task publish:py --platform=linux

# Or upload all wheels
task publish:py

# Check package is published
pip search rtms

# Test installation
pip install rtms
python -c "import rtms; print(rtms.__version__)"
```

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

### Python Manual Publishing Commands

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Commands for manually publishing Python packages to PyPI using twine. It involves setting environment variables for authentication with a PyPI API token and then using 'twine upload' to distribute the built wheel files.

```bash
export TWINE_USERNAME="__token__"
export TWINE_PASSWORD="pypi-your-api-token-here"
twine upload dist/py/*.whl
```

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

### Node.js Sharing Ports with Existing Servers

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

Integrates RTMS webhook handling into an existing Node.js HTTP server (e.g., Express). Uses `createWebhookHandler` to mount the handler on a specific route.

```javascript
import express from 'express';
import rtms from '@zoom/rtms';

const app = express();
app.use(express.json());

// Your existing application routes
app.get('/health', (req, res) => {
    res.json({ status: 'healthy' });
});

// Create webhook handler
const webhookHandler = rtms.createWebhookHandler(
    (payload) => {
        if (payload.event === "meeting.rtms_started") {
            const client = new rtms.Client();
            client.onAudioData((data, timestamp, metadata) => {
                console.log(`Audio from ${metadata.userName}`);
            });
            client.join(payload.payload);
        }
    },
    '/zoom/webhook'
);

// Mount the webhook handler
app.post('/zoom/webhook', webhookHandler);

// Single port for all routes
const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});
```

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

### Node.js Manual Publishing Commands

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Commands for manually publishing Node.js packages to npm. 'npm login' is used for interactive authentication, and 'npm publish --access public' uploads the package with public visibility. For GitHub prebuilds, a GITHUB_TOKEN environment variable is required.

```bash
npm login
npm publish --access public
export GITHUB_TOKEN="your-github-personal-access-token"
```

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

### Process Transcript Data with RTMS SDK in Node.js

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This Node.js snippet shows how to receive and process transcript data from a Zoom meeting using the RTMS SDK. It initializes a client, sets up a listener for transcript data, and joins the meeting.

```javascript
import rtms from "@zoom/rtms";

const client = new rtms.Client();

client.onTranscriptData((data, timestamp, metadata) => {
    const text = data.toString('utf-8');
    console.log(`[${metadata.userName}]: ${text}`);
});

client.join({
    meeting_uuid: "your_meeting_uuid",
    rtms_stream_id: "your_stream_id",
    server_urls: "wss://rtms.zoom.us"
});
```

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

### Build RTMS SDK using Docker

Source: https://github.com/zoom/rtms/blob/main/README.md

Instructions for building the RTMS SDK using Docker, recommended for cross-platform builds (e.g., macOS to Linux). This process requires Docker, Docker Compose, and the Zoom RTMS C SDK files. It details placing SDK files and running build tasks.

```bash
# Clone the repository
git clone https://github.com/zoom/rtms.git
cd rtms

# Place your SDK library files in the lib/{arch} folder
# For linux-x64:
cp ../librtmsdk.0.2025xxxx/librtmsdk.so.0 lib/linux-x64

# For darwin-arm64 (Apple Silicon):
cp ../librtmsdk.0.2025xxxx/librtmsdk.dylib lib/darwin-arm64

# Place the include files in the proper directory
cp ../librtmsdk.0.2025xxxx/h/* lib/include

# Build using Docker Compose with Task
docker compose run --rm build task build:js    # Build Node.js for linux-x64
docker compose run --rm build task build:py    # Build Python wheel for linux-x64

# Or use convenience services
docker compose run --rm test-js                # Build and test Node.js
docker compose run --rm test-py                # Build and test Python
```

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

### Resolve Documentation Deployment Issues

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

If documentation builds but does not deploy to GitHub Pages, check GitHub Pages settings, workflow permissions, and ensure the 'Deploy Documentation Site' job completes successfully. Propagation to the CDN may take time.

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

### Edit GitHub Release Notes

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Edits the notes of a specified GitHub release. This is useful for adding warnings or updating information without creating a new release. The example adds a warning about critical bugs and suggests using a different version.

```bash
gh release edit js-v1.0.0 --notes "⚠️ **Do not use** - critical bugs. Use v1.0.1 instead."
```

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

### Publish JavaScript N-API Packages (npm)

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Uploads prebuild tarballs for N-API versions 9 and 10 to GitHub releases and subsequently publishes the @zoom/rtms package to the npm registry. This ensures users can install the correct prebuild for their platform and Node.js version.

```bash
# Uploads N-API 9 + 10 for darwin-arm64
task publish:js:darwin

# Uploads N-API 9 + 10 for linux-x64
task publish:js:linux

# Ensure you're logged in
npm whoami

# Or login
npm login

# Publish to npm registry
npm publish

# For scoped packages (if needed)
npm publish --access public

# Check package is published
npm view @zoom/rtms

# Test installation
npm install @zoom/rtms
```

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

### Node.js - RTMS Webhook Integration Example

Source: https://github.com/zoom/rtms/blob/main/README.md

Demonstrates how to integrate with Zoom webhooks using the RTMS SDK for Node.js. It listens for the 'meeting.rtms_started' event, creates an RTMS client, and sets up a listener for audio data. The client then joins the meeting using the provided payload.

```javascript
import rtms from "@zoom/rtms";

// CommonJS
// const rtms = require('@zoom/rtms').default;

rtms.onWebhookEvent(({event, payload}) => {
    if (event !== "meeting.rtms_started") return;

    const client = new rtms.Client();
    
    client.onAudioData((data, timestamp, metadata) => {
        console.log(`Received audio: ${data.length} bytes from ${metadata.userName}`);
    });

    client.join(payload);
});
```

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

### Process Transcript Data with RTMS SDK in Python

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This Python snippet demonstrates how to receive and process transcript data from a Zoom meeting using the RTMS SDK. It initializes a client, defines a callback function for transcript data, and joins the meeting. The client polls for updates in a loop.

```python
import rtms

client = rtms.Client()

@client.onTranscriptData
def on_transcript(data, size, timestamp, metadata):
    text = data.decode('utf-8')
    print(f'[{metadata.userName}]: {text}')

client.join(
    meeting_uuid='your_meeting_uuid',
    rtms_stream_id='your_stream_id',
    server_urls='wss://rtms.zoom.us'
)

import time
while True:
    client._poll_if_needed()
    time.sleep(0.01)
```

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

### Monitor RTMS Session Lifecycle Events

Source: https://context7.com/zoom/rtms/llms.txt

Monitor session state changes, including start, stop, pause, and resume events, using the `onSessionUpdate` callback. This functionality is crucial for tracking the meeting lifecycle and managing associated resources effectively. The examples demonstrate how to handle different session event operations.

```javascript
// Node.js - Session lifecycle monitoring
import rtms from "@zoom/rtms";

const client = new rtms.Client();

client.onSessionUpdate((op, sessionInfo) => {
    switch (op) {
        case rtms.SESSION_EVENT_ADD:
            console.log('Session started');
            break;
        case rtms.SESSION_EVENT_STOP:
            console.log('Session stopped');
            break;
        case rtms.SESSION_EVENT_PAUSE:
            console.log('Session paused');
            break;
        case rtms.SESSION_EVENT_RESUME:
            console.log('Session resumed');
            break;
    }

    console.log(`Session ID: ${sessionInfo.sessionId}`);
    console.log(`Meeting ID: ${sessionInfo.meetingId}`);
    console.log(`Stream ID: ${sessionInfo.streamId}`);
    console.log(`Status: ${sessionInfo.isActive ? 'active' : 'inactive'}`);
});

client.join({
    meeting_uuid: "your_meeting_uuid",
    rtms_stream_id: "your_stream_id",
    server_urls: "wss://rtms.zoom.us"
});
```

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

### Handle Session and Participant Events with RTMS SDK in Python

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This Python snippet shows how to manage session and participant events within a Zoom meeting using the RTMS SDK. It sets up decorators for join confirmation, session updates, participant events, and leave notifications, then joins the meeting and polls for updates.

```python
import rtms

client = rtms.Client()

@client.onJoinConfirm
def on_join(reason):
    print(f'Joined meeting: {reason}')

@client.onSessionUpdate
def on_session(event, session):
    print(f'Session event: {event}')
    print(f'Session ID: {session.sessionId}')
    print(f'Meeting ID: {session.meetingId}')

@client.onParticipantEvent
def on_participant(event, timestamp, participants):
    for p in participants:
        print(f'User {event}: {p.get("user_name")} ({p.get("user_id")})')

@client.onLeave
def on_leave(reason):
    print(f'Left meeting: {reason}')

client.join(
    meeting_uuid='your_meeting_uuid',
    rtms_stream_id='your_stream_id',
    server_urls='wss://rtms.zoom.us'
)

import time
while True:
    client._poll_if_needed()
    time.sleep(0.01)
```

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

### Task Caching Example

Source: https://github.com/zoom/rtms/blob/main/CONTRIBUTING.md

Demonstrates Task's smart caching mechanism. If source files have not changed, a task like `build:js` will be skipped, indicated by the 'is up to date' message. Modifying a source file will trigger a rebuild.

```bash
$ task build:js
# ... builds ...

$ task build:js
task: Task "build:js" is up to date  # Skipped!

$ touch src/rtms.cpp
$ task build:js
# ... rebuilds (detected change) ...
```

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

### Process Audio Streams (Node.js)

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This Node.js code snippet demonstrates how to process incoming audio data from a Zoom RTMS meeting. It sets up a stream to write the raw audio data to a file named 'meeting-audio.raw'. The `onAudioData` event handler logs information about the audio source and writes the received data to the file.

```javascript
import rtms from "@zoom/rtms";
import fs from "fs";

const client = new rtms.Client();
const audioStream = fs.createWriteStream("meeting-audio.raw");

client.onAudioData((data, timestamp, metadata) => {
    console.log(`Audio from ${metadata.userName}: ${data.length} bytes`);
    audioStream.write(data);
});

client.join({
    meeting_uuid: "your_meeting_uuid",
    rtms_stream_id: "your_stream_id",
    server_urls: "wss://rtms.zoom.us"
});
```

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

### Build Zoom RTMS Natively on Linux

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Commands to build Python wheels and Node.js prebuilds natively on a Linux x64 system. Requires GCC 9+ or Clang and SDK files in `lib/linux-x64/`.

```bash
task build:py:linux
task build:js:linux
```

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

### Process Audio Streams (Python)

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This Python snippet shows how to process audio streams from a Zoom RTMS meeting and save them to a file. It opens a file in binary write mode and uses the `onAudioData` decorator to handle incoming audio. The received audio data is then written to the file, and a loop ensures the client continues to poll for data.

```python
import rtms

client = rtms.Client()
audio_file = open('meeting-audio.raw', 'wb')

@client.onAudioData
def on_audio(data, size, timestamp, metadata):
    print(f'Audio from {metadata.userName}: {size} bytes')
    audio_file.write(data)

client.join(
    meeting_uuid='your_meeting_uuid',
    rtms_stream_id='your_stream_id',
    server_urls='wss://rtms.zoom.us'
)

import time
while True:
    client._poll_if_needed()
    time.sleep(0.01)
```

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

### Configure Audio Parameters (Python)

Source: https://github.com/zoom/rtms/blob/main/examples/meetings.md

This Python snippet configures audio parameters for the RTMS SDK to match the raw WebSocket defaults. It specifies settings like content type, codec, sample rate, and channel. This configuration is necessary when you need to align the SDK's audio output with the behavior of the underlying RTMS WebSocket protocol.

```python
# Using SDK defaults (recommended for v1.x)
@client.onAudioData
def on_audio(data, size, timestamp, metadata):
    print(f'Audio from {metadata.userName}')

# Matching WebSocket defaults
client.set_audio_params(
    content_type=rtms.AudioContentType.RAW_AUDIO,
    codec=rtms.AudioCodec.L16,
    sample_rate=rtms.AudioSampleRate.SR_16K,
    channel=rtms.AudioChannel.MONO,
    data_opt=rtms.AudioDataOption.AUDIO_MIXED_STREAM,
    duration=20,
    frame_size=320
)
```

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

### Dry-Run Workflow Configuration (CI/CD)

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

Configuration options for running the 'Publish Packages' workflow in dry-run mode. This allows testing the build and validation steps without actually publishing to npm or PyPI.

```yaml
# Branch: Select `main` or your feature branch
# Language: `node` or `python`
# Version: e.g., `1.0.0`
# Dry run: ✅ **true** (important!)
# Target (Python only): `test` (for TestPyPI)
```

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

### Task Build System Command Structure

Source: https://github.com/zoom/rtms/blob/main/PUBLISHING.md

The Task build system uses a structured command format for orchestrating build, test, and publish actions across different languages and platforms. It supports features like smart caching, parallel execution, and environment validation.

```bash
task <action>:<lang>:<platform>
```
Tokens:
Raw