From the team

Developer Blog

Product announcements, technical deep dives, and behind-the-scenes looks at what we are building for the Zoom Developer platform.


RTMS

Level Up: What RTMS V2 Unlocks for Developers

Rehema Armorer3 min read
  • announcement
  • release
  • RTMS

Summary:Learn about the new RTMS version 2 and how to upgrade.

Since RTMS launched last June, developers have used it to bring live meeting and call content to hundreds of thousands of users . Today, the Zoom Developers team is excited to introduce RTMS v2, the next step in that journey. It adds new options for security, streaming, and control, for an improved building experience. Read on to see what v2 has to offer, what it means for you, and how to upgrade.

RTMS v2: Build your way

Here's what the new version of RTMS offers at a glance:

  • Your data, locked down: Optional payload encryption keeps sensitive call and meeting content protected in transit.
  • Stream with confidence, anywhere: SRT is now available as a transport option, so media delivery stays stable across a wide range of network conditions.
  • Less overhead, more throughput: A more efficient message format lets your integration exchange data faster and with fewer resources.
  • Per-user video, on your terms: Subscribe to individual participant video streams and choose exactly whose video your integration captures.
  • Easier debugging: Granular error signals and globally unique event codes help you find and fix issues faster.

Together, these give you more control, stronger security options, and a more customizable integration. Here's how each one works:

  • Optional application-layer payload encryption: Clients can offer payload_encryptions in the signaling handshake. Once encryption is negotiated, the response returns wrapped key information, the data handshake sets the payload_encrypted flag, and media and text payloads arrive in encrypted envelopes. Use media_payload_key_mode to choose per-media derived keys (the default) or a direct master key.
  • SRT media URLs: Clients can select a srt:// URL from media_server.server_urls. The handshake response includes srt_passphrase and srt_pbkey_length. In JSON, the passphrase is Base64-encoded. In protobuf, it's sent as raw bytes.
  • Protobuf wire format: Signaling, data handshake, and supported control and media messages can use a protobuf schema instead of JSON. You can also omit individual media parameter fields to fall back to server defaults, which reduces payload size and parsing work on every exchange between your app and Zoom.
  • Multiple individual video subscriptions: Set data_opt: 6 in the media parameters of your media server handshake request to open separate video connections and subscribe by user_id. This applies to products that currently offer the video media type.
  • Globally unique event_code identifiers and expanded events: Event codes now cover Meetings (participant, sharing, video, and chat group events), Contact Center Voice, and Zoom Phone, so you can pinpoint exactly which event fired.

Upgrading from v1 to v2

Moving your application from v1 to v2 takes a few key changes. Make them up front to avoid errors and keep the upgrade smooth. The examples below use Node.js.

  1. Opt in to v2. V2 is opt-in. Send protocol_version: 2 in your signaling handshake and in each data handshake request.

  2. Update how you read server URLs. In v2, server_urls in the signaling handshake response can return two URLs in one comma-separated string. Split the value and pick the one you need (WSS or SRT):

const pickWssUrl = (urls) => String(urls || '').split(',').map(u => u.trim()).find(u => u.startsWith('wss://'));
const wssUrl = pickWssUrl(message.media_server.server_urls);
  1. Open one WebSocket connection per media type. V1 let you receive all streams over a single aggregate data connection. V2 requires a separate data connection for each media type you want to receive. media_type: 32 (ALL) isn't supported in v2 and returns an error. Here's an abbreviated, reusable connection function:
const WebSocket = require('ws');

function connectToMediaWebSocket(mediaUrl, mediaType) {
 const media = new WebSocket(mediaUrl);
 media.on('open', () => {
 media.send(JSON.stringify({
 msg_type: 3, // DATA_HAND_SHAKE_REQ
 protocol_version: 2, // must use 2
 media_type: mediaType,
 ...(mediaType === 1
 ? { media_params: { audio: { send_rate: AUDIO_SEND_RATE_MS } } }
 : {})
 }));
 });
 return media;
}

// Invoke with a specific URL and media type
connectToMediaWebSocket(wssUrl, 1); // AUDIO
  1. Use event_code instead of event_type. Use event_code both when subscribing to events in your server connection configuration and when reading incoming event payloads:
// Subscribing to the MEETING_ACTIVE_SPEAKER_CHANGE event (code 1000)
{
 "msg_type": 5,
 "events": [{ "event_code": 1000, "subscribe": true }]
}
// Returned payload for event 1001, MEETING_PARTICIPANT_JOIN
{
 "msg_type": 6,
 "event": {
 "event_code": 1001,
 "participants": [{ "user_id": 12345, "user_name": "Ada" }],
 "timestamp": 1735689600000
 }
}

Conclusion

RTMS v2 doesn't replace what you've built. It expands what you can build. Every new capability is your choice: opt into encryption, use protobuf or JSON, stream over SRT or WebSocket, and subscribe to one video feed or many. The result is a modular, configurable integration that fits your use case. Head to our docs to learn more and start building today!