Usage

Zoom APIs use pagination to organize large response datasets into manageable chunks. This approach helps you efficiently handle substantial data payloads when making GET requests that list large numbers of resources.

Response limits

The number of items returned per page varies based on the API and data retrieval level:

Light data retrieval: Up to 300 items per page
Heavy data retrieval: Up to 30, 50, or 100 items per page, depending on the specific API

For details on light and heavy APIs, see the Rate limits documentation.

Using `next_page_token`

Most Zoom APIs, including List Meeting participants and List Webinars, use the next_page_token parameter for pagination.

If the initial API query returns a complete response, the next_page_token value will be an empty string.
A non-empty next_page_token value (e.g., "abc3445rg") indicates that additional results are available.

To retrieve additional responses, include the next_page_token value in subsequent API requests using the same query parameters.

A request to the List Meetings API can return a response with a next_page_token similar to:

{
    "from": "2024-02-07",
    "meetings": [
        {
            "duration": "05:27",
            "email": "jchill@example.com",
            "end_time": "2024-02-15T23:30:19Z",
            "has_recording": false,
            "id": 123456,
            "participants": 2,
            "start_time": "2024-02-15T23:24:52Z",
            "topic": "My Meeting",
            "user_type": "Pro|Webinar1000",
            "uuid": "abcd1234=="
        }
    ],
    "next_page_token": "def5678",
    "page_count": 5,
    "page_size": 1,
    "to": "2024-03-07",
    "total_records": 5
}

Example: List all users with `next_page_token`:

Reference: /docs/api/users

const axios = require("axios");
async function getAllUsers(baseUrl, accessToken) {
    let allUsers = [];
    let nextPageToken = "";
    while (true) {
        const headers = {
            Authorization: `Bearer ${accessToken}`,
            "Content-Type": "application/json",
        };
        const params = { page_size: 300 };
        if (nextPageToken) {
            params.next_page_token = nextPageToken;
        }
        try {
            const response = await axios.get(baseUrl, { headers, params });
            const data = response.data;
            allUsers = allUsers.concat(data.users || []);
            nextPageToken = data.next_page_token || "";
            if (!nextPageToken) {
                break;
            }
        } catch (error) {
            console.error("Error fetching users:", error.message);
            break;
        }
    }
    return allUsers;
}
// Usage
const baseUrl = "https://api.zoom.us/v2/users";
const accessToken = "YOUR_ACCESS_TOKEN";
getAllUsers(baseUrl, accessToken)
    .then((users) => console.log(`Total users retrieved: ${users.length}`))
    .catch((error) => console.error("Error:", error.message));

import requests
def get_all_users(base_url, access_token):
    all_users = []
    next_page_token = ''
    while True:
        headers = {
            "Authorization": f"Bearer {access_token}",
            "Content-Type": "application/json"
        }
        params = {"page_size": 300}
        if next_page_token:
            params["next_page_token"] = next_page_token
        response = requests.get(base_url, headers=headers, params=params)
        data = response.json()
        all_users.extend(data.get('users', []))
        next_page_token = data.get('next_page_token', '')
        if not next_page_token:
            break
    return all_users
# Usage
base_url = "https://api.zoom.us/v2/users"
access_token = "YOUR_ACCESS_TOKEN"
users = get_all_users(base_url, access_token)
print(f"Total users retrieved: {len(users)}")

Legacy pagination: page numbers

Some Zoom APIs, like List Users, support pagination using page_size and page_number parameters. However, this method is being phased out in favor of next_page_token.

page_size: Number of records to return per page
page_number: Specific page to retrieve

We recommend setting these values based on your needs, rather than relying on default values.

For example, a request to List Meetings with page_number and page_size parameters can return a response similar to:

{
    "meetings": [
        {
            "agenda": "Weekly standup",
            "created_at": "2024-03-14T21:14:55Z",
            "duration": 60,
            "id": 987654,
            "join_url": "https://zoom.us/j/987654",
            "start_time": "2024-03-15T22:00:00Z",
            "topic": "Team Meeting",
            "type": 2
        }
    ],
    "page_count": 1,
    "page_number": 1,
    "page_size": 1,
    "total_records": 2
}

Example: List users with page numbers

const axios = require("axios");
async function getAllUsers(baseUrl, accessToken) {
    let allUsers = [];
    let pageNumber = 1;
    const pageSize = 300;
    while (true) {
        const headers = {
            Authorization: `Bearer ${accessToken}`,
            "Content-Type": "application/json",
        };
        const params = {
            page_size: pageSize,
            page_number: pageNumber,
        };
        try {
            const response = await axios.get(baseUrl, { headers, params });
            const data = response.data;
            allUsers = allUsers.concat(data.users || []);
            if (pageNumber >= data.page_count) {
                break;
            }
            pageNumber++;
        } catch (error) {
            console.error("Error fetching users:", error.message);
            break;
        }
    }
    return allUsers;
}
// Usage
const baseUrl = "https://api.zoom.us/v2/users";
const accessToken = "YOUR_ACCESS_TOKEN";
getAllUsers(baseUrl, accessToken)
    .then((users) => console.log(`Total users retrieved: ${users.length}`))
    .catch((error) => console.error("Error:", error.message));

import requests
def get_all_users(base_url, access_token):
    all_users = []
    page_number = 1
    page_size = 300
    while True:
        headers = {
            "Authorization": f"Bearer {access_token}",
            "Content-Type": "application/json"
        }
        params = {
            "page_size": page_size,
            "page_number": page_number
        }
        response = requests.get(base_url, headers=headers, params=params)
        data = response.json()
        all_users.extend(data.get('users', []))
        if page_number >= data.get('page_count', 0):
            break
        page_number += 1
    return all_users
# Usage
base_url = "https://api.zoom.us/v2/users"
access_token = "YOUR_ACCESS_TOKEN"
users = get_all_users(base_url, access_token)
print(f"Total users retrieved: {len(users)}")