Options
All
  • Public
  • Public/Protected
  • All
Menu

The Zoom Apps SDK is a JavaScript library that faciliates communication between your Zoom App and the Zoom client. The SDK allows you to take advantage of the many APIs and events Zoom exposes in its embedded browser.

Installation

There are two ways to install the Zoom Apps SDK into your frontend project

NPM

You can install it from NPM, if you are using a module bundler such as Webpack:

$ npm install @zoom/appssdk

CDN

Alternatively, you can load the SDK from a CDN, using a script tag in your HTML document:

<script src="https://appssdk.zoom.us/sdk.js"></script>

Usage

If you installed Zoom Apps SDK from NPM, import zoomSdk into the component where you wanted to use the SDK and call config as your first call to verify your application with Zoom.

import zoomSdk from "@zoom/appssdk"

async function configureApp {
const configResponse = await zoomSdk.config({
popoutSize: {width: 480, height: 360},
capabilities: ["shareApp"]
})
}

When you load the SDK using a script tag, zoomSDK is served as a global object and can be called across components. Even in this case zoomSdk.config should be the first call.

<script src="https://appssdk.zoom.us/sdk.js"></script>

async function configureApp {
const configResponse = await zoomSdk.config({
version: "0.16",
popoutSize: {width: 480, height: 360},
capabilities: ["shareApp"]
})
}

The cloud SDK is designed to provide on-demand patch updates, and it does not support exact versions. You will always get the latest patch version within the major version specified in the version parameter of zoomSdk.config. In other words, if you supplied an exact version like 0.16.1, you will get the latest patch within the 0.16 major version.

zoomSdk.config response object. Read more about zoomSdk.config

{
"clientVersion": "5.11.1.8356",
"browserVersion": "applewebkit/17613.2.7.1.8",
"userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko)",
"auth": {
"status": "authorized",
"upgradable": true
},
"unsupportedApis": [],
"runningContext": "inMainClient"
}

Note

  • Zoom Desktop Client is a native application. Depending on the Zoom Desktop Client version a user has installed, they might have access to different Zoom Apps APIs and events. With the cloud version of the SDK, you automatically get the latest patches as we release new client versions, and your apps avoid potential breaks due to missing patches.

  • When using SDK via npm, check for updates in our monthly release of Zoom Desktop Client. You must manually update your app when needed to the latest SDK to maintain compatibility with newer client versions.

  • The SDK module installed via npm includes the sdk.d.ts file which provides type definitions for sdk.es.js and sdk.module.js. The cloud-based SDK does not provide this file.

How do compatibility patches work?

This is an example of how compatibility patches delivered via cloud-based SDK help your app run on the latest client versions.

Note: This example is only for illustrating the concept, and does not imply Zoom is planning to change the sendAppInvitation API schema.

Example: Your app is developed against the 3.4.0 client version and uses the sendAppInvitation API.

Client version 3.4.0. The sendAppInvitation API schema is

sendAppInvitation ({ participantUUIDs: [participantUUID1, participantUUID2, ...], })

Client version 4.0.0 introduces a breaking change to the sendAppInvitation API that requires one additional parameter message to customize your invitation. The new API schema is

sendAppInvitation ({ participantUUIDs: [participantUUID1, participantUUID2, ...],  message: "This app is awesome, try it!"})

Apps based on the client version 3.4.0 will break when used on the 4.0.0 client because the client is expecting the message parameter as part of the API call. Whereas, when you use the cloud-based SDK, the compatibility patch can accept your API request and transform it internally to use a default value for the message parameter.

Original call from app to SDK

sendAppInvitation ({ participantUUIDs: [participantUUID1, participantUUID2, ...], })

SDK transforms the call internally to

sendAppInvitation ({ participantUUIDs: [participantUUID1, participantUUID2, ...], message: ""})

Release notes

Refer to release notes to discover changes made in the Apps SDK.

Resources to create a Zoom App

Need help?

Hierarchy

  • ZoomSdk

Index

Methods Core Endpoints

Methods In-client Auth

Methods Collaborate Mode

Methods Managing Breakout Rooms

Methods Maintaining State Outside of a Meeting

Methods Events Core

Methods Events Managing Collaborations

Methods Events Managing Breakout Rooms

