Suggest Edits

Introduction

 

The Zoom API provides the ability for developers to add Video and Voice easily, and Screen Sharing to your application. Our API is a server-side implementation designed around REST; it does not support cross-origin resource sharing or access via a client-side web application.

The Zoom API helps manage the pre-meeting experience such as creating, editing and deleting resources like users, meetings, and webinars. It also provides access to post-meeting information for tasks such as reporting and analytics. It does not provide access to the in-meeting experience such as current attendee list, who is the current speaker or ability to mute participants; if you seek these features, please have a look at our SDKs.

If you are looking to test our v2 APIs using POSTMAN, please check out using Postman.

 
https://api.zoom.us/v2/

The Zoom API endpoint is pretty straight forward. We require that you send all requests via https, requests sent to HTTP will receive a 302 HTTP response code. The base URL is api.zoom.us followed by the version number of the API, currently at version 2.

API version 1

V1 of our API is sunset. We will continue to support it till Dec 2018, but the support will be discontinued from January 2019. We strongly recommend that you plan for migration to v2 in the coming months if you are still on our version 1 of our APIs.

 

Webhooks can be used as notifications to keep your systems in sync with actions inside Zoom. Find more information about webhooks on the Developer Portal

Suggest Edits

Authentication

 

Zoom API version 2 implements either OAuth or JSON Web Tokens (JWT) for authentication. It is recommended that you use OAuth, but if you are already using our APIs with JWT, we suggest that you use one of the existing JWT libraries to generate the token.

You can pass the token to the API either in the HTTP Authorization Header using ‘Bearer’ or via Query Parameter in your API call as ‘access_token.’

Suggest Edits

Generating Token using JWT

 

You can find more details and specifics about JWT at jwt.io, below is and example of the minimum properties needed for the Zoom API.

Header

alg refers to the algorithm being used; Zoom API uses HMAC SHA256 (HS256 for short)
typ refers to the type of token, always JWT

{
    "alg": "HS256",
    "typ": "JWT"
}  

Payload

iss is the issuer of the token; this is your Zoom API Key
exp is the expiration timestamp of the token. It is recommended to use one of the JWT libraries to generate your tokens and to set this timestamp for a short period (like seconds), that way if someone intercepts your token it won’t be valid for very long.

Signature

To the right you’ll find an example algorithm for generating a signature, again highly recommend using a library to do this for you

HMACSHA256(
    base64UrlEncode(header) + "." +
    base64UrlEncode(payload),
    api_secret)
 

The below examples are written in NodeJS and PHP and utilizes the Firebase JWT Library installed via Composer. However the concept and idea can be ported to any language and workflow, and you can find libraries for your specific language on jwt.io

The key thing to understand is that the JWT token isn’t static and that it is generated each time you make a request. This makes it unique and more secure; if somehow your token is intercepted it won’t be good for long (as in this example 60 seconds)

const jwt = require('jsonwebtoken');
const config = require('./config');
const rp = require('request-promise');

const payload = {
    iss: config.APIKey,
    exp: ((new Date()).getTime() + 5000)
};

//Automatically creates header, and returns JWT
const token = jwt.sign(payload, config.APISecret);


var options = {
    uri: 'https://api.zoom.us/v2/users',
    qs: {
        status: 'active' // -> uri + '?status=active'
    },
    auth: {
    		'bearer': token
  	},
    headers: {
        'User-Agent': 'Zoom-Jwt-Request',
        'content-type': 'application/json'
    },
    json: true // Automatically parses the JSON string in the response
};

rp(options)
    .then(function (response) {
        console.log('User has', response);
    })
    .catch(function (err) {
        // API call failed...
        console.log('API call failed, reason ', err);
    });
<?php

//using composer
require __DIR__ . '/vendor/autoload.php';

// JWT PHP Library https://github.com/firebase/php-jwt
use \Firebase\JWT\JWT;

//function to generate JWT
function generateJWT () {
  
	//Zoom API credentials from https://developer.zoom.us/me/
	$key = '<zoom_api_key>';
	$secret = '<zoom_api_secret>';
  
	$token = array(
		"iss" => $key,
        // The benefit of JWT is expiry tokens, we'll set this one to expire in 1 minute
    
		"exp" => time() + 60
	);
	return JWT::encode($token, $secret);
}

function getUsers () {
    //list users endpoint GET https://api.zoom.us/v2/users
  
	$ch = curl_init('https://api.zoom.us/v2/users');
	curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  
    // add token to the authorization header
	curl_setopt($ch, CURLOPT_HTTPHEADER, array(
		'Authorization: Bearer ' . generateJWT()
	));
  
	$response = curl_exec($ch);
	$response = json_decode($response);
	return $response;
}

var_dump(getUsers());

The Zoom API uses HTTP Status codes to reflect a successful or error requests. 2XX status codes represent a successful request, 4XX/5XX status codes represent an error took place. If you receive an error HTTP status code, check the body for an error code and message.

Status Code
Description
Most Likely Cause

2XX

Successful Request

400

Bad Request

Invalid/missing data

401

Unauthorized

Invalid/missing credentials

404

Not Found

The resource dosen’t exists, ex. invalid/non-existent user id

409

Conflict

Trying to overwrite a resource, ex. when creating a user with an email that already exists

429

Too Many Requests

Hit an API rate limit

Error response example

{
"code" : 300,
"message" : "Request Body should be a valid JSON object."
}

Error response when sending invalid fields

{
"code": 300,
"message": "Validation Failed.",
"errors": [
{
"field": "user_info.email",
"message": "Invalid field."
},
{
"field": "user_info.type",
"message": "Invalid field."
}
]
}

Suggest Edits

Rate Limits

 

To preserve the integrity and reliability of the platform, our APIs have the following rate limits.

Suggest Edits

All API Endpoints

 

You can run a max of ten requests per second (10 requests/second) unless otherwise noted below.

Suggest Edits

Billing APIs

 

You can run a max of one request per second (1 request/second) on the following:

