5 Best Ways to Create a Meeting with the Zoom API in Python

by

💡 Problem Formulation: Integrating Zoom’s functionalities within an application requires creating meetings through their API. Developers often need to automate the process of creating Zoom meetings using Python scripts. This article illustrates how to use the Zoom API for meeting creation, starting with obtaining necessary credentials (API Key and Secret), continuing with API calls, and handling Zoom’s response. By the end of this guide, readers will be able to generate new Zoom meeting links programmatically, with the input being meeting details and the output being the Zoom meeting URL and related information.

Method 1: Using Zoom API with HTTP Requests

This method involves directly making HTTP requests to the Zoom REST API using the requests library in Python. You will require a JWT token for authorization, which you can obtain by encoding your API key, API secret, and expiration time. The main function to be created is one that sets up the POST request to create a Zoom meeting.

Here’s an example:

import json
import requests
from jwt import encode

API_KEY = 'YOUR_API_KEY'
API_SEC = 'YOUR_API_SECRET'

def generate_jwt(api_key, api_sec):
    token = encode({'iss': api_key, 'exp': 1585907209}, api_sec, algorithm='HS256')
    return token

def create_zoom_meeting(token):
    headers = {'authorization': 'Bearer ' + token, 'content-type': 'application/json'}
    data = {
        "topic": "My Test Meeting",
        "type": 2,
        "start_time": "2023-04-30T14:00:00Z",
        "duration": "45",
        "timezone": "Europe/Berlin",
        "agenda": "Discussing the test agenda",
    }
    response = requests.post('https://api.zoom.us/v2/users/me/meetings', headers=headers, json=data)
    return json.loads(response.text)

jwt_token = generate_jwt(API_KEY, API_SEC)
meeting_details = create_zoom_meeting(jwt_token)
print(meeting_details)

The output will be a JSON object with the meeting details, including the join URL

This code snippet provides a simple way to generate a JWT token for authorization and make a POST request to create a meeting with predefined options. Users should replace the placeholder values in API_KEY and API_SEC with their actual Zoom API credentials. The create_zoom_meeting function encapsulates the request logic, making it a reusable component in larger applications.

Method 2: Using the Zoomus Python Library

The Zoomus library is a third-party Python wrapper for the Zoom API which simplifies the process of making API requests. It handles the creation of JWT tokens and provides Pythonic methods to interact with the API. The main function to leverage here is zoom.create_meeting().

Here’s an example:

from zoomus import ZoomClient

API_KEY = 'YOUR_API_KEY'
API_SEC = 'YOUR_API_SECRET'

client = ZoomClient(API_KEY, API_SEC)

user_id = 'me'  # or a specific Zoom user's ID
meeting_details = {
    'topic': 'My Test Meeting',
    'type': 2,
    'start_time': '2023-04-30T14:00:00Z',
    'duration': 45,
    'timezone': 'Europe/Berlin',
    'agenda': 'Discussion on test agenda'
}

response = client.meeting.create(user_id=user_id, **meeting_details)
print(response)

The output will be a JSON object with the meeting details, including the join URL

This snippet demonstrates the ease of using the Zoomus library to create a new Zoom meeting. The ZoomClient takes care of authentication, and the meeting creation process is reduced to a single method call. This abstracts away much of the lower-level HTTP handling that method 1 required.

Method 3: Using Environment Variables for API Credentials

This method involves storing your API key and secret as environment variables to enhance security and modularize your code. This is a best practice in application development to avoid hardcoding sensitive information. The process of creating the meeting with the Zoom API remains the same as in Method 1 or Method 2.

Here’s an example:

import os
from zoomus import ZoomClient

API_KEY = os.getenv('ZOOM_API_KEY')
API_SEC = os.getenv('ZOOM_API_SECRET')

client = ZoomClient(API_KEY, API_SEC)

# Create a meeting with this client as we did in method 2
...

This snippet does not directly produce output but ensures the secure handling of your credentials.

By utilizing environment variables, this code snippet demonstrates a secure way to handle API keys and secrets, avoiding any hard-coded values. Both Method 1 and Method 2 can be easily adapted to use this approach. This method protects your credentials in case the source code is exposed or shared.

Method 4: Asynchronous API Calls with Asyncio and Aiohttp

If you’re running a high-performance application that needs to handle multiple requests concurrently, you can create Zoom meetings asynchronously using the asyncio library in conjunction with aiohttp. This makes the API calls non-blocking, improving throughput in scenarios with multiple synchronous operations.

Here’s an example:

import aiohttp
import asyncio
import json
from your_jwt_generation_function import generate_jwt  # Use the JWT function as before

API_KEY = 'YOUR_API_KEY'
API_SEC = 'YOUR_API_SECRET'
jwt_token = generate_jwt(API_KEY, API_SEC)

async def create_zoom_meeting_async(token):
    async with aiohttp.ClientSession() as session:
        headers = {'authorization': 'Bearer ' + token, 'content-type': 'application/json'}
        data = {
            "topic": "My Async Test Meeting",
            "type": 2,
            "start_time": "2023-04-30T14:00:00Z",
            "duration": "45",
            "timezone": "Europe/Berlin",
            "agenda": "Discussing the test agenda",
        }
        async with session.post('https://api.zoom.us/v2/users/me/meetings', headers=headers, json=data) as resp:
            return await resp.text()

meeting_info = asyncio.run(create_zoom_meeting_async(jwt_token))
print(meeting_info)

The output will be a JSON object with the meeting details, including the join URL, similar to the previous methods but retrieved asynchronously.

This code snippet attributes to a modern approach to HTTP networking, allowing for asynchronous handling of request and response cycles. Zoom meetings can be created without blocking the execution thread, which is particularly useful in web-based applications that serve multiple users concurrently.

Bonus One-Liner Method 5: Using a Management Command in Django

If you’re using Django, you can create a custom management command that wraps any of the above methods into a single command line instruction, enabling you to invoke meeting creation from the terminal.

Here’s an example:

from django.core.management.base import BaseCommand
from my_zoom_app.utils import create_zoom_meeting  # Assuming this is where your meeting creation utility is

class Command(BaseCommand):
    help = 'Creates a Zoom meeting'

    def handle(self, *args, **options):
        meeting_details = create_zoom_meeting()  # Use one of the previously defined methods
        self.stdout.write(str(meeting_details))
        
# Run this in the terminal: 
# python manage.py create_zoom_meeting

No output is directly produced here, but when the terminal command is run, it will output meeting details.

This management command acts as a shortcut, wrapping the meeting creation function in a Django-specific way. It allows for quick and easy meeting creation directly from the command line, which can be very useful for repetitive tasks or automation scripts.

Summary/Discussion

  • Method 1: Direct HTTP Requests. Strengths: Full control over the request details. Weaknesses: More complex, requires manual handling of JWT and API requests.
  • Method 2: Using Zoomus Python Library. Strengths: Simplified API interaction, less boilerplate code. Weaknesses: Dependency on a third-party package that might become outdated or unsupported.
  • Method 3: Environment Variables for Credentials. Strengths: Secure handling of sensitive information. Weaknesses: Requires additional setup for environment variables.
  • Method 4: Asynchronous API Calls. Strengths: Non-blocking calls, better for performance with multiple operations. Weaknesses: More complex due to asynchronous programming patterns.
  • Method 5: Django Management Command. Strengths: Easy invocation from the command line within Django projects. Weaknesses: Specific only to Django framework.