Methods Events maintaining state outside of a meeting

Core Endpoints Methods

  • To initialize and start using the SDK, you must first call zoomSdk.config to verify your application with Zoom. Without completing this step, your application won’t be able to use any of the APIs or event listeners provided by the SDK. In the request body of this API call, specify the list of APIs and event listeners that you plan to use in your app as shown below. Ensure that the list of capabilities provided in this request corresponds to the list of APIs and events that you have added in your app build flow on Marketplace (Zoom App > Feature > Zoom App SDK).

    The Zoom Apps SDK relies on a token that is generated and used internally by the Zoom client to authorize API calls on behalf of the app. This token is bound to the openURL that you provide when you call zoomSdk.config. If your URL changes, your configuration will be invalidated and you will need to call zoomSdk.config with the new URL again.

    If your Zoom App is a single page app, we suggest modifying your navigation methods to automate this.

    const configResponse = await zoomSdk.config({
    version: '0.16',
    // The `version` param is only required if using the Cloud SDK (not NPM SDK).
    // See README for more details.
    popoutSize: { width: 480, height: 360 },
    capabilities: [
    //APIs
    "shareApp",
    "listCameras",
    "setCamera",
    "setVideoMirrorEffect",
    "getMeetingParticipants",
    "cloudRecording",
    "allowParticipantToRecord",
    "getRunningContext",
    "getMeetingContext",
    "getSupportedJsApis",
    "showNotification",
    "openUrl",
    "setVirtualBackground",
    "listCameras",
    "setCamera",
    "sendAppInvitation",
    "sendAppInvitationToAllParticipants",
    "getUserContext",
    "getRecordingContext",
    "getMeetingContext",
    "getMeetingJoinUrl",
    "getMeetingUUID",
    "expandApp",
    "connect",
    "postMessage",
    "allowParticipantToStartLocalRecording",
    //Events
    "onShareApp",
    "onSendAppInvitation",
    "onCloudRecording",
    "onActiveSpeakerChange",
    "onAppPopout",
    "onCohostChange",
    "onParticipantChange",
    "onReaction",
    "onConnect",
    "onExpandApp",
    "onMessage",
    "onMeeting",
    ],
    });

    Parameters

    Returns Promise<ConfigResponse>

  • Returns an array of APIs and events supported by the current running context.

    await zoomSdk.getSupportedJsApis();
    

    Returns Promise<GetSupportedJsApisResponse>

  • Opens a URL in the system browser of a user's device.

    await zoomSdk.openUrl({ url: "https://awesome-zoom-app.com/login" });
    

    You must whitelist the URL's domain in your Marketplace app configuration, otherwise the browser will show a warning "Accessing Untrusted Web Site". And the user has to manually click the link to trigger marketplace to redirect them to the specified url.

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Returns the context in which the Zoom App is launched: inMeeting, inWebinar, inMainClient, inPhone, inCollaborate. This is useful for controlling your app's behavior based on the presence of a single user or multiple collaborative users.

    await zoomSdk.getRunningContext();
    

    Returns Promise<RunningContextResponse>

  • This API is only available in meetings. It returns an object containing basic information about the meeting.

    Role-based permissions This API is only available to an app instance being run by a Meeting Owner.

    await zoomSdk.getMeetingContext();
    

    Returns Promise<GetMeetingContextResponse>

  • This sets a virtual background or blur the user's native background.

    When setVirtualBackground is invoked in a context where the smart virtual background package is not yet installed, a dialog prompts the user to download the package. When the user clicks "Install" in the dialog box, the package is downloaded. The client will subsequently show the consent dialog for setting the background.

    var myOptions = {
    fileUrl: "https://unsplash.com/photos/itTHOJ5aUk4"
    };

    await zoomSdk.setVirtualBackground(myOptions);

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Removes current virtual background and resets to use the camera.

    Note that when calling removeVirtualBackground, the client will pop up a confirmation dialog to let the user allow or disallow. If the user does not allow the action, the client will return an error code of 10017 to the app.

    Supports Guest Mode = Yes

    zoomSdk.removeVirtualBackground().then(function() => {
    // background was successfully removed
    })
    .catch(function(error) => {
    // there was an error removing the virtual background
    })

    Returns Promise<GeneralMessageResponse>

  • Draws an image in the foreground of the user’s video.

    zoomSdk.setVirtualForeground({
    imageData: <ImageData>
    })
    .then((ctx) => {
    console.log("setVirtualForeground returned", ctx);
    })
    .catch((e) => {
    console.log(e);
    });

    Returns

    On success, this returns an object with an imageId field (string/UUID) that uniquely identifies the image.

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Removes the image which was set using setVirtualForeground from the foreground of the user’s video.

    zoomSdk.removeVirtualForeground()
    .catch((e) => {
    console.log(e);
    });

    Returns Promise<GeneralMessageResponse>

  • Triggers a push notification. The embedded browser does not support the Web Notification API, so we have provided a similar API via the JS SDK.

    Supports Guest Mode = Yes

    await zoomSdk.showNotification({
    type: "info",
    title: "Hello",
    message: "This is an info notification"
    });

    Parameters

    Returns Promise<GeneralMessageResponse>

  • The cloud recording API allows you to control cloud recording actions during a meeting.

    await zoomSdk.cloudRecording({ action: "start" });
    

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Screenshare current app.

    Role-based permissions In webinars, this API is only available to an app instance being run by a panelist or host. Webinar attendees cannot use this API.

    Supports Guest Mode = Yes

    await zoomSdk.shareApp({ action: "start" });
    

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Get all available cameras.

    Supports Guest Mode = Yes

    await zoomSdk.listCameras();
    

    Returns

    {
    "cameras": [
    { "id": "0x14424000046d085b", "name": "Logitech Webcam C925e #2" },
    { "id": "0x8020000005ac8514", "name": "FaceTime HD Camera (Built-in)" }
    ]
    }

    Returns Promise<ListCamerasResponse>

  • Role-based permissions This API is only available to an app instance being run by a Meeting Owner.

    Get information of the participants in the current meeting. Note that for breakout rooms, the participants in the current room will be returned, not those of the parent meeting.

    await zoomSdk.getMeetingParticipants();
    

    Returns Promise<GetMeetingParticipantsResponse>

  • Send app to list of participants in the meeting.

    await zoomSdk.sendAppInvitation({
    participantUUIDs: [participantUUID1, participantUUID2, ...],
    });

    Returns

    { "invitationUUID": "AnQlE6dxT9yx+jxeI8ZXuQ==" }
    

    Parameters

    Returns Promise<AppInvitationResponse>

  • It returns basic information about the meeting participant while in a meeting.

    Supported in Guest Mode = Yes.

    zoomSdk.getUserContext().then((result) => {
    // e.g. { screenName: 'Happy Zoomineer', role: 'host', participantId: "xxxx", participantUUID: "xxxx", status: "authorized"}
    })
    .catch(function(error){
    // there was an error
    })

    Returns Promise<GetUserContextResponse>

  • This API endpoint is only available in meetings. It returns basic information about the meeting recording while in a meeting.

    zoomSdk.getRecordingContext().then((result) => {
    // e.g. { cloudRecordingStatus: 'stopped'|'started'|'paused'|'connecting'}
    })
    .catch(function(error){
    // there was an error
    })

    Returns Promise<GetRecordingContextResponse>

  • This API endpoint is only available in meetings. It allows the app to access the JoinUrl while in a meeting.

    Role-based permissions This API is only available to an app instance being run by a Meeting Owner.

    zoomSdk.getMeetingJoinUrl()
    .then((result) => {
    // e.g. { joinUrl: "xxxxxx"}
    })
    .catch(function(error){
    // there was an error
    })

    Returns Promise<GetMeetingJoinUrlResponse>

  • This API endpoint is only available in meetings. It allows the app to access the meetingUUID while in a meeting.

    In breakout rooms,meetingUUID identifies the specific breakout room, and parentUUID helps connect individual rooms to the main meeting. Note that the value of parentUUID must be used for REST API calls inside of breakout rooms, while meetingUUID is otherwise used.

    Supported in Guest Mode = Yes.

    zoomSdk.getMeetingUUID()
    .then(function(result){
    // e.g. { meetingUUID: 'abcdefghijklmnopqrstuvwx'}
    })
    .catch(function(error){
    // there was an error
    })

    Returns Promise<GetMeetingUUIDResponse>

  • Tells the client to expand to the larger size or collapse it back to the default app UI size.

    Supported in Guest Mode = Yes.

    await zoomSdk.expandApp({
    action: 'expand' | 'collapse',
    })

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Allow a specific participant to start a local recording. This API will trigger a pop-up consent dialog in the client to let the host allow or not allow.

    Role-based permissions This API is only available to an app instance being run by a Meeting Host who is also a Meeting Owner. This API is not available in webinars.

    await zoomSdk.allowParticipantToRecord({
    participantUUID: 'xxxx',
    action: "grant"
    })

    This API requires (one of) participantId or participantUUID

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Starts a new meeting or joins an existing meeting and launches the app in the meeting.

    await zoomSdk.launchAppInMeeting({ joinURL: 'xxx' })
    
    with joinURL without joinURL
    inMainClient Joins meeting associated with the joinURL and launches app in it Starts a new meeting and launches app in it

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Shows client participant selection dialog window for sending an app invitation.

    Triggers client built in participant selection UI, so that apps running in non-owner context that do not have screen names can invite specific users

    await zoomSdk.showAppInvitationDialog();
    

    Returns Promise<GeneralMessageResponse>

  • Sends invitation of current app to the meeting owner (person who scheduled the meeting).

    Sends app invitations specifically to the meeting owner. Sent to both meeting & persistent chat when the meeting owner is in the meeting. Sent to persistent chat when the meeting owner is not in the meeting that might be ongoing.

    Role-based permissions In webinars, this API is only available to an app instance being run by a panelist or host. Webinar attendees cannot use this API.

    await zoomSdk.sendAppInvitationToMeetingOwner();
    

    Returns Promise<AppInvitationResponse>

  • Sends invitation for the current app to all participants currently in the meeting.

    In breakout rooms, this will only send invitations to participants within the current room.

    This API may behave differently depending on the in-meeting chat setting enabled by the host for the meeting participants. The meeting host can determine whether meeting participants can chat with: No one, Hosts and Cohosts, Everyone, Everyone and Anyone directly.

    Role-based permissions This API is not available to panelists or attendees in webinars.

    await zoomSdk.sendAppInvitationToAllParticipants()
    .then(function(){
    // success
    })
    .catch(function(error){
    // there was an error
    })

    Returns Promise<AppInvitationResponse>

  • Changes the app's rendering context from the meeting sidebar to the main meeting window, with behavior defined by the specified view option.

    zoomSdk.runRenderingContext({
    view: 'immersive'
    })

    Only a meeting host may invoke an immersive runRenderingContext. To transition other meeting participants to an immersive view, the meeting host’s app must use the sendAppInvitationToAllParticipants API.

    Warning: Only one app instance can create an immersive rendering context at a time. If another attempts to, it will fail with an error.

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Returns the rendering context of the app to the sidebar.

    zoomSdk.closeRenderingContext()
    .then(() => {
    console.log("closeRenderingContext returned");
    })
    .catch((e) => {
    console.log(e);
    });

    Returns Promise<GeneralMessageResponse>

  • Draws participant videos and static images on top of the background.

    The getMeetingParticipants method provides a list of meeting participants. For each of these, the app can specify a position, size and z-index with using drawParticipant. This method is available when using the "immersive" rendering context. All visible meeting participants are shown using a video cutout, removing their background.

    zoomSdk.drawParticipant({
    participantUUID: 'xxx',
    x: 0, y: 0, width: 1280, height: 720, zIndex: 1
    })
    .then((ctx) => {
    console.log("drawParticipant returned", ctx);
    })
    .catch((e) => {
    console.log(e);
    });

    Notes

    • The getMeetingParticipants() API is only available to the meeting host. When multiple participants are each using the same Layers app for a meeting, app-specific messaging may be used to communicate the participants list to other meeting attendees.
    • Drawing a participant’s video that is already being drawn moves it to the new location.
    • If the participant isn’t sending video, the a fallback will be used. Fallbacks are tried in the following order: user avatar, telephone icon (if applicable), CRC icon (if applicable), user name.

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Draws an image in the rendering context's canvas.

    Supports Guest Mode = Yes.

    zoomSdk.drawImage({
    imageData: <ImageData (includes width/height properties)>,
    x: 0, y: 0, zIndex: 3
    })
    .then((ctx) => {
    console.log("drawImage returned", ctx);
    })
    .catch((e) => {
    console.log(e);
    });

    Notes

    Drawing an image with the same x / y / zIndex / width / height as an existing image replaces the previous image and may return the same imageId.

    In order to move an image, use clearImage first, and then redraw the image in the intended position.

    Parameters

    Returns Promise<DrawImageResponse>

  • Clears the content set by drawImage.

    Supports Guest Mode = Yes.

    zoomSdk.clearImage({
    imageId: 'xxx'
    })
    .catch((e) => {
    console.log(e);
    });

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Draws the OSR webview with the specified size, location and zIndex [Layers Camera Mode]

    zoomSdk.drawWebView({
    webviewId: 'camera'
    x: 0, y: 0, width: 1280, height: 720, zIndex: 2
    })
    .catch((e) => {
    console.log(e);
    });

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Clears the content set by drawWebView. [Layers Camera Mode]

    zoomSdk.clearWebView({
    webviewId: 'camera'
    })
    .catch((e) => {
    console.log(e);
    });

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Allows hosts and co-hosts to mute and unmute all, or specific, meeting participants. The action doesn’t affect the person initiating the request.

    Role-based permission: meeting host and co-hosts

    Running context: inMeeting, inWebinar

    Supports Guest Mode: No

    Scope label: Manage Devices

    Scope hierarchy: zoomapps.meetings / zoomapps.webinar

    Confirmation / Consent moments

    • All participants

      "[AppName] wants to unmute all participants" [Don’t Allow] [Allow]

    • Single participant

      "[AppName] wants to unmute this participant: [Screen name]" [Don’t Allow] [Allow]

    • Multiple participants

      "[AppName] wants to unmute these participants: [Screen name 1], [Screen name 2], [Screen name 3],…" [Don’t Allow] [Allow]

    zoomSdk.toggleParticipantMediaAudio({
    "participantUUIDs":['participantUUID1','participantUUID2'....],
    "audio": true | false
    })
    .then((response) => { console.log(response); })
    .catch((e) => { console.log(e); })

    Parameters

    Returns Promise<GeneralMessageResponse>

