Meeting Sdk/Linux

Zoom Meeting SDK - Linux Development

Expert guidance for building headless meeting bots with the Zoom Meeting SDK on Linux. This SDK enables server-side meeting participation, raw media capture, transcription, and AI-powered meeting automation.

Current public changelog release: 7.1.0 (verified 2026-07-10). It includes breaking changes plus I420 Limited/Full, breakout-room summaries, face ROI in raw video, and on-demand avatar download. Verify the downloaded headers before using new symbols; existing examples can reflect an older package snapshot.

How to Build a Meeting Bot That Automatically Joins and Records

Use this skill when the requirement is:

• visible bot joins a real Zoom meeting
• the bot records raw media itself
• or the bot triggers a Zoom-managed cloud-recording workflow after join

Skill chain:

• primary: meeting-sdk/linux
• add zoom-rest-api for OBF/ZAK lookup, scheduling, or cloud-recording settings
• add zoom-webhooks when post-meeting cloud recording retrieval is required

Minimal raw-recording flow:

cppCopy code
JoinParam join_param;
join_param.userType = SDK_UT_WITHOUT_LOGIN;
auto& params = join_param.param.withoutloginuserJoin;
params.meetingNumber = meeting_number;
params.userName = "Recording Bot";
params.psw = meeting_password.c_str();
params.app_privilege_token = obf_token.c_str();

SDKError join_err = meeting_service->Join(join_param);
if (join_err != SDKERR_SUCCESS) {
    throw std::runtime_error("join_failed");
}

// In MEETING_STATUS_INMEETING callback:
auto* record_ctrl = meeting_service->GetMeetingRecordingController();
if (!record_ctrl) {
    throw std::runtime_error("recording_controller_unavailable");
}

if (record_ctrl->CanStartRawRecording() != SDKERR_SUCCESS) {
    throw std::runtime_error("raw_recording_not_permitted");
}

SDKError record_err = record_ctrl->StartRawRecording();
if (record_err != SDKERR_SUCCESS) {
    throw std::runtime_error("start_raw_recording_failed");
}

GetAudioRawdataHelper()->subscribe(new MyAudioDelegate());

Use raw recording when the bot must own PCM/YUV media or feed an AI pipeline directly.
Use cloud recording + webhooks when the requirement is Zoom-managed MP4/M4A/transcript assets after the meeting.

Official Documentation: https://developers.zoom.us/docs/meeting-sdk/linux/
API Reference: https://marketplacefront.zoom.us/sdk/meeting/linux/
Sample Repository (Raw Recording): https://github.com/zoom/meetingsdk-linux-raw-recording-sample
Sample Repository (Headless): https://github.com/zoom/meetingsdk-headless-linux-sample

Quick Links

New to Meeting SDK Linux? Follow this path:

1. linux.md - Quick start guide with complete workflow
2. concepts/high-level-scenarios.md - Production bot architectures
3. meeting-sdk-bot.md - Resilient bot with retry logic
4. references/linux-reference.md - Dependencies, Docker, CMake

Common Use Cases:

• Transcription Bot → high-level-scenarios.md#scenario-1-transcription-bot
• Recording Bot → high-level-scenarios.md#scenario-2-recording-bot
• AI Meeting Assistant → high-level-scenarios.md#scenario-3-ai-meeting-assistant
• Quality Monitoring → high-level-scenarios.md#scenario-4-monitoring-quality-bot
• Auto-Join + Recording Bot → meeting-sdk-bot.md for raw recording orchestration, retry, and cloud-recording handoff

Having issues?

• Docker audio issues → references/linux-reference.md#pulseaudio-setup
• Raw recording permission denied → meeting-sdk-bot.md#raw-recording-permission-denied
• Build errors → references/linux-reference.md#troubleshooting

Routing Rule for Bots

If the user asks to build a bot that automatically joins a Zoom meeting and records it, start with meeting-sdk-bot.md.

• Use Meeting SDK Linux for the visible participant, join flow, and raw recording control.
• Chain zoom-rest-api when the bot must fetch OBF/ZAK tokens, schedule meetings, or enable account-side recording settings.
• Chain zoom-webhooks when the requirement is Zoom cloud recording retrieval after meeting end.

