Zoom API SDKs & Libraries: Official and Community Integrations (2026)

SDKs overview

The Zoom API provides programmatic access to its core functionalities, enabling developers to integrate video meetings, webinars, and user management features into custom applications. To simplify this integration, Zoom offers a suite of official Software Development Kits (SDKs) for popular platforms, alongside community-contributed libraries that extend its reach to additional programming languages and frameworks. These SDKs abstract much of the underlying REST API complexity, offering higher-level functions and event-driven interfaces for embedding real-time communication capabilities directly into diverse applications.

Utilizing an SDK can reduce development time by providing pre-built UI components, handling authentication flows, and managing real-time data synchronization. This allows developers to focus on application-specific logic rather than the intricacies of the network protocols or API endpoint management. The official SDKs are primarily designed for embedding the full Zoom client experience, including video, audio, and chat, into native desktop and mobile applications, as well as web browsers. For server-side integrations or specific API calls, developers often interact directly with the Zoom REST API endpoints, sometimes facilitated by community-supported client libraries.

Official SDKs by language

Zoom maintains official SDKs designed for integrating core Zoom client features directly into custom applications. These SDKs are platform-specific and provide comprehensive access to video, audio, chat, and meeting management functionalities. They are typically updated to align with the main Zoom client features and security improvements.

The following table outlines the key official SDKs provided by Zoom:

Installation

Installation methods vary depending on the specific SDK and target platform. Developers should refer to the official Zoom SDK documentation for the most up-to-date and platform-specific instructions.

Web SDK Installation (npm)

For web applications, the Zoom Web SDK is typically installed via npm:

npm install @zoom/websdk

After installation, you can import the necessary modules into your JavaScript project:

import ZoomMtg from '@zoom/websdk/release/web-sdk.umd';

Android SDK Installation (Gradle)

For Android development, the SDK can be integrated by adding dependencies to your project's build.gradle file. First, ensure you have the necessary repositories configured:

allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url 'https://zoom.github.io/zoom-sdk-android'
        }
    }
}

Then, add the SDK dependency to your app's build.gradle:

dependencies {
    implementation 'us.zoom.sdk:mobilertc:5.14.10.15570'
}

Note: Version numbers should be updated to the latest stable release as specified in the official documentation.

iOS SDK Installation (CocoaPods)

For iOS projects, CocoaPods is the recommended method. Add the Zoom SDK pod to your Podfile:

platform :ios, '10.0'

target 'YourApp' do
  use_frameworks!
  pod 'ZoomVideoSDK', '1.8.0'
end

Then, run pod install from your terminal in the project directory.

Note: Version numbers should be updated to the latest stable release as specified in the official documentation.

Windows and macOS SDK Installation

For Windows and macOS, the SDKs are typically distributed as downloadable packages containing libraries, header files, and sample projects. Developers download the package from the Zoom Developer website for Windows or macOS and integrate them manually into their IDE (e.g., Visual Studio for Windows, Xcode for macOS) following the detailed integration guides.

Quickstart example

This example demonstrates a basic integration using the Zoom Web SDK to embed a meeting into a web page. This snippet illustrates client-side initialization and joining a meeting. This requires pre-configuration on the server-side to generate a signature for authentication, as detailed in the Zoom Web SDK documentation for signatures.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Zoom Web SDK Integration</title>
    <link type="text/css" rel="stylesheet" href="https://source.zoom.us/5.14.10/css/bootstrap.css" />
    <link type="text/css" rel="stylesheet" href="https://source.zoom.us/5.14.10/css/react-select.css" />
</head>
<body>
    <div id="zmmtg-root"></div>

    <script src="https://source.zoom.us/5.14.10/lib/vendor/react.min.js"></script>
    <script src="https://source.zoom.us/5.14.10/lib/vendor/react-dom.min.js"></script>
    <script src="https://source.zoom.us/5.14.10/lib/vendor/redux.min.js"></script>
    <script src="https://source.zoom.us/5.14.10/lib/vendor/redux-thunk.min.js"></script>
    <script src="https://source.zoom.us/5.14.10/lib/vendor/jquery.min.js"></script>
    <script src="https://source.zoom.us/5.14.10/lib/vendor/lodash.min.js"></script>

    <script src="https://source.zoom.us/zoom-sdk/5.14.10/lib/zoom-sdk.umd.min.js"></script>

    <script>
        ZoomMtg.preLoadWasm();
        ZoomMtg.prepareJssdk();

        document.addEventListener('DOMContentLoaded', function() {
            // Replace with your actual API Key, Meeting Number, Passcode, User Name, and Signature
            const API_KEY = 'YOUR_API_KEY';
            const MEETING_NUMBER = 'YOUR_MEETING_NUMBER';
            const PASSCODE = 'YOUR_PASSCODE';
            const USER_NAME = 'Your Name';
            const SIGNATURE = 'YOUR_GENERATED_SIGNATURE'; // Must be generated server-side
            const ROLE = 0; // 0 for attendee, 1 for host

            ZoomMtg.init({
                leaveUrl: 'http://www.zoom.us',
                success: function () {
                    ZoomMtg.join({
                        signature: SIGNATURE,
                        meetingNumber: MEETING_NUMBER,
                        userName: USER_NAME,
                        apiKey: API_KEY,
                        passWord: PASSCODE,
                        success: function(res) {
                            console.log('join meeting success');
                        },
                        error: function(res) {
                            console.log(res);
                        }
                    });
                },
                error: function(res) {
                    console.log(res);
                }
            });
        });
    </script>
</body>
</html>

This example sets up the basic Zoom Web SDK environment and attempts to join a meeting. The SIGNATURE parameter is crucial for authentication and must be securely generated on a server using your Zoom API Key and Secret, as direct exposure of the API Secret client-side would pose a security risk. For details on how to generate this signature, refer to the Zoom Web SDK client-side signature generation documentation.

Community libraries

Beyond official SDKs, the developer community has created various libraries and wrappers that facilitate interaction with the Zoom API, often focusing on specific languages or frameworks not covered by official SDKs, or on simplifying server-side API calls. These libraries leverage the Zoom REST API to manage meetings, users, reports, and other resources.

• Python: Libraries like zoomus (available on PyPI) provide Pythonic wrappers for the Zoom REST API, simplifying tasks like creating meetings, managing users, and accessing reports. Developers can install it via pip install zoomus and use it to interact with the API endpoints programmatically. For example, creating a meeting would involve initializing the client with API credentials and calling a method like create_meeting().
• Node.js: While the official Web SDK is JavaScript-based for client-side use, community modules exist for Node.js environments to interact with the server-side REST API. These often handle request signing and API endpoint routing, streamlining backend integrations.
• PHP, Ruby, C#: Developers in these ecosystems often create their own client libraries or utilize generic HTTP clients to interact with the Zoom REST API directly. These custom solutions handle authentication, request formatting (JSON), and response parsing. For instance, a PHP developer might use Guzzle HTTP client to make authenticated requests to the Zoom API.

When using community-contributed libraries, developers should evaluate their maintenance status, documentation, and community support. While they can offer flexibility and language-specific convenience, they may not always keep pace with the latest Zoom API updates as quickly as official SDKs. For critical production systems, direct interaction with the Zoom REST API or well-maintained official SDKs is often preferred, although community libraries can accelerate prototyping and development for specific use cases. An example of this approach might involve using a general-purpose API client library, such as AWS SDK for JavaScript, to sign and send requests to external APIs.