In-client Auth Methods

  • This method is part of in-client OAuth feature. It initiates on OAuth authorization request from the Zoom Client - Zoom Apps tab - to the Zoom marketplace.

    Invoke the authorize method with PKCE codeChallenge and optional state:

    • If the app's scopes are authorized by the user, it starts a non-interactive OAuth flow, completely invisible to the user.
    • If the app's scopes have changed or added, it goes to the in-client consent screen, and the user is prompted to reauthorize the app's scope.

    Notes The application must create a crypographically secure string for OAuth2.0 code verifier, which is used to generate the challenge.

    Upon user authorization, an onAuthorized event is triggered with an authorization code. You have to add an event listener for this event to get authorization code.

    zoomSdk.authorize({
    state: 'TIA5UgoM38',
    codeChallenge: 'o0qAEF...'
    }).then((ret) => {
    console.log(ret);
    }).catch((e) => {
    console.log(e);
    })

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Triggers a contextual prompt for the user to sign in with Zoom (if the user context status is not "authenticated"), or add the app (if the user context status is "authenticated"). The prompt is asynchronous and non-blocking, users can continue using the app while it is visible, or close the prompt.

    If user context is "unauthenticated", Zoom does not know the user, and only some Zoom APIs are allowed. Invoking promptAuthorize will ask the user to log in to Zoom, upon which user context status will update to "authenticated".

    If user is authenticated, but they have not yet added the app and/or consented to app scopes, invoke promptAuthorize once more to ask the authenticated user to consent and add the app. This will invoke the in-client OAuth flow and update user context status to "authorized".

    IMPORTANT: Calling promptAuthorize will update user context status, per the states noted above. You MUST reconfigure the application upon user context status change, by re-calling the config method. The recommended approach is to listen for the onMyUserContextChange event and invoke config once more if the user context status has changed.

    zoomSdk.promptAuthorize()
    .then((res) => console.log(res))
    .catch((err) => console.log(err))

    Returns Promise<GeneralMessageResponse>