SDK Overview

The Zoom Meeting SDK for Linux is a C++ library optimized for headless server environments:

• Headless Operation: No GUI required, perfect for Docker/cloud
• Raw Data Access: YUV420 video, PCM audio at 32kHz
• GLib Event Loop: Async event handling for callbacks
• Docker-Ready: Pre-configured Dockerfiles for CentOS/Ubuntu
• PulseAudio Integration: Virtual audio devices for headless environments

Key Differences from Video SDK

Prerequisites

System Requirements

• OS: Ubuntu 22+, CentOS 8/9, Oracle Linux 8
• Architecture: x86_64
• Compiler: gcc/g++ with C++11 support
• Build Tools: cmake 3.16+

Development Dependencies

bashCopy code
# Ubuntu
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

# CentOS
yum install -y cmake gcc gcc-c++ \
    libxcb-devel xcb-util-image xcb-util-keysyms \
    glib2-devel libcurl-devel pulseaudio

Required Credentials

1. Zoom Meeting SDK App (Client ID & Secret) → Create at Marketplace
2. JWT Token → Generate from Client ID/Secret
3. For External Meetings: OBF token OR ZAK token → Get via REST API
4. For Raw Recording: Meeting Recording Token (optional) → Get via API

Quick Start

1. Download & Extract SDK

bashCopy code
# Download from https://marketplace.zoom.us/
tar xzf zoom-meeting-sdk-linux_x86_64-{version}.tar

