Skill v1.0.0
currentTrusted Publisher100/100name: zoom-meeting-sdk-windows description: | Zoom Meeting SDK for Windows - Native C++ SDK for embedding Zoom meetings into Windows desktop applications. Supports custom UI architecture with raw video/audio data, headless bots, and deep integration with meeting features. Includes SDK architecture patterns and Windows message loop handling. user-invocable: false triggers:
- "meeting sdk windows"
- "windows meeting sdk"
- "windows meeting bot"
- "c++ meeting sdk windows"
- "custom ui meeting windows"
Zoom Meeting SDK (Windows)
Embed Zoom meeting capabilities into Windows desktop applications for native C++ integrations and headless bots.
New to Zoom SDK? Start Here!
The fastest way to master the SDK:
- [SDK Architecture Pattern](concepts/sdk-architecture-pattern.md) - Learn the universal pattern that works for ALL 35+ features
- [Authentication Pattern](examples/authentication-pattern.md) - Get a working bot joining meetings
- [Windows Message Loop](troubleshooting/windows-message-loop.md) - Fix the #1 reason callbacks don't fire
Building a Custom UI?
- Custom UI Architecture - How SDK rendering actually works (child HWNDs, D3D, etc.)
- Custom UI Video Rendering Example - Complete working code
- SDK-Rendered vs Self-Rendered - Choose the right approach
- Custom UI Interface Methods - All 13 required virtual methods
Having issues?
- Build errors → Build Errors Guide
- Callbacks not firing → Windows Message Loop
- Quick diagnostics → Common Issues
- Performance / service quality → service-quality.md
- Deployment notes → deployment.md
- MSBuild from git bash → Build Errors Guide
- Complete navigation → SKILL.md
Prerequisites
- Zoom app with Meeting SDK credentials (Client ID & Secret)
- Visual Studio 2019/2022 or later
- Windows 10 or later
- C++ development environment
- vcpkg for dependency management
Need help with authentication? See the [zoom-oauth](../../oauth/SKILL.md) skill for JWT token generation.
Project Preferences & Learnings
IMPORTANT: These are hard-won preferences from real project experience. Follow these when creating new projects.
Do NOT use CMake — Use native Visual Studio .vcxproj
Always create a native Visual Studio `.sln` + `.vcxproj` project, not a CMake project. Reasons:
- More standard and familiar for Windows C++ developers
- Developers can double-click the
.slnto open in Visual Studio immediately - Project settings (include dirs, lib dirs, preprocessor defines) are easier to see and edit in the VS Property Pages UI
- No extra CMake tooling or configuration step required
- Friendlier and easier for developers to understand and maintain
config.json must be visible in Solution Explorer
The config.json file (containing sdk_jwt, meeting_number, passcode) must be:
- Included in the `.vcxproj` as a
<None>item with<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> - Placed in a "Config" filter in the
.vcxproj.filtersfile so it appears under a "Config" folder in Solution Explorer - Easily editable by developers directly from Solution Explorer — they should never have to hunt for it in File Explorer
Example .vcxproj entry:
<ItemGroup><None Include="config.json"><CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory></None></ItemGroup>
Example .vcxproj.filters entry:
<ItemGroup><Filter Include="Config"><UniqueIdentifier>{GUID-HERE}</UniqueIdentifier></Filter></ItemGroup><ItemGroup><None Include="config.json"><Filter>Config</Filter></None></ItemGroup>
Overview
The Windows SDK is a C++ native SDK designed for:
- Desktop applications - Native Windows apps with full UI control
- Headless bots - Join meetings without UI
- Raw media access - Capture/send audio/video streams
- Local recording - Record meetings locally or to cloud
Key Architectural Insight
The SDK follows a universal 3-step pattern for every feature:
- Get controller (singleton):
meetingService->Get[Feature]Controller() - Implement event listener:
class MyListener : public I[Feature]Event { ... } - Register and use:
controller->SetEvent(listener)then call methods
This works for ALL features: audio, video, chat, recording, participants, screen sharing, breakout rooms, webinars, Q&A, polling, whiteboard, and 20+ more!
Learn more: [SDK Architecture Pattern Guide](concepts/sdk-architecture-pattern.md)
Quick Start
1. Download Windows SDK
Download from Zoom Marketplace:
- Extract
zoom-meeting-sdk-windows_x86_64-{version}.zip
2. Setup Project Structure
your-project/YourApp/SDK/x64/bin/ # DLL files and dependenciesh/ # Header fileslib/ # sdk.libx86/bin/h/lib/YourApp.cppYourApp.vcxprojconfig.json
Copy SDK files:
xcopy /E /I sdk-package\x64 your-project\YourApp\SDK\x64\xcopy /E /I sdk-package\x86 your-project\YourApp\SDK\x86\
3. Install Dependencies (vcpkg)
# Install vcpkggit clone https://github.com/Microsoft/vcpkg.git C:\vcpkgcd C:\vcpkg.\bootstrap-vcpkg.bat.\vcpkg integrate install# Install dependencies.\vcpkg install jsoncpp:x64-windows.\vcpkg install curl:x64-windows
4. Configure Visual Studio Project
Project Properties → C/C++ → General → Additional Include Directories:
$(SolutionDir)SDK\$(PlatformTarget)\hC:\vcpkg\packages\jsoncpp_x64-windows\includeC:\vcpkg\packages\curl_x64-windows\include
Project Properties → Linker → General → Additional Library Directories:
$(SolutionDir)SDK\$(PlatformTarget)\lib
Project Properties → Linker → Input → Additional Dependencies:
sdk.lib
Post-Build Event (Copy DLLs to output):
xcopy /Y /D "$(SolutionDir)SDK\$(PlatformTarget)\bin\*.*" "$(OutDir)"
5. Configure Credentials
Create config.json:
{"sdk_jwt": "YOUR_JWT_TOKEN","meeting_number": "1234567890","passcode": "password123","zak": ""}
6. Build & Run
- Open solution in Visual Studio
- Select x64 or x86 configuration
- Press F5 to build and run
Core Workflow
┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐│ InitSDK │───►│ AuthSDK │───►│ JoinMeeting │───►│ Raw Data ││ │ │ (JWT) │ │ │ │ Subscribe │└─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘│ │▼ ▼OnAuthComplete onInMeetingcallback callback
⚠️ CRITICAL: Add Windows message loop or callbacks won't fire!
while (!done) {MSG msg;while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {TranslateMessage(&msg);DispatchMessage(&msg);}std::this_thread::sleep_for(std::chrono::milliseconds(100));}
See: Windows Message Loop Guide
Code Examples
💡 Pro Tip: These are minimal examples. For complete, tested code see:- Authentication Pattern - Full auth workflow- Raw Video Capture - Complete video capture- SDK Architecture Pattern - Implement any feature
Important: Include Order
CRITICAL: Include headers in this exact order or you'll get build errors:
#include <windows.h> // MUST be first#include <cstdint> // MUST be second (SDK headers use uint32_t)// ... other standard headers ...#include <zoom_sdk.h>#include <meeting_service_components/meeting_audio_interface.h> // BEFORE participants!#include <meeting_service_components/meeting_participants_ctrl_interface.h>
See: Build Errors Guide for all dependency fixes.
1. Initialize SDK
#include <windows.h>#include <cstdint>#include <zoom_sdk.h>using namespace ZOOM_SDK_NAMESPACE;bool InitMeetingSDK() {InitParam initParam;initParam.strWebDomain = L"https://zoom.us";initParam.strSupportUrl = L"https://zoom.us";initParam.emLanguageID = LANGUAGE_English;initParam.enableLogByDefault = true;initParam.enableGenerateDump = true;SDKError err = InitSDK(initParam);if (err != SDKERR_SUCCESS) {std::wcout << L"InitSDK failed: " << err << std::endl;return false;}return true;}
2. Authenticate with JWT
#include <windows.h>#include <cstdint>#include <auth_service_interface.h>#include "AuthServiceEventListener.h"IAuthService* authService = nullptr;void OnAuthenticationComplete() {std::cout << "Authentication successful!" << std::endl;JoinMeeting(); // Proceed to join meeting}bool AuthenticateSDK(const std::wstring& jwtToken) {CreateAuthService(&authService);if (!authService) return false;// Set event listener BEFORE calling SDKAuthauthService->SetEvent(new AuthServiceEventListener(&OnAuthenticationComplete));// Authenticate with JWTAuthContext authContext;authContext.jwt_token = jwtToken.c_str();SDKError err = authService->SDKAuth(authContext);if (err != SDKERR_SUCCESS) {std::wcout << L"SDKAuth failed: " << err << std::endl;return false;}// CRITICAL: Add message loop or callback won't fire!// See complete example: examples/authentication-pattern.mdreturn true;}
AuthServiceEventListener.h:
#include <windows.h>#include <cstdint>#include <auth_service_interface.h>#include <iostream>using namespace ZOOM_SDK_NAMESPACE;class AuthServiceEventListener : public IAuthServiceEvent {public:AuthServiceEventListener(void (*onComplete)()): onAuthComplete(onComplete) {}void onAuthenticationReturn(AuthResult ret) override {if (ret == AUTHRET_SUCCESS && onAuthComplete) {onAuthComplete();} else {std::cout << "Auth failed: " << ret << std::endl;}}// Must implement ALL pure virtual methods (6 total)void onLoginReturnWithReason(LOGINSTATUS ret, IAccountInfo* info, LoginFailReason reason) override {}void onLogout() override {}void onZoomIdentityExpired() override {}void onZoomAuthIdentityExpired() override {}#if defined(WIN32)void onNotificationServiceStatus(SDKNotificationServiceStatus status, SDKNotificationServiceError error) override {}#endifprivate:void (*onAuthComplete)();};
See complete working code: Authentication Pattern Guide
3. Join Meeting
#include <meeting_service_interface.h>#include "MeetingServiceEventListener.h"IMeetingService* meetingService = nullptr;void OnMeetingJoined() {std::cout << "Joining meeting..." << std::endl;}void OnInMeeting() {std::cout << "In meeting now!" << std::endl;// Start raw data capture here}void OnMeetingEnds() {std::cout << "Meeting ended" << std::endl;}bool JoinMeeting(UINT64 meetingNumber, const std::wstring& password) {CreateMeetingService(&meetingService);if (!meetingService) return false;// Set event listenermeetingService->SetEvent(new MeetingServiceEventListener(&OnMeetingJoined, &OnMeetingEnds, &OnInMeeting));// Prepare join parametersJoinParam joinParam;joinParam.userType = SDK_UT_WITHOUT_LOGIN;JoinParam4WithoutLogin& params = joinParam.param.withoutloginuserJoin;params.meetingNumber = meetingNumber;params.userName = L"Bot User";params.psw = password.c_str();params.isVideoOff = false;params.isAudioOff = false;SDKError err = meetingService->Join(joinParam);if (err != SDKERR_SUCCESS) {std::wcout << L"Join failed: " << err << std::endl;return false;}return true;}
MeetingServiceEventListener.h:
#include <windows.h>#include <cstdint>#include <meeting_service_interface.h>#include <iostream>using namespace ZOOM_SDK_NAMESPACE;class MeetingServiceEventListener : public IMeetingServiceEvent {public:MeetingServiceEventListener(void (*onJoined)(),void (*onEnded)(),void (*onInMeeting)()) : onMeetingJoined(onJoined),onMeetingEnded(onEnded),onInMeetingCallback(onInMeeting) {}void onMeetingStatusChanged(MeetingStatus status, int iResult) override {if (status == MEETING_STATUS_CONNECTING) {if (onMeetingJoined) onMeetingJoined();}else if (status == MEETING_STATUS_INMEETING) {if (onInMeetingCallback) onInMeetingCallback();}else if (status == MEETING_STATUS_ENDED) {if (onMeetingEnded) onMeetingEnded();}}// Must implement ALL pure virtual methods (9 total)void onMeetingStatisticsWarningNotification(StatisticsWarningType type) override {}void onMeetingParameterNotification(const MeetingParameter* param) override {}void onSuspendParticipantsActivities() override {}void onAICompanionActiveChangeNotice(bool isActive) override {}void onMeetingTopicChanged(const zchar_t* sTopic) override {}void onMeetingFullToWatchLiveStream(const zchar_t* sLiveStreamUrl) override {}void onUserNetworkStatusChanged(MeetingComponentType type, ConnectionQuality level, unsigned int userId, bool uplink) override {}#if defined(WIN32)void onAppSignalPanelUpdated(IMeetingAppSignalHandler* pHandler) override {}#endifprivate:void (*onMeetingJoined)();void (*onMeetingEnded)();void (*onInMeetingCallback)();};
See all required methods: Interface Methods Guide
4. Subscribe to Raw Video
#include <windows.h>#include <cstdint>#include <rawdata/zoom_rawdata_api.h>#include <rawdata/rawdata_renderer_interface.h>#include <zoom_sdk_raw_data_def.h> // REQUIRED for YUVRawDataI420#include "ZoomSDKRendererDelegate.h"IZoomSDKRenderer* videoHelper = nullptr;ZoomSDKRendererDelegate* videoSource = new ZoomSDKRendererDelegate();bool StartVideoCapture(uint32_t userId) {// STEP 1: Start raw recording FIRST (required!)IMeetingRecordingController* recordCtrl =meetingService->GetMeetingRecordingController();SDKError canStart = recordCtrl->CanStartRawRecording();if (canStart != SDKERR_SUCCESS) {std::cout << "Cannot start recording: " << canStart << std::endl;return false;}recordCtrl->StartRawRecording();// Wait for recording to initializestd::this_thread::sleep_for(std::chrono::milliseconds(500));// STEP 2: Create rendererSDKError err = createRenderer(&videoHelper, videoSource);if (err != SDKERR_SUCCESS || !videoHelper) {std::cout << "createRenderer failed: " << err << std::endl;return false;}// STEP 3: Set resolution and subscribevideoHelper->setRawDataResolution(ZoomSDKResolution_720P);err = videoHelper->subscribe(userId, RAW_DATA_TYPE_VIDEO);if (err != SDKERR_SUCCESS) {std::cout << "Subscribe failed: " << err << std::endl;return false;}std::cout << "Video capture started! Frames arrive in onRawDataFrameReceived()" << std::endl;return true;}
ZoomSDKRendererDelegate.h:
#include <windows.h>#include <cstdint>#include <rawdata/rawdata_renderer_interface.h>#include <zoom_sdk_raw_data_def.h>#include <fstream>#include <iostream>using namespace ZOOM_SDK_NAMESPACE;class ZoomSDKRendererDelegate : public IZoomSDKRendererDelegate {public:void onRawDataFrameReceived(YUVRawDataI420* data) override {if (!data) return;// YUV420 (I420) format: Y plane + U plane + V planeint width = data->GetStreamWidth();int height = data->GetStreamHeight();// Calculate buffer sizes// Y = full resolution, U/V = quarter resolution eachsize_t ySize = width * height;size_t uvSize = ySize / 4; // (width/2) * (height/2)// Total size: width * height * 1.5 bytes// Save to file (playback: ffplay -f rawvideo -pixel_format yuv420p -video_size 1280x720 output.yuv)std::ofstream outputFile("output.yuv", std::ios::binary | std::ios::app);outputFile.write(data->GetYBuffer(), ySize); // BrightnessoutputFile.write(data->GetUBuffer(), uvSize); // Blue-differenceoutputFile.write(data->GetVBuffer(), uvSize); // Red-differenceoutputFile.close();}void onRawDataStatusChanged(RawDataStatus status) override {std::cout << "Raw data status: " << status << std::endl;}void onRendererBeDestroyed() override {std::cout << "Renderer destroyed" << std::endl;}};
Complete video capture guide: Raw Video Capture Guide
5. Subscribe to Raw Audio
#include <rawdata/rawdata_audio_helper_interface.h>class ZoomSDKAudioRawDataDelegate : public IZoomSDKAudioRawDataDelegate {public:void onMixedAudioRawDataReceived(AudioRawData* data) override {// Process PCM audio (mixed from all participants)std::ofstream pcmFile("audio.pcm", std::ios::binary | std::ios::app);pcmFile.write((char*)data->GetBuffer(), data->GetBufferLen());pcmFile.close();}void onOneWayAudioRawDataReceived(AudioRawData* data, uint32_t node_id) override {// Process audio from specific participant}};// Subscribe to audioIZoomSDKAudioRawDataHelper* audioHelper = GetAudioRawdataHelper();audioHelper->subscribe(new ZoomSDKAudioRawDataDelegate());
6. Main Message Loop (CRITICAL!)
⚠️ WITHOUT THIS, CALLBACKS WON'T FIRE!
#include <windows.h>#include <thread>#include <chrono>int main() {// Initialize COMCoInitialize(NULL);// Load config and initializeLoadConfig();InitMeetingSDK();AuthenticateSDK(sdk_jwt);// CRITICAL: Windows message loop for SDK callbacks// SDK uses Windows message pump to dispatch callbacks// Without this, callbacks are queued but NEVER fire!MSG msg;while (!g_exit) {// Process all pending Windows messageswhile (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {if (msg.message == WM_QUIT) {g_exit = true;break;}TranslateMessage(&msg);DispatchMessage(&msg);}// Small sleep to avoid busy-waitingstd::this_thread::sleep_for(std::chrono::milliseconds(100));}// CleanupCleanSDK();CoUninitialize();return 0;}
Why message loop is critical: The SDK uses Windows COM/messaging for async callbacks. Without PeekMessage(), the SDK queues messages but they're never retrieved/dispatched, so callbacks never execute.
Symptoms without message loop:
- Authentication timeout (even with valid JWT)
- Meeting join timeout
- No callback events fire
- Appears like network/auth issue but it's a message loop issue
See detailed explanation: Windows Message Loop Guide
Common Issues & Solutions
| Issue | Solution | |
|---|---|---|
| Callbacks don't fire / Auth timeout | Add Windows message loop → Guide | |
| `uint32_t` / `AudioType` errors | Fix include order → Guide | |
| Abstract class error | Implement all virtual methods → Guide | |
| How to implement [feature]? | Follow universal pattern → Guide | |
| Authentication fails | Check JWT token & error codes → Guide | |
| No video frames received | Call StartRawRecording() first → Guide |
Complete troubleshooting: Common Issues Guide
How to Implement Any Feature
The SDK has 35+ feature controllers (audio, video, chat, recording, participants, screen sharing, breakout rooms, webinars, Q&A, polling, whiteboard, captions, AI companion, etc.).
Universal pattern that works for ALL features:
- Get the controller (singleton):
``cpp IMeetingAudioController* audioCtrl = meetingService->GetMeetingAudioController(); IMeetingChatController* chatCtrl = meetingService->GetMeetingChatController(); // ... 33 more controllers available ``
- Implement event listener (observer pattern):
``cpp class MyAudioListener : public IMeetingAudioCtrlEvent { void onUserAudioStatusChange(IList<IUserAudioStatus*>* lst) override { // React to audio events } // ... implement all required methods }; ``
- Register and use:
``cpp audioCtrl->SetEvent(new MyAudioListener()); audioCtrl->MuteAudio(userId, true); // Use feature ``
Complete guide with examples: SDK Architecture Pattern
Available Examples
| Example | Description | |
|---|---|---|
| SkeletonDemo | Minimal join meeting - start here | |
| GetVideoRawData | Subscribe to raw video streams | |
| GetAudioRawData | Subscribe to raw audio streams | |
| SendVideoRawData | Send custom video as virtual camera | |
| SendAudioRawData | Send custom audio as virtual mic | |
| GetShareRawData | Capture screen share content | |
| LocalRecording | Local MP4 recording | |
| ChatDemo | In-meeting chat functionality | |
| CaptionDemo | Closed caption/live transcription | |
| BreakoutDemo | Breakout room management |
Detailed References
🎯 Core Concepts (START HERE!)
- [concepts/sdk-architecture-pattern.md](concepts/sdk-architecture-pattern.md) - Universal pattern for implementing ANY feature - Understanding this unlocks the entire SDK!
📚 Complete Examples
- [examples/authentication-pattern.md](examples/authentication-pattern.md) - Complete working authentication with JWT tokens
- [examples/raw-video-capture.md](examples/raw-video-capture.md) - YUV420 video capture with detailed format explanation
🔧 Troubleshooting Guides
- [troubleshooting/windows-message-loop.md](troubleshooting/windows-message-loop.md) - Why callbacks don't fire (MOST CRITICAL!)
- [troubleshooting/build-errors.md](troubleshooting/build-errors.md) - SDK header dependency issues and fixes
- [troubleshooting/common-issues.md](troubleshooting/common-issues.md) - Quick diagnostic workflow and error code tables
📖 References
- [references/interface-methods.md](references/interface-methods.md) - How to implement ALL required virtual methods
- [references/windows-reference.md](references/windows-reference.md) - Dependencies, Visual Studio setup
- [../references/authorization.md](../references/authorization.md) - SDK JWT generation
- [../references/bot-authentication.md](../references/bot-authentication.md) - Bot token types (ZAK, OBF, JWT)
🎨 Feature-Specific Guides
- [../references/breakout-rooms.md](../references/breakout-rooms.md) - Programmatic breakout room management
- [../references/ai-companion.md](../references/ai-companion.md) - AI Companion controls
Sample Repositories
| Repository | Description | |
|---|---|---|
| meetingsdk-windows-raw-recording-sample | Official raw data capture samples | |
| meetingsdk-windows-local-recording-sample | Local recording with Docker |
Playing Raw Video/Audio Files
Raw YUV/PCM files have no headers - you must specify format explicitly.
Play Raw YUV Video
ffplay -video_size 1280x720 -pixel_format yuv420p -f rawvideo output.yuv
Convert YUV to MP4
ffmpeg -video_size 1280x720 -pixel_format yuv420p -f rawvideo -i output.yuv -c:v libx264 output.mp4
Play Raw PCM Audio
ffplay -f s16le -ar 32000 -ac 1 audio.pcm
Convert PCM to WAV
ffmpeg -f s16le -ar 32000 -ac 1 -i audio.pcm output.wav
Combine Video + Audio
ffmpeg -video_size 1280x720 -pixel_format yuv420p -f rawvideo -i output.yuv ^-f s16le -ar 32000 -ac 1 -i audio.pcm ^-c:v libx264 -c:a aac -shortest output.mp4
Key flags:
| Flag | Description | |
|---|---|---|
-video_size WxH | Frame dimensions (e.g., 1280x720) | |
-pixel_format yuv420p | I420/YUV420 planar format | |
-f rawvideo | Raw video input (no container) | |
-f s16le | Signed 16-bit little-endian PCM | |
-ar 32000 | Sample rate (Zoom uses 32kHz) | |
-ac 1 | Mono (use -ac 2 for stereo) |
Authentication Requirements (2026 Update)
Important: Beginning March 2, 2026, apps joining meetings outside their account must be authorized.
Use one of:
- App Privilege Token (OBF) - Recommended for bots (
app_privilege_tokenin JoinParam) - ZAK Token - Zoom Access Key (
userZAKin JoinParam) - On Behalf Token - For specific use cases (
onBehalfTokenin JoinParam)
📖 Complete Documentation Library
This skill includes comprehensive guides created from real-world debugging:
🎯 Start Here
- [SDK Architecture Pattern](concepts/sdk-architecture-pattern.md) - Master document: Universal pattern for ANY feature
- [SKILL.md](SKILL.md) - Complete navigation guide
📚 By Category
Core Concepts:
- SDK Architecture Pattern - How every feature works (singleton + observer pattern)
Complete Examples:
- Authentication Pattern - Working JWT auth with all code
- Raw Video Capture - YUV420 video capture explained
Troubleshooting:
- Windows Message Loop - CRITICAL: Why callbacks don't fire
- Build Errors - SDK header dependency fixes
- Common Issues - Quick diagnostics & error codes
References:
- Interface Methods - All required virtual methods (6 auth + 9 meeting)
- Windows Reference - Platform setup
- Authorization - JWT generation
- Bot Authentication - Bot token types
- Breakout Rooms - Breakout room API
- AI Companion - AI features
🚨 Most Critical Issues (From Real Debugging)
- Callbacks not firing → Missing Windows message loop (99% of issues)
- Build errors → SDK header dependencies (
uint32_t,AudioType, etc.)
- See: Build Errors Guide
- Abstract class errors → Missing virtual method implementations
💡 Key Insight
Once you learn the 3-step pattern, you can implement ANY of the 35+ features:
- Get controller → 2. Implement event listener → 3. Register and use
Official Resources
- Official docs: https://developers.zoom.us/docs/meeting-sdk/windows/
- API Reference: https://marketplacefront.zoom.us/sdk/meeting/windows/annotated.html
- Developer forum: https://devforum.zoom.us/
- SDK download: https://marketplace.zoom.us/
Documentation Version: Based on Zoom Windows Meeting SDK v6.7.2.26830
Need help? Start with SKILL.md for complete navigation.
Merged from meeting-sdk/windows/SKILL.md
Zoom Windows Meeting SDK - Complete Documentation Index
🚀 Quick Start Path
If you're new to the SDK, follow this order:
- Read the architecture pattern → concepts/sdk-architecture-pattern.md
- This teaches you the universal formula that applies to ALL features
- Once you understand this, you can implement any feature by reading the
.hfiles
- Fix build errors → troubleshooting/build-errors.md
- SDK header dependencies issues
- Required include order
- Implement authentication → examples/authentication-pattern.md
- Complete working JWT authentication code
- Fix callback issues → troubleshooting/windows-message-loop.md
- CRITICAL: Why callbacks don't fire without Windows message loop
- This was the hardest issue to diagnose!
- Implement virtual methods → references/interface-methods.md
- Complete lists of all required methods
- How to avoid abstract class errors
- Capture video (optional) → examples/raw-video-capture.md
- YUV420 format explained
- Complete raw data capture workflow
- Troubleshoot any issues → troubleshooting/common-issues.md
- Quick diagnostic checklist
- Error code tables
- "If you see X, do Y" reference
📂 Documentation Structure
meeting-sdk/windows/├── SKILL.md # Main skill overview├── SKILL.md # This file - navigation guide│├── concepts/ # Core architectural patterns│ ├── sdk-architecture-pattern.md # THE MOST IMPORTANT DOC│ │ # Universal formula for ANY feature│ ├── singleton-hierarchy.md # Navigation guide for SDK services│ │ # 4-level deep service tree, when/how│ ├── custom-ui-architecture.md # How Custom UI rendering works│ │ # Child HWNDs, D3D, layout, events│ └── custom-ui-vs-raw-data.md # SDK-rendered vs self-rendered│ # Decision guide for Custom UI approach│├── examples/ # Complete working code│ ├── authentication-pattern.md # JWT auth with full code│ ├── raw-video-capture.md # Video capture with YUV420 details│ │ # Recording vs Streaming, permissions│ ├── custom-ui-video-rendering.md # Custom UI with video container│ │ # Active speaker + gallery layout│ ├── breakout-rooms.md # Complete breakout room guide│ │ # 5 roles, create/manage/join│ ├── chat.md # Send/receive chat messages│ │ # Rich text, threading, file transfer│ ├── captions-transcription.md # Live transcription & closed captions│ │ # Multi-language translation│ ├── local-recording.md # Local MP4 recording│ │ # Permission flow, encoder monitoring│ ├── share-raw-data-capture.md # Screen share raw data capture│ │ # YUV420 frames from shared content│ └── send-raw-data.md # Virtual camera/mic/share│ # Send custom video/audio/share│├── troubleshooting/ # Problem solving guides│ ├── windows-message-loop.md # CRITICAL - Why callbacks fail│ ├── build-errors.md # Header dependency fixes + MSBuild│ └── common-issues.md # Quick diagnostic workflow│└── references/ # Reference documentation├── interface-methods.md # Required virtual methods│ # Auth(6) + Meeting(9) + CustomUI(13)├── windows-reference.md # Platform setup├── authorization.md # JWT generation├── bot-authentication.md # Bot token types├── breakout-rooms.md # Breakout room features└── ai-companion.md # AI Companion features
🎯 By Use Case
I want to build a meeting bot
- SDK Architecture Pattern - Understand the pattern
- Authentication Pattern - Join meetings
- Windows Message Loop - Fix callback issues
- Interface Methods - Implement callbacks
I'm getting build errors
- Build Errors Guide - SDK header dependencies
- Interface Methods - Abstract class errors
- Common Issues - Linker errors
I'm getting runtime errors
- Windows Message Loop - Callbacks not firing
- Authentication Pattern - Auth timeout
- Common Issues - Error code tables
I want to build a Custom UI meeting app
- Custom UI Architecture - How SDK rendering works
- SDK-Rendered vs Self-Rendered - Choose your approach
- Custom UI Video Rendering - Complete working code
- Interface Methods - 13 Custom UI virtual methods
- Build Errors Guide - MSBuild from git bash
I want to capture video/audio
- Raw Video Capture - Complete video workflow
- Recording vs Streaming approaches
- Permission requirements (host, OAuth tokens)
- Audio PCM capture
- Share Raw Data Capture - Screen share capture
- Subscribe to RAW_DATA_TYPE_SHARE
- Handle dynamic resolution
- SDK Architecture Pattern - Controller pattern
- Common Issues - No frames received
I want to use breakout rooms
- Breakout Rooms Guide - Complete breakout room workflow
- 5 roles: Creator, Admin, Data, Assistant, Attendee
- Create, configure, manage, join/leave rooms
- Common Issues - Breakout room error codes
I want to implement chat
- Chat Guide - Send/receive messages
- Rich text formatting (bold, italic, links)
- Private messages and threading
- File transfer events
I want to use live transcription
- Captions & Transcription Guide - Live transcription
- Automatic speech-to-text
- Multi-language translation
- Manual closed captions (host feature)
I want to record meetings
- Local Recording Guide - Local MP4 recording
- Permission request workflow
- zTscoder.exe encoder monitoring
- Gallery view vs active speaker
I want to implement a specific feature
- SDK Architecture Pattern - START HERE!
- Find the controller in
SDK/x64/h/meeting_service_interface.h - Find the header in
SDK/x64/h/meeting_service_components/ - Follow the universal pattern: Get controller → Implement listener → Use methods
I want to understand the SDK architecture
- SDK Architecture Pattern - Complete architecture overview
- Singleton Hierarchy - Navigate the service tree (4 levels)
- Interface Methods - Event listener pattern
- Authentication Pattern - Service pattern
🔥 Most Critical Documents
1. SDK Architecture Pattern (⭐ MASTER DOCUMENT)
[concepts/sdk-architecture-pattern.md](concepts/sdk-architecture-pattern.md)
This is THE most important document. It teaches the universal 3-step pattern:
- Get controller (singleton pattern)
- Implement event listener (observer pattern)
- Register and use
Once you understand this pattern, you can implement any of the 35+ features by just reading the SDK headers.
Key insight: The Zoom SDK follows a perfectly consistent architecture. Every feature works the same way.
2. Windows Message Loop (⚠️ MOST COMMON ISSUE)
[troubleshooting/windows-message-loop.md](troubleshooting/windows-message-loop.md)
99% of "callbacks not firing" issues are caused by missing Windows message loop. This document explains:
- Why SDK requires
PeekMessage()loop - How to implement it correctly
- How to diagnose callback issues
This was the hardest bug to find during development (took ~2 hours).
3. Build Errors Guide
[troubleshooting/build-errors.md](troubleshooting/build-errors.md)
SDK headers have dependency bugs that cause build errors. This document provides:
- Required include order
- Missing
<cstdint>fix - Missing
AudioTypefix - Missing
YUVRawDataI420fix
📊 By Document Type
Concepts (Why and How)
- SDK Architecture Pattern - Universal implementation pattern
- Singleton Hierarchy - Navigation guide for SDK services (4 levels deep)
Examples (Complete Working Code)
- Authentication Pattern - JWT authentication
- Raw Video Capture - Video capture with YUV420, recording vs streaming
- Custom UI Video Rendering - SDK-rendered video containers
- Breakout Rooms - Create, manage, join breakout rooms
- Chat - Send/receive messages with rich formatting
- Captions & Transcription - Live transcription and closed captions
- Local Recording - Local MP4 recording with permission flow
- Share Raw Data Capture - Screen share raw data capture
- Send Raw Data - Virtual camera, microphone, and share
Troubleshooting (Problem Solving)
- Windows Message Loop - Callback issues
- Build Errors - Compilation issues
- Common Issues - Quick diagnostics
References (Lookup Information)
- Interface Methods - Required virtual methods
- Windows Reference - Platform setup
- Authorization - JWT generation
- Bot Authentication - Bot tokens
- Breakout Rooms - Breakout room API
- AI Companion - AI features
💡 Key Learnings from Real Debugging
These documents were created from actual debugging of a non-functional Zoom SDK sample. Here are the key insights:
Critical Discoveries:
- Windows Message Loop is MANDATORY (not optional)
- SDK uses Windows message pump for callbacks
- Without it, callbacks are queued but never fire
- Manifests as "authentication timeout" even with valid JWT
- See: Windows Message Loop Guide
- SDK Headers Have Dependency Bugs
- Missing
#include <cstdint>in SDK headers meeting_participants_ctrl_interface.hdoesn't includemeeting_audio_interface.hrawdata_renderer_interface.honly forward-declaresYUVRawDataI420- See: Build Errors Guide
- Include Order is CRITICAL
<windows.h>must be FIRST<cstdint>must be SECOND- Then SDK headers in specific order
- See: Build Errors Guide
- ALL Virtual Methods Must Be Implemented
- Including WIN32-conditional methods
- SDK v6.7.2 requires 6 auth methods + 9 meeting methods
- Different versions have different requirements
- See: Interface Methods Guide
- The Architecture is Beautifully Consistent
- Every feature follows the same 3-step pattern
- Controllers are singletons
- Event listeners use observer pattern
- Once you learn the pattern, you can implement any feature
- See: SDK Architecture Pattern
🎓 Learning Path by Skill Level
Beginner (Never used Zoom SDK)
- Read SDK Architecture Pattern to understand the overall design
- Follow Authentication Pattern to join your first meeting
- Reference Common Issues when you hit problems
Intermediate (Familiar with SDK basics)
- Deep dive into SDK Architecture Pattern - implement multiple features
- Learn Raw Video Capture for media processing
- Use Interface Methods as reference
Advanced (Building production bots)
- Study SDK Architecture Pattern - learn to implement ANY feature
- Master Windows Message Loop - understand async callback flow
- Reference SDK headers directly using the universal pattern
🔍 How to Find What You Need
"My code won't compile"
"Authentication times out"
"Callbacks never fire"
"Abstract class error"
"How do I implement [feature]?"
"How do I join a meeting?"
"How do I capture video?"
"What error code means what?"
→ Common Issues - Comprehensive error code tables (SDKERR, AUTHRET, Login, BO, Phone, OBF)
"How do I use breakout rooms?"
"How does the SDK work?"
"How do I navigate to a specific controller/feature?"
"How do I send/receive chat messages?"
"How do I use live transcription?"
→ Captions & Transcription Guide
"How do I record locally?"
"How do I capture screen share?"
📝 Document Version
All documents are based on Zoom Windows Meeting SDK v6.7.2.26830.
Different SDK versions may have:
- Different required callback methods
- Different error codes
- Different API behavior
If using a different version, use grep "= 0" SDK/x64/h/*.h to verify required methods.
Remember: The SDK Architecture Pattern is the fastest way to understand how the Windows Meeting SDK fits together. Read it first if you are debugging custom UI or event flow issues.
Operations
- RUNBOOK.md - 5-minute preflight and debugging checklist.