Collaborate Mode Methods

  • Starts Collaborate mode in a meeting. Can be initiated by hosts or co-hosts. Use the optional shareScreen parameter to opt out of sharing the host’s app screen with participants as a preview or when participants ignore the Collaborate invite.

    zoomSdk.startCollaborate(
    { "shareScreen": true || false } // default true}(host/cohost)
    ).then(function(response) {})
    .catch(function(error) {
    // handle error
    })

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Ends Collaborate mode in a meeting. Can be initiated by hosts or co-hosts.

    zoomSdk.endCollaborate()
    .then(function(response) {}) // (host/cohost)
    .catch(function(error) {
    // handle error
    })

    Returns Promise<GeneralMessageResponse>

  • Leave Collaborate mode. Can be initiated by participants in a meeting who are currently in Collaborate mode.

    zoomSdk.leaveCollaborate()
    .then(function(response) {}) // (other participant)
    .catch(function(error) {
    // handle error
    })

    Returns Promise<GeneralMessageResponse>

  • Join Collaborate mode. Can be initiated by participants in a meeting when they are invited to collaborate.

    zoomSdk.joinCollaborate()
    .then(function(response) {}) // (other participant)
    .catch(function(error) {
    // handle error
    })

    Returns Promise<GeneralMessageResponse>

