npx skills add ...
npx skills add anthropics/knowledge-work-plugins --skill zoom-meeting-sdk-windows
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.
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.
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;
}