OverviewHistoryStatsSecurity
npx skills add ...
Documentation
SKILL.md
npx skills add anthropics/knowledge-work-plugins --skill zoom-meeting-sdk-windows
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.
npx skills add anthropics/knowledge-work-plugins --skill zoom-meeting-sdk-windows
Embed Zoom meeting capabilities into Windows desktop applications for native C++ integrations and headless bots.
The fastest way to master the SDK:
Building a Custom UI?
Having issues?
Need help with authentication? See the zoom-oauth skill for JWT token generation.
IMPORTANT: These are hard-won preferences from real project experience. Follow these when creating new projects.
.vcxprojAlways create a native Visual Studio .sln + .vcxproj project, not a CMake project. Reasons:
.sln to open in Visual Studio immediatelyconfig.json must be visible in Solution ExplorerThe config.json file (containing sdk_jwt, meeting_number, passcode) must be:
.vcxproj as a <None> item with <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>.vcxproj.filters file so it appears under a "Config" folder in Solution ExplorerExample .vcxproj entry:
Example .vcxproj.filters entry:
The Windows SDK is a C++ native SDK designed for:
The SDK follows a universal 3-step pattern for every feature:
meetingService->Get[Feature]Controller()class MyListener : public I[Feature]Event { ... }controller->SetEvent(listener) then call methodsThis 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
Download from Zoom Marketplace:
zoom-meeting-sdk-windows_x86_64-{version}.zipCopy SDK files:
Project Properties → C/C++ → General → Additional Include Directories:
Project Properties → Linker → General → Additional Library Directories:
Project Properties → Linker → Input → Additional Dependencies:
Post-Build Event (Copy DLLs to output):
Create config.json:
⚠️ CRITICAL: Add Windows message loop or callbacks won't fire!
See: Windows Message Loop Guide
💡 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
CRITICAL: Include headers in this exact order or you'll get build errors:
See: Build Errors Guide for all dependency fixes.
AuthServiceEventListener.h:
See complete working code: Authentication Pattern Guide
MeetingServiceEventListener.h:
See all required methods: Interface Methods Guide
ZoomSDKRendererDelegate.h:
Complete video capture guide: Raw Video Capture Guide
⚠️ WITHOUT THIS, CALLBACKS WON'T FIRE!
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:
See detailed explanation: Windows Message Loop Guide
| 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
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):
Implement event listener (observer pattern):
Register and use:
Complete guide with examples: SDK Architecture Pattern
| 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 |
| Repository | Description |
|---|---|
| meetingsdk-windows-raw-recording-sample | Official raw data capture samples |
| meetingsdk-windows-local-recording-sample | Local recording with Docker |
Raw YUV/PCM files have no headers - you must specify format explicitly.
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) |
Important: Beginning March 2, 2026, apps joining meetings outside their account must be authorized.
Use one of:
app_privilege_token in JoinParam)userZAK in JoinParam)onBehalfToken in JoinParam)This skill includes comprehensive guides created from real-world debugging:
Core Concepts:
Complete Examples:
Troubleshooting:
References:
Callbacks not firing → Missing Windows message loop (99% of issues)
Build errors → SDK header dependencies (uint32_t, AudioType, etc.)
Abstract class errors → Missing virtual method implementations
Once you learn the 3-step pattern, you can implement ANY of the 35+ features:
Documentation Version: Based on Zoom Windows Meeting SDK v6.7.2.26830
Need help? Start with SKILL.md for complete navigation.
If you're new to the SDK, follow this order:
Read the architecture pattern → concepts/sdk-architecture-pattern.md
.h filesFix build errors → troubleshooting/build-errors.md
Implement authentication → examples/authentication-pattern.md
Fix callback issues → troubleshooting/windows-message-loop.md
Implement virtual methods → references/interface-methods.md
Capture video (optional) → examples/raw-video-capture.md
Troubleshoot any issues → troubleshooting/common-issues.md
SDK/x64/h/meeting_service_interface.hSDK/x64/h/meeting_service_components/concepts/sdk-architecture-pattern.md
This is THE most important document. It teaches the universal 3-step pattern:
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.
troubleshooting/windows-message-loop.md
99% of "callbacks not firing" issues are caused by missing Windows message loop. This document explains:
PeekMessage() loopThis was the hardest bug to find during development (took ~2 hours).
troubleshooting/build-errors.md
SDK headers have dependency bugs that cause build errors. This document provides:
<cstdint> fixAudioType fixYUVRawDataI420 fixThese documents were created from actual debugging of a non-functional Zoom SDK sample. Here are the key insights:
Windows Message Loop is MANDATORY (not optional)
SDK Headers Have Dependency Bugs
#include <cstdint> in SDK headersmeeting_participants_ctrl_interface.h doesn't include meeting_audio_interface.hrawdata_renderer_interface.h only forward-declares YUVRawDataI420Include Order is CRITICAL
<windows.h> must be FIRST<cstdint> must be SECONDALL Virtual Methods Must Be Implemented
The Architecture is Beautifully Consistent
→ Common Issues - Comprehensive error code tables (SDKERR, AUTHRET, Login, BO, Phone, OBF)
→ Captions & Transcription Guide
All documents are based on Zoom Windows Meeting SDK v6.7.2.26830.
Different SDK versions may have:
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.
<ItemGroup>
<Filter Include="Config">
<UniqueIdentifier>{GUID-HERE}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<None Include="config.json">
<Filter>Config</Filter>
</None>
</ItemGroup>your-project/
YourApp/
SDK/
x64/
bin/ # DLL files and dependencies
h/ # Header files
lib/ # sdk.lib
x86/
bin/
h/
lib/
YourApp.cpp
YourApp.vcxproj
config.jsonxcopy /E /I sdk-package\x64 your-project\YourApp\SDK\x64\
xcopy /E /I sdk-package\x86 your-project\YourApp\SDK\x86\# Install vcpkg
git clone https://github.com/Microsoft/vcpkg.git C:\vcpkg
cd C:\vcpkg
.\bootstrap-vcpkg.bat
.\vcpkg integrate install
# Install dependencies
.\vcpkg install jsoncpp:x64-windows
.\vcpkg install curl:x64-windows$(SolutionDir)SDK\$(PlatformTarget)\h
C:\vcpkg\packages\jsoncpp_x64-windows\include
C:\vcpkg\packages\curl_x64-windows\include$(SolutionDir)SDK\$(PlatformTarget)\libsdk.libxcopy /Y /D "$(SolutionDir)SDK\$(PlatformTarget)\bin\*.*" "$(OutDir)"{
"sdk_jwt": "YOUR_JWT_TOKEN",
"meeting_number": "1234567890",
"passcode": "password123",
"zak": ""
}┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ InitSDK │───►│ AuthSDK │───►│ JoinMeeting │───►│ Raw Data │
│ │ │ (JWT) │ │ │ │ Subscribe │
└─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘
│ │
▼ ▼
OnAuthComplete onInMeeting
callback callbackwhile (!done) {
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}#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>#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;
}#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 SDKAuth
authService->SetEvent(new AuthServiceEventListener(&OnAuthenticationComplete));
// Authenticate with JWT
AuthContext 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.md
return true;
}#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 {}
#endif
private:
void (*onAuthComplete)();
};#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 listener
meetingService->SetEvent(
new MeetingServiceEventListener(&OnMeetingJoined, &OnMeetingEnds, &OnInMeeting)
);
// Prepare join parameters
JoinParam 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;
}#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 {}
#endif
private:
void (*onMeetingJoined)();
void (*onMeetingEnded)();
void (*onInMeetingCallback)();
};#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 initialize
std::this_thread::sleep_for(std::chrono::milliseconds(500));
// STEP 2: Create renderer
SDKError err = createRenderer(&videoHelper, videoSource);
if (err != SDKERR_SUCCESS || !videoHelper) {
std::cout << "createRenderer failed: " << err << std::endl;
return false;
}
// STEP 3: Set resolution and subscribe
videoHelper->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;
}#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 plane
int width = data->GetStreamWidth();
int height = data->GetStreamHeight();
// Calculate buffer sizes
// Y = full resolution, U/V = quarter resolution each
size_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); // Brightness
outputFile.write(data->GetUBuffer(), uvSize); // Blue-difference
outputFile.write(data->GetVBuffer(), uvSize); // Red-difference
outputFile.close();
}
void onRawDataStatusChanged(RawDataStatus status) override {
std::cout << "Raw data status: " << status << std::endl;
}
void onRendererBeDestroyed() override {
std::cout << "Renderer destroyed" << std::endl;
}
};#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 audio
IZoomSDKAudioRawDataHelper* audioHelper = GetAudioRawdataHelper();
audioHelper->subscribe(new ZoomSDKAudioRawDataDelegate());#include <windows.h>
#include <thread>
#include <chrono>
int main() {
// Initialize COM
CoInitialize(NULL);
// Load config and initialize
LoadConfig();
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 messages
while (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-waiting
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
// Cleanup
CleanSDK();
CoUninitialize();
return 0;
}