Managing Breakout Rooms Methods

  • Change breakout room settings.

    Note: Each parameter is optional. If the parameter is missing, the related setting is not changed.

    Response is a JSON object with information about the current configuration.

    Example

    {
    "allowParticipantsChooseRoom": true,
    "allowParticipantsReturnToMainSession": true,
    "automaticallyMoveParticipantsIntoRooms": true,
    "closeAfter": 1,
    "countDown": 60
    }

    Parameters

    Returns Promise<ConfigureBreakoutRoomsResponse>

  • List all breakout rooms. Owners get list of rooms and participants for each breakout room. Co-hosts and participants get only list of rooms. The method works for participants only when breakout rooms are open.

    Example payload

    {
    rooms: [{
    breakoutRoomId: "room uuid",
    name: "room name",
    participants: [{
    participantId,
    displayName,
    participantStatus = ["assigned"|"joined"]
    }, …],
    state = [“open”|”closed”],
    unassigned: [{
    participantId,
    displayName
    }, …]
    }]
    }

    Returns an array of breakout rooms with their names, UUID, and an array of participant id's.

    Returns Promise<BreakoutRoomsResponse>

  • Add one more breakout room. This method is allowed only when breakout rooms are closed. Returns UUID of newly created breakout room.

    Parameters

    Returns Promise<Uuid>

  • Delete one breakout room. This method is allowed only when breakout rooms are closed.

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Assigns a participant to a breakout room (other than the host / co-host). Only one user assigned per call. For open breakout rooms, the method triggers a user flow to join the room.

    Note:

    • assignParticipantToBreakoutRoom cannot be executed while the current user is changing rooms.
    • To assign yourself (as host / co-host) to a breakout room, use method changeBreakoutRoom.

    Parameters

    Returns Promise<GeneralMessageResponse>

  • Called by a host / co-host / participant. Allows single participant user to join or leave a breakout room.

    Note:

    1. Rooms need to be open
    2. Room configuration should allow user to initiate the change
    3. This method returns success when changing breakout rooms is initiated, but the transition for the user might not be completed in some scenarios. Use onBreakoutRoomChange to confirm successful transition. If the event doesn’t fire, repeat changeBreakoutRoom call

    Parameters

    Returns Promise<GeneralMessageResponse>

