Zoom Video SDK SDKs & Libraries: Official and Community (2026)

SDKs overview

The Zoom Video SDK provides programmatic interfaces and client libraries designed for embedding customizable video, audio, and interactive features directly into applications Zoom Video SDK documentation. These SDKs allow developers to build real-time communication functionalities without the full Zoom client interface, offering control over the user experience and UI. The SDKs cover a range of native platforms and cross-platform frameworks, supporting use cases from social applications to telehealth and virtual events.

Core functionalities available through the SDKs include real-time video and audio streaming, screen sharing, chat, and participant management. Developers can manage local and remote video streams, control camera and microphone inputs, and implement custom UI elements to match their application's design language. The SDK also provides features for optimizing network performance and handling various network conditions, aiming to maintain call quality across different environments.

Security features within the SDKs include encryption for media and signaling, ensuring that communications are protected. Developers are provided with mechanisms to authenticate users and manage access to video sessions. The Zoom Video SDK aims to offer a flexible foundation for creating custom video conferencing experiences, distinguishing it from the full Zoom client by offering granular control over the application's functionality and appearance.

Official SDKs by language

Zoom offers a suite of official SDKs tailored for various development environments, enabling integration of video capabilities across diverse platforms Zoom Video SDK platform details. These SDKs are maintained by Zoom and provide access to the core features of the Video SDK. Each SDK is designed to align with the conventions and best practices of its target platform or framework.

The following table outlines the official SDKs, their primary languages, common package managers or installation methods, and their general maturity level as of 2026.

Each SDK provides specific client interfaces for managing video sessions, participants, and media streams. For instance, the Web SDK leverages common web technologies, making it suitable for browser-based applications, while the native iOS and Android SDKs offer deeper integration with device hardware and operating system features. Developers can consult the specific documentation for each platform to understand the detailed API surface and implementation guidelines Zoom Video SDK API reference.

Installation

Installation methods for the Zoom Video SDK vary by platform and development environment. The general process involves adding the SDK as a dependency to your project and then configuring it for use. Detailed steps are available in the Zoom Video SDK developer documentation.

Web SDK (npm)

For web projects, the SDK is typically installed via npm:

npm install @zoom/videosdk --save

After installation, you can import modules into your JavaScript or TypeScript files. The Web SDK requires a modern browser environment that supports WebRTC, such as Chrome, Firefox, Safari, or Edge. It integrates with common web frameworks like React, Angular, and Vue.js by providing components and methods for managing video sessions and user interfaces.

iOS SDK (CocoaPods)

For iOS applications, CocoaPods is a common method:

# Podfile
pod 'ZoomVideoSDK'

Then run pod install. Manual installation by dragging frameworks into your Xcode project is also an option. The iOS SDK provides a Swift-friendly interface for managing video sessions, local and remote participants, and media controls. It handles camera and microphone access, rendering video frames, and managing network connectivity specific to Apple's ecosystem.

Android SDK (Gradle)

For Android applications, add the dependency to your build.gradle file:

dependencies {
    implementation 'us.zoom.sdk:videosdk:latest.release'
}

The Android SDK integrates into Android Studio projects and offers Java/Kotlin APIs for managing video sessions, integrating with Android UI components, and handling device permissions. It supports a range of Android versions and device types, providing optimizations for performance and battery usage.

React Native SDK

For React Native projects:

npm install @zoom/react-native-videosdk
npx pod-install

The React Native SDK provides a bridge to the native iOS and Android SDKs, allowing developers to write cross-platform video applications using a single codebase. It wraps native functionalities in JavaScript, making it accessible within the React Native component model. This includes managing video components, audio settings, and session events.

Flutter SDK

For Flutter projects, add to your pubspec.yaml:

dependencies:
  zoom_videosdk:
    ^latest.version

Then run flutter pub get. The Flutter SDK, available via pub.dev, offers a Dart API for integrating video conferencing into Flutter applications. It leverages platform channels to communicate with native SDKs, providing a unified API for both iOS and Android platforms within the Flutter framework.

Windows SDK

For Windows applications, the SDK is typically distributed as a set of DLLs and header files. Installation involves copying these files into your project and configuring your build system (e.g., Visual Studio) to link against them. NuGet packages may also be available for C# development. The Windows SDK supports both C++ and C# interfaces, allowing developers to integrate video features into native desktop applications, often leveraging DirectX or GDI+ for rendering.

macOS SDK

