How to create a meeting using 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 them with other workflows or applications. In this guide, we’ll explore how to create a meeting using the Zoom API in Python using the requests library and the Zoom API’s authentication mechanism.

This guide explains how to create a Zoom meeting using Python and the Zoom API. To use the Zoom API, you must follow these steps to create it −

• Go to https://marketplace.zoom.us/ and either sign up or sign in to your Zoom account.

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

• 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 the required information, such as your company name, developer name, and email address. For Company Name, you can enter your name and 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 and secure way to represent data to be transmitted between two parties. statement.

• Requests − The requests package in Python is used to make HTTP requests to the Web API.

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

We can install these packages through the commands shown below.

pip3 install jwt requests json 

Create a meeting using Zoom API

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

Example

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 = requests.post(
      f'https://api.zoom.us/v2/users/me/meetings',  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
create_zoom_meeting() 

Explanation

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

• This code defines the API key and key variables for use 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.

• This 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.

Output

一旦运行此代码，它将产生以下输出 −

can you change the value in this
creating zoom meeting …
here is your zoom meeting link
https://us04web.zoom.us/j/12345678901?pwd=AbCdEfGhIjKlMnOpQrStUvWxYz and your password: "XyZaBc123"

Conclusion

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.

The above is the detailed content of How to create a meeting using Zoom API in Python?. For more information, please follow other related articles on the PHP Chinese website!