Maintaining State Outside of a Meeting Methods

  • The API can only be called in meeting. Allows the App to communicate with the instance of the app running on the main client.

    await zoomSdk.connect()
    

    Returns Promise<GeneralMessageResponse>

  • Send a message with the current state of the mirrored app. The structure of the payload depends on the needs of the app.

    await zoomSdk.postMessage({ JSON })
    

    Parameters

    Returns Promise<GeneralMessageResponse>

  • endSyncData(): Promise<void>
  • Tells the client to end the data communication between connected apps. Note that the client will close the connection between the apps when endSyncData is called or 10 seconds after the onMeeting event with event.action == 'ended' is recieved, whichever comes first.

    await zoomSdk.endSyncData()
    

    Returns Promise<void>

Events Core Methods

  • This event occurs when the user clicks the share icon from the Zoom App sidebar during a meeting, and when the user stops the share.

    Supports Guest Mode = Yes

    Parameters

    Returns void

  • This event occurs when the user clicks the invite icon from the Zoom App sidebar during a meeting. All attendees and participants receive an invitation. The sender receives an event.

    Parameters

    Returns void

  • The cloud recording events occur when a user starts, pauses, stops or resumes recording a Zoom meeting (where your app is being run) to the cloud using the Zoom UI or programmatically using the JS APIs. Additionally, the "connecting" event action will be trigered prior to the start of a cloud recording.

    Parameters

    Returns void

  • This event occurs when a meeting participant sends a reaction.

    Role-based permissions This event is only available to an app instance being run by a Meeting Owner.

    Parameters

    Returns void

  • This event is triggered when a user joins or leaves a meeting or when a participant's role changes for that meeting.

    Note The event triggers twice in some situations, such as when a participant leaves a meeting with one role and rejoins the meeting with a new role. The participantId of the user might change when the role changes.

    Role-based permissions This event is only available to an app instance being run by a Meeting Owner.

    Parameters

    Returns void

  • This event occurs when the active speaker changes in a meeting.

    Role-based permissions This event is only available to an app instance being run by a Meeting Owner.

    Parameters

    Returns void

  • This event is triggered when the current user’s role changes.

    onMyUserContextChange is be available to apps regardless of whether the app user is an owner, host or attendee in a meeting, but would only provide data for the user that’s running the app (and not the other participants in the meeting).

    IMPORTANT: Some changes to user context (for example, change to status following onMyUserContextChange), will require the application to configure again, by invoking config once more.

    Supports Guest Mode = Yes

    Parameters

    Returns void

  • Notifies the app when the current user's video settings change, when it’s toggled on or off, and when the audio is muted or unmuted.

    For example, when the user chooses a different camera, mutes or unmutes their primary audio, or toggles: "Original ratio", "HD" in video settings, or primary camera on or off.

    Supports Guest Mode = Yes

    Parameters

    Returns void

  • The event triggers when the user closes the app for participants. It is only triggered for the user who performed the action. Example: The host uses an app to poll participants. When the host closes the app for participants, the app displays the results.

    Usage:

    zoomSdk.onCloseAppForParticipants((event) => {
    console.log(event)
    });
    • everyone: App closes for all users, including the current user.
    • attendees: App closes for only attendees.
    • everyoneButMe: App closes for everyone except the current user.

    Parameters

    Returns void

