How to create a meeting with the zoom API in Python?

Zoom is a video conferencing platform that has become increasingly popular for remote meetings and webinars. Zoom provides an API that allows developers to programmatically interact with Zoom's features and functionality, including creating and managing meetings. In this context, Python provides a simple and efficient way to create meetings through Zoom's API.

By using Python, you can automate the process of creating Zoom meetings and integrate it with other workflows or applications. In this guide, we will explore how to create a meeting with the Zoom API in Python using the requests library and the Zoom API's authentication mechanisms.

This guide covers how to create a Zoom meeting using Python and Zoom API. To use the Zoom API, you must first create it by following the steps below −

  • Go to and either sign up or sign in to your Zoom account.

  • Click on the "Develop" tab and select "Build App".

  • Agree to Zoom's API License and Terms of Use.

  • Choose "JWT" as the app type because it is easy to use.

  • Enter the name of your app and click "Create".

  • Fill in mandatory details such as your company name, developer's name, and email address. For the company name, you can enter your name, and then click "Continue".

  • Go to the "App Credentials" tab, copy your API key and API secret, and save them.

Before we can move ahead with the code, we need to install the following packages −

  • JWT  JWT (JSON Web Token) is a compact, URL-safe means of representing claims to be transferred between two parties.

  • Requests  The requests package in Python is used for making HTTP requests to web APIs.

  • JSON  The json package in Python is used for encoding and decoding JSON data.

We can install these packages with the help of the command shown below.

pip3 install jwt requests json 

Creating a Meeting with the Zoom API

Now let's focus on the code. Consider the code shown below.


import jwt
import requests
import json
from time import time

# Replace with your own API key and secret
API_KEY = 'Your API key'
API_SECRET = 'Your API secret'

# Create a function to generate a token using the PyJWT library
def generate_token():
   # Create a payload of the token containing API key and expiration time
   token_payload = {'iss': API_KEY, 'exp': time() + 5000}

   # Secret used to generate token signature
   secret_key = API_SECRET

   # Specify the hashing algorithm
   algorithm = 'HS256'

   # Encode the token
   token = jwt.encode(token_payload, secret_key, algorithm=algorithm)
   return token.decode('utf-8')
# Create JSON data for the Zoom meeting details
meeting_details = {
   "topic": "The title of your Zoom meeting",
   "type": 2,
   "start_time": "2019-06-14T10:21:57",
   "duration": "45",
   "timezone": "Europe/Madrid",
   "agenda": "test",
   "recurrence": {
      "type": 1,
      "repeat_interval": 1 
   "settings": {
      "host_video": "true",
      "participant_video": "true",
      "join_before_host": "False",
      "mute_upon_entry": "False",
      "watermark": "true",
      "audio": "voip",
      "auto_recording": "cloud"

# Send a request with headers including a token and meeting details
def create_zoom_meeting():
   headers = {
      'authorization': 'Bearer ' + generate_token(),
      'content-type': 'application/json'

   # Make a POST request to the Zoom API endpoint to create the meeting
   response =
      f'',  headers=headers, data=json.dumps(meeting_details)
   print("\nCreating Zoom meeting...\n")

   # Convert the response to JSON and extract the meeting details
   response_json = json.loads(response.text)
   join_url = response_json["join_url"]
   meeting_password = response_json["password"]

   # Print the meeting details
   print(f'\nHere is your Zoom meeting link {join_url} and your password: "{meeting_password}"\n')
# Run the create_zoom_meeting function


  • The code imports necessary libraries  jwt, requests, json, and time.

  • The code defines the API key and secret variables to be used later in the program.

  • The code defines a function named generateToken() that uses the PyJWT library to create a token for authentication. The function encodes a payload that contains the API key and an expiration time, then signs the payload with the API secret using the HS256 hashing algorithm. The token is returned as a UTF-8 string.

  • The code defines a dictionary named meetingdetails that contains the details of a Zoom meeting, such as the title, start time, duration, and settings.

  • The code defines a function named createMeeting() that sends a POST request to the Zoom API endpoint to create a new meeting. The function first calls the generateToken() function to obtain an authentication token, then sets the headers of the request to include the token and the content type as JSON. The function sends the meetingdetails as a JSON-encoded string in the body of the request. If the request is successful, the function prints the meeting details such as the join URL and password.

  • The code calls the createMeeting() function to create a new Zoom meeting.

  • The code uses comments to explain what each part of the program is doing.


Once you run this code, it will produce the following output −

can you change the value in this
creating zoom meeting …
here is your zoom meeting link and your password: "XyZaBc123"


In conclusion, creating a meeting with the Zoom API in Python is a straightforward process that can be achieved using the Zoom API wrapper for Python.

By following the steps outlined in this guide, developers can easily integrate Zoom meetings into their Python applications and automate the process of creating meetings for their users.

Updated on: 21-Apr-2023

2K+ Views

Kickstart Your Career

Get certified by completing the course

Get Started