/v2/*/billing/*
/v2/*/plan/*
/v2/*/metrics/* (excluding /meetings and /webinars)
Suggest Edits

Report & Metric APIs

 

You can run a max of one request per second (1 request/second) and a max of two thousand requests per day (2000 requests/day) on the following:

/v2/metrics/meetings
/v2/metrics/webinars
/v2/report/*
 
Suggest Edits

List sub accounts

List all the sub accounts under the master account

 
gethttps://api.zoom.us/v2/accounts
curl --request GET \
  --url https://api.zoom.us/v2/accounts \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/accounts',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/accounts");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "page_count": "integer",
  "page_number": "integer",
  "page_size": "integer",
  "total_records": "integer",
  "accounts": [
    {
      "id": "string [uuid]",
      "account_name": "string",
      "owner_email": "string",
      "account_type": "string",
      "seats": "integer",
      "subscription_start_time": "string [date-time]",
      "subscription_end_time": "string [date-time]",
      "created_at": "string [date-time]"
    }
  ]
}

Query Params

page_size
int32

The number of records returned within a single API call

page_number
int32

Current page number of returned records

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Create a sub account

Create a sub account under the master account. <aside>Your account must be a master account and have this privilege to create sub account. Zoom only assigns this privilege to trusted partners. The created user will not receive a confirmation email.</aside>.

 
posthttps://api.zoom.us/v2/accounts
curl --request POST \
  --url https://api.zoom.us/v2/accounts
var request = require("request");

var options = { method: 'POST', url: 'https://api.zoom.us/v2/accounts' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.zoom.us/v2/accounts");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "id": "string",
  "owner_id": "string",
  "owner_email": "string",
  "created_at": "string"
}

Body Params

first_name
string
required

User’s first name

last_name
string
required

User’s last name

email
string
required

User’s email address

password
string
required

User’s password

options
object
options.share_rc
string

Enable Share Virtual Room Connector

options.room_connectors
string

Virtual Room Connector, multiple value separated by comma

options.share_mc
string

Enable Share Meeting Connector

options.meeting_connectors
string

Meeting Connector, multiple values separated by comma

options.pay_mode
string

Payee
master Master account holder pays
sub Sub account holder pays

Response

Suggest Edits

Retrieve a sub account

Retrieve a sub account under the master account. <aside>Your account must be a master account and have this privilege to read sub accounts. Zoom only assigns this privilege to trusted partners</aside>.

 
gethttps://api.zoom.us/v2/accounts/accountId
curl --request GET \
  --url https://api.zoom.us/v2/accounts/accountId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/accounts/accountId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/accounts/accountId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "page_count": "integer",
  "page_number": "integer",
  "page_size": "integer",
  "total_records": "integer",
  "accounts": [
    {
      "id": "string [uuid]",
      "account_name": "string",
      "owner_email": "string",
      "account_type": "string",
      "seats": "integer",
      "subscription_start_time": "string [date-time]",
      "subscription_end_time": "string [date-time]",
      "created_at": "string [date-time]"
    }
  ]
}

Path Params

accountId
string
required

The account ID

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Disassociate an account

Disassociate a sub account from the master account. This will leave the account intact but the sub account will not longer be associated with the master account.

 
deletehttps://api.zoom.us/v2/accounts/accountId
curl --request DELETE \
  --url https://api.zoom.us/v2/accounts/accountId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/accounts/accountId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/accounts/accountId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

accountId
string
required

The account ID

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Update a sub account's options

Update a sub account's options under the master account

 
patchhttps://api.zoom.us/v2/accounts/accountId/options
curl --request PATCH \
  --url https://api.zoom.us/v2/accounts/accountId/options \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PATCH',
  url: 'https://api.zoom.us/v2/accounts/accountId/options',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId/options")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PATCH", "https://api.zoom.us/v2/accounts/accountId/options");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId/options"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PATCH", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

accountId
string
required

The account ID

Body Params

share_rc
string

Enable Share Virtual Room Connector

room_connectors
string

Virtual Room Connector, multiple value separated by comma

share_mc
string

Enable Share Meeting Connector

meeting_connectors
string

Meeting Connector, multiple values separated by comma

pay_mode
string

Payee
master Master account holder pays
sub Sub account holder pays

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Retrieve a sub account's settings

Retrieve a sub account's settings under the master account

 
gethttps://api.zoom.us/v2/accounts/accountId/settings
curl --request GET \
  --url https://api.zoom.us/v2/accounts/accountId/settings \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/accounts/accountId/settings',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId/settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/accounts/accountId/settings");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId/settings"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "schedule_meting": {
    "host_video": "boolean",
    "participant_video": "boolean",
    "audio_type": "string",
    "join_before_host": "boolean",
    "enforce_login": "boolean",
    "enforce_login_with_domains": "boolean",
    "enforce_login_domains": "string",
    "not_store_meeting_topic": "boolean",
    "force_pmi_jbh_password": "boolean"
  },
  "in_meeting": {
    "e2e_encryption": "boolean",
    "chat": "boolean",
    "private_chat": "boolean",
    "auto_saving_chat": "boolean",
    "file_transfer": "boolean",
    "feedback": "boolean",
    "post_meeting_feedback": "boolean",
    "co_host": "boolean",
    "polling": "boolean",
    "attendee_on_hold": "boolean",
    "show_meeting_control_toolbar": "boolean",
    "allow_show_zoom_windows": "boolean",
    "annotation": "boolean",
    "whiteboard": "boolean",
    "webinar_question_answer": "boolean",
    "anonymous_question_answer": "boolean",
    "breakout_room": "boolean",
    "closed_caption": "boolean",
    "far_end_camera_control": "boolean",
    "group_hd": "boolean",
    "virtual_background": "boolean",
    "watermark": "boolean",
    "alert_guest_join": "boolean",
    "auto_answer": "boolean",
    "p2p_connetion": "boolean",
    "p2p_ports": "boolean",
    "ports_range": "string",
    "sending_default_email_invites": "boolean",
    "use_html_format_email": "boolean",
    "dscp_marking": "boolean",
    "dscp_audio": "integer",
    "dscp_video": "integer",
    "stereo_audio": "boolean",
    "original_audio": "boolean",
    "screen_sharing": "boolean",
    "remote_control": "boolean",
    "attention_tracking": "boolean"
  },
  "email_notification": {
    "cloud_recording_avaliable_reminder": "boolean",
    "jbh_reminder": "boolean",
    "cancel_meeting_reminder": "boolean",
    "low_host_count_reminder": "boolean",
    "alternative_host_reminder": "boolean"
  },
  "zoom_rooms": {
    "upcoming_meeting_alert": "boolean",
    "start_airplay_manually": "boolean",
    "weekly_system_restart": "boolean",
    "list_meetings_with_calendar": "boolean",
    "zr_post_meeting_feedback": "boolean",
    "ultrasonic": "boolean",
    "force_private_meeting": "boolean",
    "hide_host_information": "boolean",
    "cmr_for_instant_meeting": "boolean",
    "auto_start_stop_scheduled_meetings": "boolean"
  },
  "security": {
    "admin_change_name_pic": "boolean",
    "import_photos_from_devices": "boolean",
    "hide_billing_info": "boolean"
  },
  "recording": {
    "local_recording": "boolean",
    "cloud_recording": "boolean",
    "record_speaker_view": "boolean",
    "record_gallery_view": "boolean",
    "record_audio_file": "boolean",
    "save_chat_text": "boolean",
    "show_timestamp": "boolean",
    "recording_audio_transcript": "boolean",
    "auto_recording": "string",
    "cloud_recording_download": "boolean",
    "cloud_recording_download_host": "boolean",
    "account_user_access_recording": "boolean",
    "auto_delete_cmr": "boolean",
    "auto_delete_cmr_days": "integer"
  },
  "telephony": {
    "third_party_audio": "boolean",
    "audio_conference_info": "string"
  },
  "integration": {
    "google_calendar": "boolean",
    "google_drive": "boolean",
    "dropbox": "boolean",
    "box": "boolean",
    "microsoft_one_drive": "boolean",
    "kubi": "boolean"
  },
  "feature": {
    "meeting_capacity": "integer"
  }
}

Path Params

accountId
string
required

The account ID

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Update a sub account's settings

Update a sub account's settings under the master account

 
patchhttps://api.zoom.us/v2/accounts/accountId/settings
curl --request PATCH \
  --url https://api.zoom.us/v2/accounts/accountId/settings \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PATCH',
  url: 'https://api.zoom.us/v2/accounts/accountId/settings',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId/settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PATCH", "https://api.zoom.us/v2/accounts/accountId/settings");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId/settings"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PATCH", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

accountId
string
required

The account ID

Body Params

schedule_meting
object
schedule_meting.enforce_login_domains
string

Start meetings with host video on.

schedule_meting.participant_video
string

Start meetings with participant video on. Participants can change this during the meeting.

schedule_meting.audio_type
string

Determine how participants can join the audio portion of the meeting
both Telephony and VoIP
telephony Audio PSTN telephony only
voip VoIP only
thirdParty 3rd party audio conference

schedule_meting.join_before_host
string

Allow participants to join the meeting before the host starts the meeting. Only used for scheduled or recurring meetings.

schedule_meting.enforce_login
string

Only signed-in users can join this meeting.

schedule_meting.enforce_login_with_domains
string
schedule_meting.not_store_meeting_topic
string

Always display “Zoom Meeting” as the meeting topic.

schedule_meting.force_pmi_jbh_password
string

Require a password for Personal Meetings if attendees can join before host.

in_meeting
object
in_meeting.e2e_encryption
string

Require that all meetings are encrypted using AES.

in_meeting.chat
string

Allow meeting participants to send a message visible to all participants.

in_meeting.private_chat
string

Allow meeting participants to send a private 1:1 message to another participants.

in_meeting.auto_saving_chat
string

Automatically save all in-meeting chats so that hosts do not need to manually save the text of the chat after the meeting starts.

in_meeting.file_transfer
string

Hosts and participants can send files through the in-meeting chat.

in_meeting.feedback
string

Add a Feedback tab to the Windows Settings or Mac Preferences dialog, and also enable users to provide feedback to Zoom at the end of the meeting.

in_meeting.post_meeting_feedback
string

Display a thumbs up/down survey at the end of each meeting.

in_meeting.co_host
string

Allow the host to add co-hosts.

in_meeting.polling
string

Add ‘Polls’ to the meeting controls.

in_meeting.attendee_on_hold
string

Allow hosts to temporarily remove an attendee from the meeting.

in_meeting.show_meeting_control_toolbar
string

Always show meeting control toolbar.

in_meeting.allow_show_zoom_windows
string

Show Zoom Desktop application when sharing screen.

in_meeting.annotation
string

Allow participants to use annotation tools to add information to shared screens.

in_meeting.whiteboard
string

Allow participants to share a whiteboard that includes annotation tools.

in_meeting.webinar_question_answer
string

Q&A in webinar.

in_meeting.anonymous_question_answer
string

Allow Anonymous Q&A in Webinar.

in_meeting.breakout_room
string

Allow host to split meeting participants into separate, smaller rooms.

in_meeting.closed_caption
string

Allow host to type closed captions or assign a participant/third party device to add closed captions.

in_meeting.far_end_camera_control
string

Allow another user to take control of your camera during a meeting.

in_meeting.group_hd
string

Activate higher quality video for host and participants. (This will use more bandwidth.)

in_meeting.virtual_background
string

Allow users to replace their background with any selected image. Choose or upload an image in the Zoom Desktop application settings.

in_meeting.watermark
string

Add watermark when viewing shared screen.

in_meeting.alert_guest_join
string

Identify guest participants in the meeting/webinar.

in_meeting.auto_answer
string

Enable users to see and add contacts to ‘auto-answer group’ in the contact list on chat. Any call from members of this group will be automatically answered.

in_meeting.p2p_connetion
string

Peer to Peer connection while only 2 people are in a meeting.

in_meeting.p2p_ports
string

P2P listening ports range.

in_meeting.ports_range
string

Listening ports range, separated by comma (ex 55,56). The ports range must be between 1 to 65535.

in_meeting.sending_default_email_invites
string

Only show default email when sending email invites.

in_meeting.use_html_format_email
string

Use HTML format email for Outlook plugin.

in_meeting.dscp_marking
string

DSCP marking.

in_meeting.dscp_audio
string
in_meeting.dscp_video
string
in_meeting.stereo_audio
string

Allow users to select stereo audio in their client settings.

in_meeting.original_audio
string

Allow users to select original sound in their client settings.

in_meeting.screen_sharing
string

Allow screen sharing.

in_meeting.remote_control
string

Allow users to request remote control.

in_meeting.attention_tracking
string

Lets the host see an indicator in the participant panel if a meeting/webinar attendee does not have Zoom in focus during screen sharing.

email_notification
object
email_notification.cloud_recording_avaliable_reminder
string

Notify host when cloud recording is available.

email_notification.jbh_reminder
string

Notify host when participants join the meeting before them.

email_notification.cancel_meeting_reminder
string

Notify host and participants when the meeting is cancelled.

email_notification.low_host_count_reminder
string

Notify when host licenses are running low.

email_notification.alternative_host_reminder
string

Notify when an alternative host is set or removed from a meeting.

zoom_rooms
object
zoom_rooms.upcoming_meeting_alert
string

Upcoming meeting alert.

zoom_rooms.start_airplay_manually
string

Start AirPlay service manually.

zoom_rooms.weekly_system_restart
string

Weekly system restart.

zoom_rooms.list_meetings_with_calendar
string

Display meeting list with calendar integration.

zoom_rooms.zr_post_meeting_feedback
string

Zoom Room post meeting feedback.

zoom_rooms.ultrasonic
string

Automatic direct sharing using ultrasonic proximity signal.

zoom_rooms.force_private_meeting
string

Transform all meetings to private.

zoom_rooms.hide_host_information
string

Hide host and meeting ID from private meetings.

zoom_rooms.cmr_for_instant_meeting
string

Cloud recording for instant meetings.

zoom_rooms.auto_start_stop_scheduled_meetings
string

Automatic start/stop for scheduled meetings.

security
object
security.admin_change_name_pic
string
required

Only account administrators can change user’s username and picture.

security.import_photos_from_devices
string
required

Allow importing of photos from photo library on the user’s device.

security.hide_billing_info
string
required

Hide billing information.

recording
object
recording.local_recording
string

Allow hosts and participants to record the meeting to a local file.

recording.cloud_recording
string

Allow hosts to record and save the meeting in the cloud.

recording.record_speaker_view
string

Record active speaker with shared screen.

recording.record_gallery_view
string

Record gallery view with shared screen.

recording.record_audio_file
string

Record an audio only file.

recording.save_chat_text
string

Save chat text from the meeting.

recording.show_timestamp
string

Add a timestamp to the recording.

recording.recording_audio_transcript
string

Automatically transcribe the audio of the meeting or webinar to the cloud.

recording.auto_recording
string

Record meetings automatically as they start
local Record on local
cloud Record on cloud
none Disabled.

recording.cloud_recording_download
string

Cloud Recording Downloads

recording.cloud_recording_download_host
string

Only the host can download cloud recordings.

recording.account_user_access_recording
string

Cloud recordings are only accessible to account members. People outside of your organization cannot open links that provide access to cloud recordings.

recording.auto_delete_cmr
string

Allow Zoom to automatically delete recordings permanently after a specified number of days.

recording.auto_delete_cmr_days
string

When auto_delete_cmr is ‘true’ this value will set the number of days before auto deletion of cloud recordings.

telephony
object
telephony.third_party_audio
string

Users can join the meeting using the existing 3rd party audio configuration.

telephony.audio_conference_info
string

3rd party audio conference info.

integration
object
integration.google_calendar
string

Enables meetings to be scheduled using Google Calendars.

integration.google_drive
string

Enables users who join a meeting from their mobile device to share content from their Google Drive.

integration.dropbox
string

Enables users who join a meeting from their mobile device to share content from their Dropbox account.

integration.box
string
integration.microsoft_one_drive
string

Enables users who join a meeting from their mobile device to share content from their Microsoft OneDrive account.

integration.kubi
string

Enables users to control a connected Kubi device from within a Zoom meeting.

feature
object
feature.meeting_capacity
string

Set the maximum number of participants this user can have in a single meeting.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

 
Suggest Edits

Retrieve billing information for a sub account

Retrieve billing information for a sub account under the master account

 
gethttps://api.zoom.us/v2/accounts/accountId/billing
curl --request GET \
  --url https://api.zoom.us/v2/accounts/accountId/billing \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/accounts/accountId/billing',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId/billing")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/accounts/accountId/billing");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId/billing"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "first_name": "string",
  "last_name": "string",
  "email": "string",
  "phone_number": "string",
  "address": "string",
  "apt": "string",
  "city": "string",
  "state": "string",
  "zip": "string",
  "country": "string"
}

Path Params

accountId
string
required

The account ID

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Update billing information for a sub account

Update billing information for a sub account under the master account <aside>Only for the sub account which is a paid account and paid by master account</aside>

 
patchhttps://api.zoom.us/v2/accounts/accountId/billing
curl --request PATCH \
  --url https://api.zoom.us/v2/accounts/accountId/billing \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PATCH',
  url: 'https://api.zoom.us/v2/accounts/accountId/billing',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId/billing")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PATCH", "https://api.zoom.us/v2/accounts/accountId/billing");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId/billing"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PATCH", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

accountId
string
required

The account ID

Body Params

first_name
string

User's first name.

last_name
string

User's last name.

email
string

User's email address.

phone_number
string

User's phone number.

address
string

User's address.

apt
string

User's apartment/suite.

city
string

User's city.

state
string

User's state.

zip
string

User's zip code.

country
string

User's country.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Retrieve plan information for a sub account

Retrieve plan information for a sub account under the master account <aside>Only for the sub account which is paid by master account</aside>

 
gethttps://api.zoom.us/v2/accounts/accountId/plans
curl --request GET \
  --url https://api.zoom.us/v2/accounts/accountId/plans \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/accounts/accountId/plans',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId/plans")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/accounts/accountId/plans");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId/plans"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "plan_base": {
    "type": "string",
    "hosts": "integer"
  },
  "plan_zoom_rooms": {
    "type": "string",
    "hosts": "integer"
  },
  "plan_room_connector": {
    "type": "string",
    "hosts": "integer"
  },
  "plan_large_meeting": [
    {
      "type": "string",
      "hosts": "integer"
    }
  ],
  "plan_webinar": [
    {
      "type": "string",
      "hosts": "integer"
    }
  ],
  "plan_recording": "string",
  "plan_audio": {
    "type": "string",
    "tollfree_countries": "string",
    "premium_countries": "string",
    "callout_countries": "string",
    "ddi_numbers": "integer"
  }
}

Path Params

accountId
string
required

The account ID

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Subscribe plans for a sub account

Subscribe plans for a sub account of the master account <aside>Can only subscribe plans for the sub account which is a free account and paid by master account</aside>

 
posthttps://api.zoom.us/v2/accounts/accountId/plans
curl --request POST \
  --url https://api.zoom.us/v2/accounts/accountId/plans \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.zoom.us/v2/accounts/accountId/plans',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId/plans")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.zoom.us/v2/accounts/accountId/plans");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId/plans"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "plan_base": {
    "type": "string",
    "hosts": "integer"
  },
  "plan_zoom_rooms": {
    "type": "string",
    "hosts": "integer"
  },
  "plan_room_connector": {
    "type": "string",
    "hosts": "integer"
  },
  "plan_large_meeting": [
    {
      "type": "string",
      "hosts": "integer"
    }
  ],
  "plan_webinar": [
    {
      "type": "string",
      "hosts": "integer"
    }
  ],
  "plan_recording": "string",
  "plan_audio": {
    "type": "string",
    "tollfree_countries": "string",
    "premium_countries": "string",
    "callout_countries": "string",
    "ddi_numbers": "integer"
  }
}

Path Params

accountId
string
required

The account ID

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Created

Suggest Edits

Update a base plan for a sub account

Update a base plan for a sub account <aside>Can only update a base plan for the sub account which is a paid account and paid by master account</aside>

 
puthttps://api.zoom.us/v2/accounts/accountId/plans/base
curl --request PUT \
  --url https://api.zoom.us/v2/accounts/accountId/plans/base \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.zoom.us/v2/accounts/accountId/plans/base',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId/plans/base")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.zoom.us/v2/accounts/accountId/plans/base");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId/plans/base"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PUT", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

accountId
string
required

The account ID

Body Params

type
string
required
hosts
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Update an additional plan for sub account

Update an additional plan for sub account<aside>Can only update an Additional plan for the sub account which is a paid account and paid by master account</aside>

 
puthttps://api.zoom.us/v2/accounts/accountId/plans/addons
curl --request PUT \
  --url https://api.zoom.us/v2/accounts/accountId/plans/addons \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.zoom.us/v2/accounts/accountId/plans/addons',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId/plans/addons")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.zoom.us/v2/accounts/accountId/plans/addons");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId/plans/addons"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PUT", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Path Params

accountId
string
required

The account ID

Body Params

type
string
required
hosts
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Created

Suggest Edits

Add an additional plan for sub account

Add an additional plan for sub account <aside>Can only add an Additional plan for the sub account which is a paid account and paid by master account</aside>

 
posthttps://api.zoom.us/v2/accounts/accountId/plans/addons
curl --request POST \
  --url https://api.zoom.us/v2/accounts/accountId/plans/addons \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.zoom.us/v2/accounts/accountId/plans/addons',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/accounts/accountId/plans/addons")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.zoom.us/v2/accounts/accountId/plans/addons");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/accounts/accountId/plans/addons"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

accountId
string
required

The account ID

Body Params

type
string
required
hosts
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

List Users

List users on your account

 
gethttps://api.zoom.us/v2/users
curl --request GET \
  --url https://api.zoom.us/v2/users \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "page_count": "integer",
  "page_number": "integer",
  "page_size": "integer",
  "total_records": "integer",
  "users": [
    {
      "id": "string",
      "first_name": "string",
      "last_name": "string",
      "email": "string",
      "type": "integer",
      "pmi": "string",
      "timezone": "string",
      "dept": "string",
      "created_at": "string [date-time]",
      "last_login_time": "string [date-time]",
      "last_client_version": "string",
      "group_ids": [
        "string"
      ],
      "im_group_ids": [
        "string"
      ]
    }
  ]
}

Query Params

status
string

User status

page_size
int32

The number of records returned within a single API call

page_number
int32

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Create a user

Create a user on your account

 
posthttps://api.zoom.us/v2/users
curl --request POST \
  --url https://api.zoom.us/v2/users \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.zoom.us/v2/users',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.zoom.us/v2/users");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "id": "string",
  "first_name": "string",
  "last_name": "string",
  "email": "string",
  "type": "integer"
}

Body Params

action
string
required
user_info
object
user_info.email
string
required

User's email address.

user_info.type
string
required
user_info.first_name
string

User's first name.

user_info.last_name
string

User's last name.

user_info.password
string

Sets password.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Suggest Edits

Retrieve a user

Retrieve a user on your account

 
gethttps://api.zoom.us/v2/users/userId
curl --request GET \
  --url https://api.zoom.us/v2/users/userId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users/userId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users/userId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "id": "string",
  "first_name": "string",
  "last_name": "string",
  "email": "string",
  "type": "integer",
  "pmi": "string",
  "timezone": "string",
  "dept": "string",
  "created_at": "string [date-time]",
  "last_login_time": "string [date-time]",
  "last_client_version": "string",
  "vanity_url": "string",
  "verified": "integer",
  "pic_url": "string",
  "cms_user_id": "string",
  "account_id": "string",
  "host_key": "string",
  "group_ids": [
    "string"
  ],
  "im_group_ids": [
    "string"
  ]
}

Path Params

userId
string
required

Unique user ID.

Query Params

login_type
string

0 Facebook
1 Google
99 API
100 Zoom
101 SSO

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Delete a user

Delete a user on your account

 
deletehttps://api.zoom.us/v2/users/userId
curl --request DELETE \
  --url https://api.zoom.us/v2/users/userId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/users/userId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/users/userId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

userId
string
required

Unique user ID.

Query Params

action
string
transfer_email
string
transfer_meeting
string
transfer_webinar
string
transfer_recording
string

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Update a user

Update a user on your account

 
patchhttps://api.zoom.us/v2/users/userId
curl --request PATCH \
  --url https://api.zoom.us/v2/users/userId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PATCH',
  url: 'https://api.zoom.us/v2/users/userId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PATCH", "https://api.zoom.us/v2/users/userId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PATCH", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

userId
string
required

Unique user ID.

Body Params

first_name
string

User's first name.

last_name
string

User's last name.

type
string
pmi
string
timezone
string

Timezone to format start_time. For example, “America/Los_Angeles”. For scheduled meetings only. Please reference our timezone list for supported timezones and their formats.

dept
string
vanity_name
string
host_key
string
cms_user_id
string

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

List a user's assistants

List a user's assistants

 
gethttps://api.zoom.us/v2/users/userId/assistants
curl --request GET \
  --url https://api.zoom.us/v2/users/userId/assistants \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users/userId/assistants',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/assistants")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users/userId/assistants");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/assistants"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "assistants": [
    {
      "id": "string",
      "email": "string"
    }
  ]
}

Path Params

userId
string
required

Unique user ID.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Add assistants

Add assistants to a user

 
posthttps://api.zoom.us/v2/users/userId/assistants
curl --request POST \
  --url https://api.zoom.us/v2/users/userId/assistants \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.zoom.us/v2/users/userId/assistants',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/assistants")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.zoom.us/v2/users/userId/assistants");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/assistants"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "ids": "string",
  "add_at": "string [date-time]"
}

Path Params

userId
string
required

Unique user ID.

Body Params

assistants
array of objects

List of User’s assistants.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Created

Suggest Edits

Delete a user's assistants

Delete all of a user'sassitants

 
deletehttps://api.zoom.us/v2/users/userId/assistants
curl --request DELETE \
  --url https://api.zoom.us/v2/users/userId/assistants \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/users/userId/assistants',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/assistants")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/users/userId/assistants");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/assistants"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

userId
string
required

Unique user ID.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Delete a user's assistant

Delete one of a user's assistants

 
deletehttps://api.zoom.us/v2/users/userId/assistants/assistantId
curl --request DELETE \
  --url https://api.zoom.us/v2/users/userId/assistants/assistantId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/users/userId/assistants/assistantId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/assistants/assistantId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/users/userId/assistants/assistantId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/assistants/assistantId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

userId
string
required

Unique user ID.

assistantId
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

List a user's schedulers

List a user's schedulers

 
gethttps://api.zoom.us/v2/users/userId/schedulers
curl --request GET \
  --url https://api.zoom.us/v2/users/userId/schedulers \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users/userId/schedulers',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/schedulers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users/userId/schedulers");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/schedulers"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "assistants": [
    {
      "id": "string",
      "email": "string"
    }
  ]
}

Path Params

userId
string
required

Unique user ID.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Delete a user's schedulers

Delete all of a user'schedulers

 
deletehttps://api.zoom.us/v2/users/userId/schedulers
curl --request DELETE \
  --url https://api.zoom.us/v2/users/userId/schedulers \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/users/userId/schedulers',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/schedulers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/users/userId/schedulers");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/schedulers"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

userId
string
required

Unique user ID.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Delete a user's scheduler

Delete one of a user's schedulers

 
deletehttps://api.zoom.us/v2/users/userId/schedulers/schedulerId
curl --request DELETE \
  --url https://api.zoom.us/v2/users/userId/schedulers/schedulerId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/users/userId/schedulers/schedulerId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/schedulers/schedulerId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/users/userId/schedulers/schedulerId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/schedulers/schedulerId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

userId
string
required

Unique user ID.

schedulerId
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Upload a user's picture

Upload a user's profile picture

 
posthttps://api.zoom.us/v2/users/userId/picture
curl --request POST \
  --url https://api.zoom.us/v2/users/userId/picture \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.zoom.us/v2/users/userId/picture',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/picture")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.zoom.us/v2/users/userId/picture");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/picture"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Path Params

userId
string
required

Unique user ID.

Form Data

pic_file
string

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Created

Suggest Edits

Retrieve a user's settings

Retrieve a user's settings

 
gethttps://api.zoom.us/v2/users/userId/settings
curl --request GET \
  --url https://api.zoom.us/v2/users/userId/settings \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users/userId/settings',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users/userId/settings");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/settings"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "scheduled_meeting": {
    "host_video": "boolean",
    "participants_video": "boolean",
    "audio_type": "string",
    "join_before_host": "boolean",
    "force_pmi_jbh_password": "boolean",
    "pstn_password_protected": "boolean"
  },
  "in_meeting": {
    "e2e_encryption": "boolean",
    "chat": "boolean",
    "private_chat": "boolean",
    "auto_saving_chat": "boolean",
    "entry_exit_chime": "string",
    "record_play_voice": "boolean",
    "file_transfer": "boolean",
    "feedback": "boolean",
    "co_host": "boolean",
    "polling": "boolean",
    "attendee_on_hold": "boolean",
    "annotation": "boolean",
    "remote_control": "boolean",
    "non_verbal_feedback": "boolean",
    "breakout_room": "boolean",
    "remote_support": "boolean",
    "closed_caption": "boolean",
    "group_hd": "boolean",
    "virtual_background": "boolean",
    "far_end_camera_control": "boolean",
    "share_dual_camera": "boolean",
    "attention_tracking": "boolean",
    "waiting_room": "boolean"
  },
  "email_notification": {
    "jbh_reminder": "boolean",
    "cancel_meeting_reminder": "boolean",
    "alternative_host_reminder": "boolean"
  },
  "recording": {
    "local_recording": "boolean",
    "cloud_recording": "boolean",
    "record_speaker_view": "boolean",
    "record_gallery_view": "boolean",
    "record_audio_file": "boolean",
    "save_chat_text": "boolean",
    "show_timestamp": "boolean",
    "recording_audio_transcript": "boolean",
    "auto_recording": "string",
    "auto_delete_cmr": "boolean",
    "auto_delete_cmr_days": "integer"
  },
  "telephony": {
    "third_party_audio": "boolean",
    "audio_conference_info": "string",
    "show_international_numbers_link": "boolean"
  },
  "feature": {
    "meeting_capacity": "integer",
    "large_meeting": "boolean",
    "large_meeting_capacity": "integer",
    "webinar": "boolean",
    "webinar_capacity": "integer",
    "cn_meeting": "boolean",
    "in_meeting": "boolean"
  }
}

Path Params

userId
string
required

Unique user ID.

Query Params

login_type
string

0 Facebook
1 Google
99 API
100 Zoom
101 SSO

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Update a user's settings

Update a user's settings

 
patchhttps://api.zoom.us/v2/users/userId/settings
curl --request PATCH \
  --url https://api.zoom.us/v2/users/userId/settings \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PATCH',
  url: 'https://api.zoom.us/v2/users/userId/settings',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PATCH", "https://api.zoom.us/v2/users/userId/settings");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/settings"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PATCH", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

userId
string
required

Unique user ID.

Body Params

scheduled_meeting
object
scheduled_meeting.enforce_login_domains
string

Start meetings with host video on.

scheduled_meeting.participants_video
string

Participants video.

scheduled_meeting.audio_type
string

Determine how participants can join the audio portion of the meeting
both Telephony and VoIP
telephony Audio PSTN telephony only
voip VoIP only
thirdParty 3rd party audio conference

scheduled_meeting.join_before_host
string

Allow participants to join the meeting before the host starts the meeting. Only used for scheduled or recurring meetings.

scheduled_meeting.force_pmi_jbh_password
string

Require a password for Personal Meetings if attendees can join before host.

scheduled_meeting.pstn_password_protected
string

Generate and require password for participants joining by phone.

in_meeting
object
in_meeting.e2e_encryption
string

Require that all meetings are encrypted using AES.

in_meeting.chat
string

Allow meeting participants to send a message visible to all participants.

in_meeting.private_chat
string

Allow meeting participants to send a private 1:1 message to another participants.

in_meeting.auto_saving_chat
string

Automatically save all in-meeting chats so that hosts do not need to manually save the text of the chat after the meeting starts.

in_meeting.entry_exit_chime
string

Play sound on join/leave
host when host joins/leaves
all when any participant joins/leaves
none no join/leave sound.

in_meeting.record_play_voice
string

Record and play their own voice.

in_meeting.file_transfer
string

Hosts and participants can send files through the in-meeting chat.

in_meeting.feedback
string

Add a Feedback tab to the Windows Settings or Mac Preferences dialog, and also enable users to provide feedback to Zoom at the end of the meeting.

in_meeting.co_host
string

Allow the host to add co-hosts.

in_meeting.polling
string

Add ‘Polls’ to the meeting controls.

in_meeting.attendee_on_hold
string

Allow hosts to temporarily remove an attendee from the meeting.

in_meeting.annotation
string

Allow participants to use annotation tools to add information to shared screens.

in_meeting.remote_control
string

Allow users to request remote control.

in_meeting.non_verbal_feedback
string

Non-verbal feedback.

in_meeting.breakout_room
string

Allow host to split meeting participants into separate, smaller rooms.

in_meeting.remote_support
string

Remote support.

in_meeting.closed_caption
string

Allow host to type closed captions or assign a participant/third party device to add closed captions.

in_meeting.group_hd
string

Activate higher quality video for host and participants. (This will use more bandwidth.)

in_meeting.virtual_background
string

Allow users to replace their background with any selected image. Choose or upload an image in the Zoom Desktop application settings.

in_meeting.far_end_camera_control
string

Allow another user to take control of your camera during a meeting.

in_meeting.share_dual_camera
string

Share dual camera. (Deprecated)

in_meeting.attention_tracking
string

Lets the host see an indicator in the participant panel if a meeting/webinar attendee does not have Zoom in focus during screen sharing.

in_meeting.waiting_room
string

Waiting room.

email_notification
object
email_notification.jbh_reminder
string

Notify host when participants join the meeting before them.

email_notification.cancel_meeting_reminder
string

Notify host and participants when the meeting is cancelled.

email_notification.alternative_host_reminder
string

Notify when an alternative host is set or removed from a meeting.

recording
object
recording.local_recording
string

Allow hosts and participants to record the meeting to a local file.

recording.cloud_recording
string

Allow hosts to record and save the meeting in the cloud.

recording.record_speaker_view
string

Record active speaker with shared screen.

recording.record_gallery_view
string

Record gallery view with shared screen.

recording.record_audio_file
string

Record an audio only file.

recording.save_chat_text
string

Save chat text from the meeting.

recording.show_timestamp
string

Add a timestamp to the recording.

recording.recording_audio_transcript
string

Automatically transcribe the audio of the meeting or webinar to the cloud.

recording.auto_recording
string

Record meetings automatically as they start
local Record on local
cloud Record on cloud
none Disabled.

recording.auto_delete_cmr
string

Allow Zoom to automatically delete recordings permanently after a specified number of days.

recording.auto_delete_cmr_days
string

When auto_delete_cmr is ‘true’ this value will set the number of days before auto deletion of cloud recordings.

telephony
object
telephony.third_party_audio
string

Users can join the meeting using the existing 3rd party audio configuration.

telephony.audio_conference_info
string

3rd party audio conference info.

telephony.show_international_numbers_link
string

Show international numbers link on the invitation email.

feature
object
feature.meeting_capacity
string

Set the maximum number of participants this user can have in a single meeting.

feature.large_meeting
string

Large meting feature.

feature.large_meeting_capacity
string

Large meeting capacity, can be 100, 200, 300 or 500, depends on if having related large meeting capacity plan subscription or not.

feature.webinar
string

Webinar feature.

feature.webinar_capacity
string

Webinar capacity, can be 100, 500, 1000, 3000, 5000 or 10000, depends on if having related webinar capacity plan subscription or not.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Update a user's status

Update a user's status

 
puthttps://api.zoom.us/v2/users/userId/status
curl --request PUT \
  --url https://api.zoom.us/v2/users/userId/status \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.zoom.us/v2/users/userId/status',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.zoom.us/v2/users/userId/status");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/status"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PUT", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

userId
string
required

Unique user ID.

Body Params

action
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Update a user's password

Update a user's password

 
puthttps://api.zoom.us/v2/users/userId/password
curl --request PUT \
  --url https://api.zoom.us/v2/users/userId/password \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.zoom.us/v2/users/userId/password',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/password")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.zoom.us/v2/users/userId/password");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/password"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PUT", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

userId
string
required

Unique user ID.

Body Params

password
string
required

Sets password.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Retrieve a user's permissions

Retrieve a user's permissions

 
gethttps://api.zoom.us/v2/users/userId/permissions
curl --request GET \
  --url https://api.zoom.us/v2/users/userId/permissions \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users/userId/permissions',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/permissions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users/userId/permissions");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/permissions"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "permissions": [
    "string"
  ]
}

Path Params

userId
string
required

Unique user ID.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Retrieve a user's token

Retrieve a user's token

 
gethttps://api.zoom.us/v2/users/userId/token
curl --request GET \
  --url https://api.zoom.us/v2/users/userId/token \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users/userId/token',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/token")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users/userId/token");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/token"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "token": "string"
}

Path Params

userId
string
required

Unique user ID.

Query Params

type
string

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Revoke a user's SSO token

Revoke a user's SSO token

 
deletehttps://api.zoom.us/v2/users/userId/token
curl --request DELETE \
  --url https://api.zoom.us/v2/users/userId/token \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/users/userId/token',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/token")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/users/userId/token");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/token"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

userId
string
required

Unique user ID.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Verify a user's zpk (Deprecated

Check if the zpk is expired. The zpk is used to authenticate a user.

 
gethttps://api.zoom.us/v2/users/zpk
curl --request GET \
  --url https://api.zoom.us/v2/users/zpk \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users/zpk',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/zpk")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users/zpk");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/zpk"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "expire_in": "integer"
}

Query Params

zpk
string

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Check a user's email

Check if the user email exists

 
gethttps://api.zoom.us/v2/users/email
curl --request GET \
  --url https://api.zoom.us/v2/users/email \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users/email',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/email")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users/email");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/email"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "existed_email": "boolean"
}

Query Params

email
string

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

List webinars

List webinars for a user

 
gethttps://api.zoom.us/v2/users/userId/webinars
curl --request GET \
  --url https://api.zoom.us/v2/users/userId/webinars \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users/userId/webinars',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/webinars")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users/userId/webinars");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/webinars"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "page_count": "integer",
  "page_number": "integer",
  "page_size": "integer",
  "total_records": "integer",
  "webinars": [
    {
      "uuid": "string",
      "id": "string",
      "host_id": "string",
      "topic": "string",
      "type": "integer",
      "duration": "integer",
      "timezone": "string",
      "created_at": "string [date-time]",
      "join_url": "string"
    }
  ]
}

Path Params

userId
string
required

Unique user ID.

Query Params

page_size
int32

The number of records returned within a single API call

page_number
int32

Current page number of returned records

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

 
Suggest Edits

Create a webinar

Create a webinar for a user <aside>The expiration time of start_url is two hours. But for API users, the expiration time is 90 days.</aside>

 
posthttps://api.zoom.us/v2/users/userId/webinars
curl --request POST \
  --url https://api.zoom.us/v2/users/userId/webinars \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.zoom.us/v2/users/userId/webinars',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/webinars")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.zoom.us/v2/users/userId/webinars");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/webinars"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "uuid": "string",
  "id": "string",
  "host_id": "string",
  "topic": "string",
  "type": "integer",
  "start_time": "string [date-time]",
  "duration": "integer",
  "timezone": "string",
  "agenda": "string",
  "created_at": "string [date-time]",
  "start_url": "string",
  "join_url": "string",
  "occurrences": [
    {
      "occurrence_id": "integer",
      "start_time": "string [date-time]",
      "duration": "integer",
      "status": "string"
    }
  ],
  "settings": {
    "host_video": "boolean",
    "panelists_video": "boolean",
    "practice_session": "boolean",
    "hd_video": "boolean",
    "approval_type": "integer",
    "registration_type": "integer",
    "audio": "string",
    "auto_recording": "string",
    "enforce_login": "boolean",
    "enforce_login_domains": "string",
    "alternative_hosts": "string",
    "close_registration": "boolean",
    "show_share_button": "boolean",
    "allow_multiple_devices": "boolean"
  }
}

Path Params

userId
string
required

Unique user ID.

Body Params

topic
string

Topic

type
string
start_time
string

Start time.

duration
string

Duration in minutes

timezone
string

Timezone to format start_time. For example, “America/Los_Angeles”. For scheduled meetings only. Please reference our timezone list for supported timezones and their formats.

password
string

Sets password.

agenda
string

Meeting description.

recurrence
object
recurrence.type
string
recurrence.repeat_interval
string

At which interval should the meeting repeat? For a daily meeting, max of 90 days. For a weekly meeting, max of 12 weeks. For a monthly meeting, max of 3 months.

recurrence.weekly_days
string

Days of the week the meeting should repeat, multiple values separated by comma
1 Sunday
2 Monday
3 Tuesday
4 Wednesday
5 Thursday
6 Friday
7 Saturday

recurrence.monthly_day
string

Day of the month for the meeting to be scheduled. The value range is from 1 to 31.

recurrence.monthly_week
string

Week for which the meeting should recur each month,
-1 Last week
1 First week
2 Second week
3 Third week
4 Fourth week.

recurrence.monthly_week_day
string

Day for which the meeting should recur each month
1 Sunday
2 Monday
3 Tuesday
4 Wednesday
5 Thursday
6 Friday
7 Saturday.

recurrence.end_times
string

Select how many times the meeting will occur before it is canceled. (Cannot be used with “end_date_time”.)

recurrence.end_date_time
string

Select a date the meeting will occur before it is canceled.. Should be UTC time, such as 2017-11-25T12:00:00Z. (Cannot be used with “end_times”.)

settings
object
settings.enforce_login_domains
string

Start meetings with host video on.

settings.panelists_video
string

Start video when panelists join webinar.

settings.practice_session
string

Enable Practice Session.

settings.hd_video
string

Default to HD Video.

settings.approval_type
string

0 Automatically Approve
1 Manually Approve
2 No Registration Required

settings.registration_type
string

Registration type. Used for recurring meeting with fixed time only.
1 Attendees register once and can attend any of the occurrences
2 Attendees need to register for each occurrence to attend
3 Attendees register once and can choose one or more occurrences to attend

settings.audio
string

Determine how participants can join the audio portion of the meeting
both Both Telephony and VoIP
telephony Telephony only
voip VoIP only

settings.auto_recording
string

Record meetings automatically as they start
local Record on local
cloud Record on cloud
none Disabled.

settings.enforce_login
string

Only signed-in users can join this meeting.

settings.alternative_hosts
string

Alternative hosts emails or IDs. Multiple value separated by comma.

settings.close_registration
string

Close registration after event date.

settings.show_share_button
string

Show social share buttons on registration page.

settings.allow_multiple_devices
string

Allow attendees to join from multiple devices.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Created

Suggest Edits

Retrieve a webinar

Retrieve a webinar

 
gethttps://api.zoom.us/v2/webinars/webinarId
curl --request GET \
  --url https://api.zoom.us/v2/webinars/webinarId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/webinars/webinarId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/webinars/webinarId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "uuid": "string",
  "id": "string",
  "host_id": "string",
  "topic": "string",
  "type": "integer",
  "start_time": "string [date-time]",
  "duration": "integer",
  "timezone": "string",
  "agenda": "string",
  "created_at": "string [date-time]",
  "start_url": "string",
  "join_url": "string",
  "occurrences": [
    {
      "occurrence_id": "integer",
      "start_time": "string [date-time]",
      "duration": "integer",
      "status": "string"
    }
  ],
  "settings": {
    "host_video": "boolean",
    "panelists_video": "boolean",
    "practice_session": "boolean",
    "hd_video": "boolean",
    "approval_type": "integer",
    "registration_type": "integer",
    "audio": "string",
    "auto_recording": "string",
    "enforce_login": "boolean",
    "enforce_login_domains": "string",
    "alternative_hosts": "string",
    "close_registration": "boolean",
    "show_share_button": "boolean",
    "allow_multiple_devices": "boolean"
  }
}

Path Params

webinarId
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Delete a webinar

Delete a webinar

 
deletehttps://api.zoom.us/v2/webinars/webinarId
curl --request DELETE \
  --url https://api.zoom.us/v2/webinars/webinarId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/webinars/webinarId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/webinars/webinarId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

webinarId
string
required

Query Params

occurrence_id
string

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Update a webinar

Update a webinar

 
patchhttps://api.zoom.us/v2/webinars/webinarId
curl --request PATCH \
  --url https://api.zoom.us/v2/webinars/webinarId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PATCH',
  url: 'https://api.zoom.us/v2/webinars/webinarId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PATCH", "https://api.zoom.us/v2/webinars/webinarId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PATCH", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "topic": "string",
  "type": "integer",
  "start_time": "string [date-time]",
  "duration": "integer",
  "timezone": "string",
  "password": "string",
  "agenda": "string",
  "recurrence": {
    "type": "integer",
    "repeat_interval": "integer",
    "weekly_days": "integer",
    "monthly_day": "integer",
    "monthly_week": "integer",
    "monthly_week_day": "integer",
    "end_times": "integer",
    "end_date_time": "string [date-time]"
  },
  "settings": {
    "host_video": "boolean",
    "panelists_video": "boolean",
    "practice_session": "boolean",
    "hd_video": "boolean",
    "approval_type": "integer",
    "registration_type": "integer",
    "audio": "string",
    "auto_recording": "string",
    "enforce_login": "boolean",
    "enforce_login_domains": "string",
    "alternative_hosts": "string",
    "close_registration": "boolean",
    "show_share_button": "boolean",
    "allow_multiple_devices": "boolean",
    "registrants_confirmation_email": "boolean"
  }
}

Path Params

webinarId
string
required

Body Params

topic
string

Topic

type
string
start_time
string

Start time.

duration
string

Duration in minutes

timezone
string

Timezone to format start_time. For example, “America/Los_Angeles”. For scheduled meetings only. Please reference our timezone list for supported timezones and their formats.

password
string

Sets password.

agenda
string

Meeting description.

recurrence
object
recurrence.type
string
recurrence.repeat_interval
string

At which interval should the meeting repeat? For a daily meeting, max of 90 days. For a weekly meeting, max of 12 weeks. For a monthly meeting, max of 3 months.

recurrence.weekly_days
string

Days of the week the meeting should repeat, multiple values separated by comma
1 Sunday
2 Monday
3 Tuesday
4 Wednesday
5 Thursday
6 Friday
7 Saturday

recurrence.monthly_day
string

Day of the month for the meeting to be scheduled. The value range is from 1 to 31.

recurrence.monthly_week
string

Week for which the meeting should recur each month,
-1 Last week
1 First week
2 Second week
3 Third week
4 Fourth week.

recurrence.monthly_week_day
string

Day for which the meeting should recur each month
1 Sunday
2 Monday
3 Tuesday
4 Wednesday
5 Thursday
6 Friday
7 Saturday.

recurrence.end_times
string

Select how many times the meeting will occur before it is canceled. (Cannot be used with “end_date_time”.)

recurrence.end_date_time
string

Select a date the meeting will occur before it is canceled.. Should be UTC time, such as 2017-11-25T12:00:00Z. (Cannot be used with “end_times”.)

settings
object
settings.enforce_login_domains
string

Start meetings with host video on.

settings.panelists_video
string

Start video when panelists join webinar.

settings.practice_session
string

Enable Practice Session.

settings.hd_video
string

Default to HD Video.

settings.approval_type
string

0 Automatically Approve
1 Manually Approve
2 No Registration Required

settings.registration_type
string

Registration type. Used for recurring meeting with fixed time only.
1 Attendees register once and can attend any of the occurrences
2 Attendees need to register for each occurrence to attend
3 Attendees register once and can choose one or more occurrences to attend

settings.audio
string

Determine how participants can join the audio portion of the meeting
both Both Telephony and VoIP
telephony Telephony only
voip VoIP only

settings.auto_recording
string

Record meetings automatically as they start
local Record on local
cloud Record on cloud
none Disabled.

settings.enforce_login
string

Only signed-in users can join this meeting.

settings.alternative_hosts
string

Alternative hosts emails or IDs. Multiple value separated by comma.

settings.close_registration
string

Close registration after event date.

settings.show_share_button
string

Show social share buttons on registration page.

settings.allow_multiple_devices
string

Allow attendees to join from multiple devices.

settings.registrants_confirmation_email
string

Send confirmation Email to Registrants.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Update a webinar's status

Update a webinar's status

 
puthttps://api.zoom.us/v2/webinars/webinarId/status
curl --request PUT \
  --url https://api.zoom.us/v2/webinars/webinarId/status \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.zoom.us/v2/webinars/webinarId/status',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId/status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.zoom.us/v2/webinars/webinarId/status");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId/status"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PUT", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

webinarId
string
required

Body Params

status
string

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

List a webinar's panelists

List panelists for a webinar

 
gethttps://api.zoom.us/v2/webinars/webinarId/panelists
curl --request GET \
  --url https://api.zoom.us/v2/webinars/webinarId/panelists \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/webinars/webinarId/panelists',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId/panelists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/webinars/webinarId/panelists");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId/panelists"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "total_records": "integer",
  "panelists": [
    {
      "id": "string",
      "name": "string",
      "email": "string",
      "join_url": "string"
    }
  ]
}

Path Params

webinarId
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Add a webinar panelist

Add panelist to webinar

 
posthttps://api.zoom.us/v2/webinars/webinarId/panelists
curl --request POST \
  --url https://api.zoom.us/v2/webinars/webinarId/panelists \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.zoom.us/v2/webinars/webinarId/panelists',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId/panelists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.zoom.us/v2/webinars/webinarId/panelists");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId/panelists"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "id": "string",
  "join_url": "string"
}

Path Params

webinarId
string
required

Body Params

panelists
array of objects

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Created

Suggest Edits

Remove a webinar's panelists

Remove all panelists from a webinar

 
deletehttps://api.zoom.us/v2/webinars/webinarId/panelists
curl --request DELETE \
  --url https://api.zoom.us/v2/webinars/webinarId/panelists \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/webinars/webinarId/panelists',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId/panelists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/webinars/webinarId/panelists");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId/panelists"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

webinarId
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Remove a webinar panelist

Remove a panelist from a webinar

 
deletehttps://api.zoom.us/v2/webinars/webinarId/panelists/panelistId
curl --request DELETE \
  --url https://api.zoom.us/v2/webinars/webinarId/panelists/panelistId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/webinars/webinarId/panelists/panelistId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId/panelists/panelistId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/webinars/webinarId/panelists/panelistId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId/panelists/panelistId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

webinarId
string
required
panelistId
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

List a webinar's registrants

List registrants for a webinar

 
gethttps://api.zoom.us/v2/webinars/webinarId/registrants
curl --request GET \
  --url https://api.zoom.us/v2/webinars/webinarId/registrants \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/webinars/webinarId/registrants',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId/registrants")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/webinars/webinarId/registrants");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId/registrants"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "page_count": "integer",
  "page_size": "integer",
  "total_records": "integer",
  "next_page_token": "string",
  "registrants": [
    {
      "id": "string",
      "email": "string",
      "first_name": "string",
      "last_name": "string",
      "address": "string",
      "city": "string",
      "country": "string",
      "zip": "string",
      "state": "string",
      "phone": "string",
      "industry": "string",
      "org": "string",
      "job_title": "string",
      "purchasing_time_frame": "string",
      "role_in_purchase_process": "string",
      "no_of_employees": "string",
      "comments": "string",
      "custom_questions": [
        {
          "title": "string",
          "value": "string"
        }
      ],
      "status": "string",
      "create_time": "string [date-time]",
      "join_url": "string [string]"
    }
  ]
}

Path Params

webinarId
string
required

Query Params

occurrence_id
string
status
string
page_size
int32

The number of records returned within a single API call

page_number
int32

Current page number of returned records

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Add a webinar registrant

Add a registrant for a webinar

 
posthttps://api.zoom.us/v2/webinars/webinarId/registrants
curl --request POST \
  --url https://api.zoom.us/v2/webinars/webinarId/registrants \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.zoom.us/v2/webinars/webinarId/registrants',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId/registrants")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.zoom.us/v2/webinars/webinarId/registrants");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId/registrants"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "registrant_id": "string",
  "id": "string",
  "topic": "string",
  "start_time": "string [date-time]",
  "join_url": "string"
}

Path Params

webinarId
string
required

Query Params

occurrence_ids
string

Body Params

email
string
required

User's email address.

first_name
string
required

User's first name.

last_name
string
required

User's last name.

address
string

User's address.

city
string

User's city.

country
string

User's country.

zip
string

User's zip code.

state
string

User's state.

phone
string

Phone

industry
string

Industry

org
string

Organization

job_title
string

Job Title

purchasing_time_frame
string

Purchasing Time Frame
Within a month
1-3 months
4-6 months
More than 6 months
No timeframe

role_in_purchase_process
string

Role in Purchase Process
Decision Maker
Evaluator/Recommender
Influencer
Not involved

no_of_employees
string

Number of Employees
1-20
21-50
51-100
101-500
500-1,000
1,001-5,000
5,001-10,000
More than 10,000

comments
string

Questions & Comments.

custom_questions
array of objects

Custom Questions.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Created

Suggest Edits

Update a webinar registrant's status

Update a webinar registrant's status

 
puthttps://api.zoom.us/v2/webinars/webinarId/registrants/status
curl --request PUT \
  --url https://api.zoom.us/v2/webinars/webinarId/registrants/status \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.zoom.us/v2/webinars/webinarId/registrants/status',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/webinars/webinarId/registrants/status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.zoom.us/v2/webinars/webinarId/registrants/status");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/webinars/webinarId/registrants/status"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PUT", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

webinarId
string
required

Query Params

occurrence_id
string

Body Params

action
string
required
registrants
array of objects

List of registrants

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

List of ended webinar instances

List of ended webinar instances

 
gethttps://api.zoom.us/v2/past_webinars/webinarId/instances
curl --request GET \
  --url https://api.zoom.us/v2/past_webinars/webinarId/instances \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/past_webinars/webinarId/instances',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/past_webinars/webinarId/instances")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/past_webinars/webinarId/instances");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/past_webinars/webinarId/instances"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "webinars": [
    {
      "uuid": "string",
      "start_time": "string [date-time]"
    }
  ]
}

Path Params

webinarId
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

 
Suggest Edits

List meetings

List meetings for a user

 
gethttps://api.zoom.us/v2/users/userId/meetings
curl --request GET \
  --url https://api.zoom.us/v2/users/userId/meetings \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/users/userId/meetings',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/meetings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/users/userId/meetings");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/meetings"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "page_count": "integer",
  "page_number": "integer",
  "page_size": "integer",
  "total_records": "integer",
  "meetings": [
    {
      "uuid": "string",
      "id": "string",
      "host_id": "string",
      "topic": "string",
      "type": "integer",
      "start_time": "string [date-time]",
      "duration": "integer",
      "timezone": "string",
      "created_at": "string [date-time]",
      "join_url": "string"
    }
  ]
}

Path Params

userId
string
required

Unique user ID.

Query Params

type
string
page_size
int32

The number of records returned within a single API call

page_number
int32

Current page number of returned records

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Create a meeting

Create a meeting for a user <aside>The expiration time of start_url is two hours. But for API users, the expiration time is 90 days.</aside>

 
posthttps://api.zoom.us/v2/users/userId/meetings
curl --request POST \
  --url https://api.zoom.us/v2/users/userId/meetings \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.zoom.us/v2/users/userId/meetings',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/users/userId/meetings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.zoom.us/v2/users/userId/meetings");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/users/userId/meetings"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "uuid": "string",
  "id": "string",
  "host_id": "string",
  "topic": "string",
  "type": "integer",
  "start_time": "string [date-time]",
  "duration": "integer",
  "timezone": "string",
  "created_at": "string [date-time]",
  "agenda": "string",
  "start_url": "string",
  "join_url": "string",
  "password": "string",
  "h323_password": "string",
  "occurrences": [
    {
      "occurrence_id": "integer",
      "start_time": "string [date-time]",
      "duration": "integer",
      "status": "string"
    }
  ],
  "settings": {
    "host_video": "boolean",
    "participant_video": "boolean",
    "cn_meeting": "boolean",
    "in_meeting": "boolean",
    "join_before_host": "boolean",
    "mute_upon_entry": "boolean",
    "watermark": "boolean",
    "use_pmi": "boolean",
    "approval_type": "integer",
    "registration_type": "integer",
    "audio": "string",
    "auto_recording": "string",
    "enforce_login": "boolean",
    "enforce_login_domains": "string",
    "alternative_hosts": "string"
  }
}

Path Params

userId
string
required

Unique user ID.

Body Params

topic
string

Topic

type
string
start_time
string

Start time.

duration
string

Duration in minutes

timezone
string

Timezone to format start_time. For example, “America/Los_Angeles”. For scheduled meetings only. Please reference our timezone list for supported timezones and their formats.

password
string

Sets password.

agenda
string

Meeting description.

recurrence
object
recurrence.type
string
recurrence.repeat_interval
string

At which interval should the meeting repeat? For a daily meeting, max of 90 days. For a weekly meeting, max of 12 weeks. For a monthly meeting, max of 3 months.

recurrence.weekly_days
string

Days of the week the meeting should repeat, multiple values separated by comma
1 Sunday
2 Monday
3 Tuesday
4 Wednesday
5 Thursday
6 Friday
7 Saturday

recurrence.monthly_day
string

Day of the month for the meeting to be scheduled. The value range is from 1 to 31.

recurrence.monthly_week
string

Week for which the meeting should recur each month,
-1 Last week
1 First week
2 Second week
3 Third week
4 Fourth week.

recurrence.monthly_week_day
string

Day for which the meeting should recur each month
1 Sunday
2 Monday
3 Tuesday
4 Wednesday
5 Thursday
6 Friday
7 Saturday.

recurrence.end_times
string

Select how many times the meeting will occur before it is canceled. (Cannot be used with “end_date_time”.)

recurrence.end_date_time
string

Select a date the meeting will occur before it is canceled.. Should be UTC time, such as 2017-11-25T12:00:00Z. (Cannot be used with “end_times”.)

settings
object
settings.enforce_login_domains
string

Start meetings with host video on.

settings.participant_video
string

Start meetings with participant video on. Participants can change this during the meeting.

settings.cn_meeting
string

Host meeting in China.

settings.in_meeting
string

Host meeting in India.

settings.join_before_host
string

Allow participants to join the meeting before the host starts the meeting. Only used for scheduled or recurring meetings.

settings.mute_upon_entry
string

Mute participants upon entry.

settings.watermark
string

Add watermark when viewing shared screen.

settings.use_pmi
string

Use Personal Meeting ID. Only used for scheduled meetings and recurring meetings with no fixed time.

settings.approval_type
string

0 Automatically Approve
1 Manually Approve
2 No Registration Required

settings.registration_type
string

Registration type. Used for recurring meeting with fixed time only.
1 Attendees register once and can attend any of the occurrences
2 Attendees need to register for each occurrence to attend
3 Attendees register once and can choose one or more occurrences to attend

settings.audio
string

Determine how participants can join the audio portion of the meeting
both Both Telephony and VoIP
telephony Telephony only
voip VoIP only

settings.auto_recording
string

Record meetings automatically as they start
local Record on local
cloud Record on cloud
none Disabled.

settings.enforce_login
string

Only signed-in users can join this meeting.

settings.alternative_hosts
string

Alternative hosts emails or IDs. Multiple value separated by comma.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Created

Suggest Edits

Retrieve a meeting

Retrieve a meeting's details

 
gethttps://api.zoom.us/v2/meetings/meetingId
curl --request GET \
  --url https://api.zoom.us/v2/meetings/meetingId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.zoom.us/v2/meetings/meetingId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/meetings/meetingId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.zoom.us/v2/meetings/meetingId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/meetings/meetingId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "uuid": "string",
  "id": "string",
  "host_id": "string",
  "topic": "string",
  "type": "integer",
  "start_time": "string [date-time]",
  "duration": "integer",
  "timezone": "string",
  "created_at": "string [date-time]",
  "agenda": "string",
  "start_url": "string",
  "join_url": "string",
  "password": "string",
  "h323_password": "string",
  "occurrences": [
    {
      "occurrence_id": "integer",
      "start_time": "string [date-time]",
      "duration": "integer",
      "status": "string"
    }
  ],
  "settings": {
    "host_video": "boolean",
    "participant_video": "boolean",
    "cn_meeting": "boolean",
    "in_meeting": "boolean",
    "join_before_host": "boolean",
    "mute_upon_entry": "boolean",
    "watermark": "boolean",
    "use_pmi": "boolean",
    "approval_type": "integer",
    "registration_type": "integer",
    "audio": "string",
    "auto_recording": "string",
    "enforce_login": "boolean",
    "enforce_login_domains": "string",
    "alternative_hosts": "string"
  }
}

Path Params

meetingId
string
required

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

OK

Suggest Edits

Delete a meeting

Delete a meeting

 
deletehttps://api.zoom.us/v2/meetings/meetingId
curl --request DELETE \
  --url https://api.zoom.us/v2/meetings/meetingId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'DELETE',
  url: 'https://api.zoom.us/v2/meetings/meetingId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/meetings/meetingId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.zoom.us/v2/meetings/meetingId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/meetings/meetingId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("DELETE", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

meetingId
string
required

Query Params

occurrence_id
string

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Update a meeting

Update a meeting's details

 
patchhttps://api.zoom.us/v2/meetings/meetingId
curl --request PATCH \
  --url https://api.zoom.us/v2/meetings/meetingId \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PATCH',
  url: 'https://api.zoom.us/v2/meetings/meetingId',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/meetings/meetingId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PATCH", "https://api.zoom.us/v2/meetings/meetingId");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/meetings/meetingId"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PATCH", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Path Params

meetingId
string
required

Body Params

topic
string

Topic

type
string
start_time
string

Start time.

duration
string

Duration in minutes

timezone
string

Timezone to format start_time. For example, “America/Los_Angeles”. For scheduled meetings only. Please reference our timezone list for supported timezones and their formats.

password
string

Sets password.

agenda
string

Meeting description.

recurrence
object
recurrence.type
string
recurrence.repeat_interval
string

At which interval should the meeting repeat? For a daily meeting, max of 90 days. For a weekly meeting, max of 12 weeks. For a monthly meeting, max of 3 months.

recurrence.weekly_days
string

Days of the week the meeting should repeat, multiple values separated by comma
1 Sunday
2 Monday
3 Tuesday
4 Wednesday
5 Thursday
6 Friday
7 Saturday

recurrence.monthly_day
string

Day of the month for the meeting to be scheduled. The value range is from 1 to 31.

recurrence.monthly_week
string

Week for which the meeting should recur each month,
-1 Last week
1 First week
2 Second week
3 Third week
4 Fourth week.

recurrence.monthly_week_day
string

Day for which the meeting should recur each month
1 Sunday
2 Monday
3 Tuesday
4 Wednesday
5 Thursday
6 Friday
7 Saturday.

recurrence.end_times
string

Select how many times the meeting will occur before it is canceled. (Cannot be used with “end_date_time”.)

recurrence.end_date_time
string

Select a date the meeting will occur before it is canceled.. Should be UTC time, such as 2017-11-25T12:00:00Z. (Cannot be used with “end_times”.)

settings
object
settings.enforce_login_domains
string

Start meetings with host video on.

settings.participant_video
string

Start meetings with participant video on. Participants can change this during the meeting.

settings.cn_meeting
string

Host meeting in China.

settings.in_meeting
string

Host meeting in India.

settings.join_before_host
string

Allow participants to join the meeting before the host starts the meeting. Only used for scheduled or recurring meetings.

settings.mute_upon_entry
string

Mute participants upon entry.

settings.watermark
string

Add watermark when viewing shared screen.

settings.use_pmi
string

Use Personal Meeting ID. Only used for scheduled meetings and recurring meetings with no fixed time.

settings.approval_type
string

0 Automatically Approve
1 Manually Approve
2 No Registration Required

settings.registration_type
string

Registration type. Used for recurring meeting with fixed time only.
1 Attendees register once and can attend any of the occurrences
2 Attendees need to register for each occurrence to attend
3 Attendees register once and can choose one or more occurrences to attend

settings.audio
string

Determine how participants can join the audio portion of the meeting
both Both Telephony and VoIP
telephony Telephony only
voip VoIP only

settings.auto_recording
string

Record meetings automatically as they start
local Record on local
cloud Record on cloud
none Disabled.

settings.enforce_login
string

Only signed-in users can join this meeting.

settings.alternative_hosts
string

Alternative hosts emails or IDs. Multiple value separated by comma.

settings.registrants_confirmation_email
string

Send confirmation Email to Registrants.

Headers

Accept
string
required

Type is always 'application/json'.

Content-Type
string
required

Type is always 'application/json'.

Response

Updated

Suggest Edits

Update a meeting's status

Update a meeting's status

 
puthttps://api.zoom.us/v2/meetings/meetingId/status
curl --request PUT \
  --url https://api.zoom.us/v2/meetings/meetingId/status \
  --header 'accept: application/json' \
  --header 'content-type: application/json'
var request = require("request");

var options = { method: 'PUT',
  url: 'https://api.zoom.us/v2/meetings/meetingId/status',
  headers: 
   { 'content-type': 'application/json',
     accept: 'application/json' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.zoom.us/v2/meetings/meetingId/status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["accept"] = 'application/json'
request["content-type"] = 'application/json'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.zoom.us/v2/meetings/meetingId/status");
xhr.setRequestHeader("accept", "application/json");
xhr.setRequestHeader("content-type", "application/json");

xhr.send(data);
import requests

url = "https://api.zoom.us/v2/meetings/meetingId/status"

headers = {
    'accept': "application/json",
    'content-type': "application/json"
    }

response = requests.request("PUT", url, headers=headers)

print(response.text)