Similar to iOS, the macOS SDK can be integrated via CocoaPods or Swift Package Manager, or by manually embedding the framework. It provides a native Objective-C/Swift API for building video applications on macOS, including features for screen sharing, virtual backgrounds, and camera/microphone management specific to the macOS environment.

Quickstart example

This example demonstrates a basic integration of the Zoom Video SDK for Web, joining a session and displaying local and remote video streams. This snippet assumes you have obtained a valid SDK JWT (JSON Web Token) and a session name.

import ZoomVideo from '@zoom/videosdk';

const client = ZoomVideo.createClient();

async function initializeAndJoinSession(sdkKey, sdkSecret, sessionName, userName) {
  try {
    // Initialize the client with your SDK key and secret
    await client.init('en-US', 'CDN', { patchLogLevel: 'info' });
    console.log('Zoom Video SDK client initialized.');

    // Generate a signature for the session (this typically happens server-side)
    // For demonstration, assume 'signature' is already generated.
    const signature = "YOUR_GENERATED_SDK_JWT"; // Replace with actual JWT

    // Join the session
    const joinResult = await client.join(sessionName, signature, userName);
    console.log('Joined session:', joinResult);

    // Get the stream and render local video
    const stream = client.getStream();
    const localVideoElement = document.getElementById('local-video');
    if (localVideoElement) {
      await stream.startVideo();
      stream.renderVideo(localVideoElement, client.getCurrentUserInfo().userId, 300, 200, 0, 0, 3);
    }

    // Listen for new participant events to render remote videos
    client.on('peer-video-state-change', async (payload) => {
      if (payload.action === 'Start') {
        const remoteVideoElement = document.createElement('video');
        remoteVideoElement.id = `remote-video-${payload.userId}`;
        document.body.appendChild(remoteVideoElement);
        await stream.startVideo({
          userId: payload.userId
        });
        stream.renderVideo(remoteVideoElement, payload.userId, 300, 200, 0, 0, 3);
      }
    });

    console.log('Session joined and video started.');
  } catch (error) {
    console.error('Failed to initialize or join Zoom Video SDK session:', error);
  }
}

// Example usage (replace with your actual values)
const sdkKey = 'YOUR_SDK_KEY';
const sdkSecret = 'YOUR_SDK_SECRET';
const sessionName = 'my-custom-video-session';
const userName = 'DeveloperUser';

// Assuming you have HTML elements with ids 'local-video'
// Example HTML:
// <video id="local-video" autoplay playsinline></video>

// initializeAndJoinSession(sdkKey, sdkSecret, sessionName, userName);

This quickstart illustrates the fundamental steps: client initialization, joining a session with a generated JWT, starting local video, and rendering both local and remote participant videos. The SDK JWT must be securely generated on a backend server, as it contains sensitive credentials Zoom Video SDK authentication guide. For a complete implementation, error handling, UI management, and additional features like audio control, chat, and screen sharing would need to be added. The Web SDK also provides methods for managing audio streams, sharing screens, and sending chat messages within a video session.

Community libraries

While the Zoom Video SDK primarily relies on its official SDKs, the developer community sometimes creates libraries or wrappers to simplify integration or extend functionality for specific use cases or frameworks not directly covered by official support. These community efforts can range from UI component libraries that abstract SDK calls to utilities for managing session data.

As of 2026, the Zoom Video SDK ecosystem is heavily weighted towards its official offerings due to the complexity of real-time media processing and the need for tight integration with Zoom's backend infrastructure. Developers typically integrate the official SDKs directly into their applications. Community contributions often appear as open-source projects on platforms like GitHub, providing examples, helper functions, or integrations with niche frameworks. These can be found by searching repositories for zoom video sdk along with the desired language or framework.

One area where community libraries can emerge is in providing higher-level abstractions or UI components that simplify the creation of video interfaces. For example, a community library might offer pre-built React components that wrap the Web SDK's video rendering and controls, reducing boilerplate code for common UI patterns. However, developers should evaluate the maintenance status, security, and compatibility of any third-party library before integrating it into production applications, as they may not be officially supported or updated as frequently as the core SDKs.

For developers seeking to explore or contribute to the broader ecosystem of real-time communication tools, resources like the Mozilla WebRTC API documentation provide foundational knowledge on the underlying technologies that many video SDKs, including Zoom's, leverage. Understanding these core principles can aid in both utilizing official SDKs effectively and evaluating or contributing to community-developed tools.