# Organize files
mkdir -p demo/include/h demo/lib/zoom_meeting_sdk
cp -r h/* demo/include/h/
cp lib*.so demo/lib/zoom_meeting_sdk/
cp -r qt_libs demo/lib/zoom_meeting_sdk/
cp translation.json demo/lib/zoom_meeting_sdk/json/

# Create required symlink
cd demo/lib/zoom_meeting_sdk && ln -s libmeetingsdk.so libmeetingsdk.so.1

2. Initialize & Auth

cppCopy code
#include "zoom_sdk.h"

USING_ZOOM_SDK_NAMESPACE

// Initialize SDK
InitParam init_params;
init_params.strWebDomain = "https://zoom.us";
init_params.enableLogByDefault = true;
init_params.rawdataOpts.audioRawDataMemoryMode = ZoomSDKRawDataMemoryModeHeap;
InitSDK(init_params);

// Authenticate with JWT
AuthContext auth_ctx;
auth_ctx.jwt_token = your_jwt_token;
CreateAuthService(&auth_service);
auth_service->SDKAuth(auth_ctx);

3. Join Meeting

cppCopy code
// In onAuthenticationReturn callback
void onAuthenticationReturn(AuthResult ret) {
    if (ret == AUTHRET_SUCCESS) {
        JoinParam join_param;
        join_param.userType = SDK_UT_WITHOUT_LOGIN;
        
        auto& params = join_param.param.withoutloginuserJoin;
        params.meetingNumber = 1234567890;
        params.userName = "Bot";
        params.psw = "password";
        params.isVideoOff = true;
        params.isAudioOff = false;
        
        meeting_service->Join(join_param);
    }
}

4. Access Raw Data

cppCopy code
// In onMeetingStatusChanged callback
void onMeetingStatusChanged(MeetingStatus status, int iResult) {
    if (status == MEETING_STATUS_INMEETING) {
        auto* record_ctrl = meeting_service->GetMeetingRecordingController();
        
        // Start raw recording (enables raw data access)
        if (record_ctrl->CanStartRawRecording() == SDKERR_SUCCESS) {
            record_ctrl->StartRawRecording();
            
            // Subscribe to audio
            auto* audio_helper = GetAudioRawdataHelper();
            audio_helper->subscribe(new MyAudioDelegate());
            
            // Subscribe to video
            IZoomSDKRenderer* video_renderer;
            createRenderer(&video_renderer, new MyVideoDelegate());
            video_renderer->setRawDataResolution(ZoomSDKResolution_720P);
            video_renderer->subscribe(user_id, RAW_DATA_TYPE_VIDEO);
        }
    }
}

Key Features

Critical Gotchas & Best Practices

⚠️ CRITICAL: PulseAudio for Docker/Headless

The #1 issue for raw audio in Docker:

Raw audio requires PulseAudio and a config file, even in headless environments.

Solution:

bashCopy code
# Install PulseAudio
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

See: references/linux-reference.md#pulseaudio-setup

Raw Recording Permission Required

Unlike Video SDK, Meeting SDK requires explicit permission to access raw data:

cppCopy code
// MUST call StartRawRecording() first
auto* record_ctrl = meeting_service->GetMeetingRecordingController();

SDKError can_record = record_ctrl->CanStartRawRecording();
if (can_record == SDKERR_SUCCESS) {
    record_ctrl->StartRawRecording();
    // NOW you can subscribe to audio/video
} else {
    // Need: host/co-host status OR recording token
}

Ways to get permission:

1. Bot is host/co-host
2. Host grants recording permission
3. Use recording_token parameter (get via REST API)
4. Use app_privilege_token (OBF) when joining

GLib Main Loop Required

SDK callbacks execute via GLib event loop:

cppCopy code
#include <glib.h>

// Setup main loop
GMainLoop* loop = g_main_loop_new(NULL, FALSE);

// Add timeout for periodic tasks
g_timeout_add_seconds(10, check_meeting_status, NULL);

// Run loop (blocks until quit)
g_main_loop_run(loop);

Without GLib loop: Callbacks never fire, join hangs indefinitely.

Heap Memory Mode Recommended

Always use heap mode for raw data to avoid stack overflow with large frames:

cppCopy code
init_params.rawdataOpts.videoRawDataMemoryMode = ZoomSDKRawDataMemoryModeHeap;
init_params.rawdataOpts.shareRawDataMemoryMode = ZoomSDKRawDataMemoryModeHeap;
init_params.rawdataOpts.audioRawDataMemoryMode = ZoomSDKRawDataMemoryModeHeap;

Thread Safety

SDK callbacks execute on SDK threads:

• Don't perform heavy operations in callbacks
• Don't call CleanUPSDK() from within callbacks
• Use thread-safe queues for data passing
• Use mutexes for shared state

Production Architectures

Transcription Bot

See: concepts/high-level-scenarios.md#scenario-1

Copy code
Join Meeting → StartRawRecording → Subscribe Audio → 
Stream to AssemblyAI/Whisper → Generate Real-time Transcript

Recording Bot

See: concepts/high-level-scenarios.md#scenario-2

Copy code
Join Meeting → StartRawRecording → Subscribe Audio+Video → 
Write YUV+PCM → FFmpeg Merge → Upload to Storage

AI Meeting Assistant

See: concepts/high-level-scenarios.md#scenario-3

Copy code
Join Meeting → Real-time Transcription → AI Analysis → 
Extract Action Items → Generate Summary

Sample Applications

Official Repositories:

What Each Demonstrates:

• Raw Recording Sample: Complete raw data workflow, PulseAudio setup, Docker multi-distro support
• Headless Sample: AssemblyAI integration, Anthropic AI, production-ready config management

Documentation Library

Core Concepts

• linux.md - Quick start & core workflow
• concepts/high-level-scenarios.md - Production bot architectures
• meeting-sdk-bot.md - Resilient bot with retry logic

Platform Reference

• references/linux-reference.md - Dependencies, CMake, Docker, troubleshooting

Authentication

• ../references/authorization.md - SDK JWT generation
• ../references/bot-authentication.md - Bot token types (ZAK, OBF, JWT)

Advanced Features

• ../references/breakout-rooms.md - Programmatic breakout rooms
• ../references/ai-companion.md - AI Companion controls

Common Issues

Complete troubleshooting: references/linux-reference.md#troubleshooting

Resources

• Official Docs: https://developers.zoom.us/docs/meeting-sdk/linux/
• API Reference: https://marketplacefront.zoom.us/sdk/meeting/linux/
• Dev Forum: https://devforum.zoom.us/
• GitHub Samples:
  • https://github.com/zoom/meetingsdk-linux-raw-recording-sample
  • https://github.com/zoom/meetingsdk-headless-linux-sample

Need help? Start with linux.md for quick start, then explore high-level-scenarios.md for production patterns.

Operations

• RUNBOOK.md - 5-minute preflight and debugging checklist.