Getting Started With ZOOM API in Python

Now that we've got our Zoom API account set up, it's time to get our hands dirty with some Python magic! Let's start by installing the necessary libraries and then move on to generating our JWT token.

Installing Required Python Libraries

Before we dive into the code, we need to equip our Python environment with two essential libraries:

1. Requests library: This is our go-to for making HTTP requests. It's like the Swiss Army knife for interacting with web APIs.

2. PyJWT library: This little gem will help us generate our JSON Web Tokens (JWT) for authentication.

To install these libraries, open your terminal and run:

pip install requests pyjwt

Easy peasy, right? Now we're ready to roll!

Generating a JWT Token

Alright, let's create a function to generate our JWT token. This token is like a VIP pass that lets us access the Zoom API. Here's how we do it:

import jwt
from time import time
API_KEY = 'Your_API_Key_Here'
API_SEC = 'Your_API_Secret_Here'
def generate_token():
    token = jwt.encode(
        {'iss': API_KEY, 'exp': time() + 5000},
        API_SEC,
        algorithm='HS256'
    )

Let's break this down:

• We import the necessary modules: jwt for token generation and time for setting the expiration.

• We define our API_KEY and API_SEC variables. Remember to replace these with your actual credentials!

• Our generate_token() function does the heavy lifting:

  • It creates a payload with two components:

    • 'iss': This is our API Key, which identifies our app to Zoom.

    • 'exp': This sets the expiration time for our token (current time + 5000 seconds).

  • We use our API Secret to sign the token.

  • We specify the hashing algorithm as 'HS256'.

And voilà! We've got ourselves a shiny new JWT token generator.

This token is like a temporary password that proves to Zoom that we're authorized to use the API. It's more secure than sending our API key and secret with every request.

Creating a Zoom Meeting and Handling the API Response

Now that we've got our token generator up and running, let's dive into the fun part – creating a Zoom meeting with just a few lines of code!

Creating a Zoom Meeting

First, we'll define our meeting details in JSON format. This is like filling out a form for Zoom, telling it what kind of meeting we want:

import json
meeting_details = {
    "topic": "Python Zoom Meeting",
    "type": 2,  # Scheduled meeting
    "start_time": "2023-06-14T10:00:00",  # Use your desired date and time
    "duration": "45",  # Duration in minutes
    "timezone": "America/New_York",
    "agenda": "Discuss Zoom API Integration",
    "settings": {
        "host_video": True,
        "participant_video": True,
        "join_before_host": False,
        "mute_upon_entry": True,
        "watermark": False,
        "audio": "voip",
        "auto_recording": "none"
    }
}

Now, let's create a function to send this to Zoom's API:

import requests
def create_meeting():
    headers = {
        'authorization': 'Bearer ' + generate_token(),
        'content-type': 'application/json'
    }
    r = requests.post(
        f'https://api.zoom.us/v2/users/me/meetings',
        headers=headers, 
        data=json.dumps(meeting_details)
    )
    return r.json()

This function does a few key things:

1. It sets up the headers, including our JWT token.

2. It sends a POST request to Zoom's API endpoint.

3. It includes our meeting details in the request.

Handling the API Response

def display_meeting_info():
    response = create_meeting()
    
    join_url = response['join_url']
    meeting_password = response['password']
    print(f"Your meeting has been created!")
    print(f"Join URL: {join_url}")
    print(f"Password: {meeting_password}")
# Let's run it!
display_meeting_info()

And there you have it! When you run this script, it will create a Zoom meeting and print out the join URL and password. It's that simple!

You've just created your first Zoom meeting using Python and the Zoom API. How cool is that? With this foundation, you can start building more complex applications – maybe a meeting scheduler, or even a custom Zoom client. The possibilities are endless!

Complete Code Example and Running the Script

Alright, let's put it all together! Here's the complete Python script that combines all the steps we've covered. This is your one-stop shop for creating Zoom meetings programmatically:

import jwt
import requests
import json
from time import time
# Your Zoom API credentials
API_KEY = 'Your_API_Key_Here'
API_SEC = 'Your_API_Secret_Here'
# Function to generate a JWT token
def generate_token():
    token = jwt.encode(
        {'iss': API_KEY, 'exp': time() + 5000},
        API_SEC,
        algorithm='HS256'
    )
    return token
# Meeting details
meeting_details = {
    "topic": "Python Zoom Meeting",
    "type": 2,  # Scheduled meeting
    "start_time": "2023-06-14T10:00:00",  # Use your desired date and time
    "duration": "45",  # Duration in minutes
    "timezone": "America/New_York",
    "agenda": "Discuss Zoom API Integration",
    "settings": {
        "host_video": True,
        "participant_video": True,
        "join_before_host": False,
        "mute_upon_entry": True,
        "watermark": False,
        "audio": "voip",
        "auto_recording": "none"
    }
}
# Function to create a meeting
def create_meeting():
    headers = {
        'authorization': 'Bearer ' + generate_token(),
        'content-type': 'application/json'
    }
    r = requests.post(
        f'https://api.zoom.us/v2/users/me/meetings',
        headers=headers, 
        data=json.dumps(meeting_details)
    )
    return r.json()
# Function to display meeting info
def display_meeting_info():
    response = create_meeting()
    
    join_url = response['join_url']
    meeting_password = response['password']
    print(f"Your meeting has been created!")
    print(f"Join URL: {join_url}")
    print(f"Password: {meeting_password}")
# Run the script
if __name__ == "__main__":
    display_meeting_info()

Running the Script

Now for the moment of truth! Let's run this script and see the magic happen.

1. Save the above code in a file, let's call it zoom_meeting_creator.py.

2. Open your terminal or command prompt.

3. Navigate to the directory where you saved the file.

4. Run the script by typing:
   
   

   python zoom_meeting_creator.py

Understanding the Output

When you run the script, you should see output similar to this:

Your meeting has been created!
Join URL: https://us04web.zoom.us/j/12345678901?pwd=abcdefghijklmnop
Password: 123456

Let's break down what's happening:

1. The script generates a JWT token for authentication.

2. It sends a request to Zoom's API to create a meeting with your specified details.

3. Zoom responds with the meeting information.

4. The script extracts and displays the Join URL and Password.

The Join URL is what you'd share with participants to join your meeting. The password adds an extra layer of security.

And there you have it! You've just created a Zoom meeting programmatically. Pretty neat, huh?

Remember, this is just the tip of the iceberg. You can expand this script to create multiple meetings, schedule recurring meetings, or even integrate it into a larger application. The possibilities are endless!