Events Managing Collaborations Methods

  • The event is triggered when changes such as start, end, leave or join happen in Collaborate mode. This method informs the app when the host or co-hosts start or end a collaboration, and when meeting participants leave or join a collaboration.

    The event is applicable to users based on their role in the meeting. For participants, the join and leave actions will apply. For hosts and co hosts, the start and end actions will apply. The event does not provide detailed information about the specific change, so the app needs to make an additional API request to retrieve the updated data.

    Parameters

    Returns void

Events Managing Breakout Rooms Methods

  • The event is triggered when any change happens to breakout rooms configuration. This method informs the app when the host changes the configuration manually, or when another app changes the configuration.

    The event does not provide detailed information about the specific change, so the app needs to make an additional API request to retrieve the updated data.

    Supports Guest Mode = Yes

    Parameters

    Returns void

Events maintaining state outside of a meeting Methods

  • In order to maintain state after a meeting, the instance of the app that is running in the meeting must communicate with the instance of the app running in the main client. The following events facilitate that process. For more information, see an example of this process.

    Notify the event listener when the API call connect has finished attempting to connect to the app instance running in the main client. This event can only be received in meeting.

    Parameters

    Returns void

  • In order to maintain state after a meeting, the instance of the app that is running in the meeting must communicate with the instance of the app running in the main client. The following events facilitate that process. For more information, see an example of this process.

    Receive a sent message from the mirrored app. The structure of the payload depends on the needs of the app.

    Parameters

    Returns void

  • In order to maintain state after a meeting, the instance of the app that is running in the meeting must communicate with the instance of the app running in the main client. The following events facilitate that process. For more information, see an example of this process.

    Meeting is closed, then notify the mirrored app and update state one more time.

    Parameters

    Returns void

Generated using TypeDoc