How to encode credentials

echo -n "YOUR_CLIENT_ID:YOUR_CLIENT_SECRET" | base64

Your credentials

client_id = "YOUR_CLIENT_ID" client_secret = "YOUR_CLIENT_SECRET" account_id = "YOUR_ACCOUNT_ID"

Encode credentials

credentials = f"{client_id}:{client_secret}" encoded_credentials = base64.b64encode(credentials.encode()).decode()

Request token

response = requests.post( "https://zoom.us/oauth/token", headers={ "Authorization": f"Basic {encoded_credentials}", "Content-Type": "application/x-www-form-urlencoded" }, params={ "grant_type": "account_credentials", "account_id": account_id } )

token_data = response.json() access_token = token_data["access_token"] print(f"Access token: {access_token}") print(f"Expires in: {token_data['expires_in']} seconds")

</details>
<details>
<summary>
  <strong>JavaScript (Node.js)</strong>
</summary>
```javascript
const axios = require('axios');
async function getAccessToken() {
  const clientId = 'YOUR_CLIENT_ID';
  const clientSecret = 'YOUR_CLIENT_SECRET';
  const accountId = 'YOUR_ACCOUNT_ID';
  // Encode credentials
  const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
  try {
    const response = await axios.post(
      'https://zoom.us/oauth/token',
      null,
      {
        headers: {
          'Authorization': `Basic ${credentials}`,
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        params: {
          grant_type: 'account_credentials',
          account_id: accountId
        }
      }
    );
    console.log('Access token:', response.data.access_token);
    console.log('Expires in:', response.data.expires_in, 'seconds');
    return response.data.access_token;
  } catch (error) {
    console.error('Authentication failed:', error.response.data);
  }
}
getAccessToken();

access_token = "YOUR_ACCESS_TOKEN"

response = requests.get( "https://api.zoom.us/v2/zoom_events/hubs", headers={ "Authorization": f"Bearer {access_token}", "Content-Type": "application/json" }, params={"role_type": "host"} )

hubs = response.json() print(f"Found {hubs['total_records']} hub(s):") for hub in hubs['hubs']: print(f" - {hub['name']} (ID: {hub['hub_id']})")

Store the first hub ID

hub_id = hubs['hubs'][0]['hub_id']

</details>
<details>
<summary>
  <strong>JavaScript (Node.js)</strong>
</summary>
```javascript
const axios = require('axios');
async function getHubId(accessToken) {
  try {
    const response = await axios.get(
      'https://api.zoom.us/v2/zoom_events/hubs',
      {
        headers: {
          'Authorization': `Bearer ${accessToken}`,
          'Content-Type': 'application/json'
        },
        params: {
          role_type: 'host'
        }
      }
    );
    const hubs = response.data;
    console.log(`Found ${hubs.total_records} hub(s):`);
    hubs.hubs.forEach(hub => {
      console.log(`  - ${hub.name} (ID: ${hub.hub_id})`);
    });
    return hubs.hubs[0].hub_id;
  } catch (error) {
    console.error('Failed to get hubs:', error.response.data);
  }
}

"timezone": "America/Los_Angeles",
"event_type": "SIMPLE_EVENT",
"access_level": "PRIVATE_UNRESTRICTED",
"meeting_type": "WEBINAR",
"attendance_type": "VIRTUAL",
"calendar": [
  {
    "start_time": "2025-12-15T18:00:00Z",
    "end_time": "2025-12-15T19:30:00Z"
  }
],
"tagline": "The future of product analytics starts here"

}'

</details>
<details>
<summary>
  <strong>Python</strong>
</summary>
```python
import requests
from datetime import datetime, timedelta, timezone
access_token = "YOUR_ACCESS_TOKEN"
hub_id = "abc123xyz"
# Create event happening in 30 days
event_date = datetime.now(timezone.utc) + timedelta(days=30)
start_time = event_date.replace(hour=18, minute=0, second=0)
end_time = start_time + timedelta(hours=1, minutes=30)
event_data = {
    "hub_id": hub_id,
    "name": "Introducing Project Phoenix",
    "timezone": "America/Los_Angeles",
    "event_type": "SIMPLE_EVENT",
    "access_level": "PRIVATE_UNRESTRICTED",
    "meeting_type": "WEBINAR",
    "attendance_type": "VIRTUAL",
    "calendar": [
      {
        "start_time": start_time.strftime("%Y-%m-%dT%H:%M:%SZ"),
        "end_time": end_time.strftime("%Y-%m-%dT%H:%M:%SZ")
      }
    ],
    "tagline": "The future of product analytics starts here"
}
response = requests.post(
    "https://api.zoom.us/v2/zoom_events/events",
    headers={
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"
    },
    json=event_data
)
event = response.json()
print(f"Event created")
print(f"   Event ID: {event['event_id']}")
print(f"   Name: {event['name']}")
print(f"   Status: {event['status']}")
print(f"   URL: {event.get('event_url', 'Not yet active (draft mode)')}")

async function createEvent(accessToken, hubId) { // Create event happening in 30 days const eventDate = new Date(); eventDate.setDate(eventDate.getDate() + 30); eventDate.setUTCHours(18, 0, 0, 0);

const startTime = eventDate.toISOString(); eventDate.setUTCHours(19, 30, 0, 0); const endTime = eventDate.toISOString();

const eventData = { hub_id: hubId, name: "Introducing Project Phoenix",

timezone: "America/Los_Angeles",
event_type: "SIMPLE_EVENT",
access_level: "PRIVATE_UNRESTRICTED",
meeting_type: "WEBINAR",
attendance_type: "VIRTUAL",
calendar: [
  {
    start_time: startTime,
    end_time: endTime
  }
],
tagline: "The future of product analytics starts here"

};

try { const response = await axios.post( 'https://api.zoom.us/v2/zoom_events/events', eventData, { headers: { 'Authorization': Bearer ${accessToken}, 'Content-Type': 'application/json' } } );

const event = response.data;
console.log('Event created');
console.log(`   Event ID: ${event.event_id}`);
console.log(`   Name: ${event.name}`);
console.log(`   Status: ${event.status}`);
console.log(`   URL: ${event.event_url || 'Not yet active (draft mode)'}`);
return event.event_id;

} catch (error) { console.error('Failed to create event:', error.response?.data || error.message); } }

</details>
**Expected response**
```json
{
  "event_id": "kNqLPC6hSFiZ9NpgjA549w",
  "name": "Introducing Project Phoenix",
  "timezone": "America/Los_Angeles",
  "event_type": "SIMPLE_EVENT",
  "status": "draft",
  "meeting_type": "WEBINAR",
  "hub_id": "abc123xyz",
  "calendar": [
    {
      "start_time": "2025-12-15T18:00:00Z",
      "end_time": "2025-12-15T19:30:00Z",
    }
  ],
  "event_url": "https://events.zoom.us/e/abc123xyz",
  "attendance_type": "VIRTUAL"
}

Important: Save the event_id. You will need it for all subsequent operations.

3.3 Verify your event configuration

Before publishing, double-check everything (some settings lock after publishing).

Review checklist

• Ensure the event name if accurate.
• Timezone correct for your audience.
• Event type matches your needs Remember: cannot change this.
• Start/end times correct.
• Meeting type appropriate webinar supports up to 100,000 attendees.
• Access level matches security requirements.

Pro tip: event_type and meeting_type (after registrations exist) are locked after publishing. Get them right now.

Step 4: Publish your event

Publishing activates all links and opens registration. After this, some settings lock.

</details>
<details>
<summary>
  <strong>JavaScript (Node.js)</strong>
</summary>
```javascript
async function publishEvent(accessToken, eventId) {
  try {
    const response = await axios.post(
      `https://api.zoom.us/v2/zoom_events/events/${eventId}/event_actions`,
      { operation: "publish" },
      {
        headers: {
          'Authorization': `Bearer ${accessToken}`,
          'Content-Type': 'application/json'
        }
      }
    );
    console.log('Event published');
    console.log(`   Status: ${response.data.status}`);
    console.log(`   Event ID: ${response.data.event_id}`);
  } catch (error) {
    console.error('Failed to publish event:', error.response?.data || error.message);
  }
}

Expected response

{
    "status": "published",
    "event_id": "kNqLPC6hSFiZ9NpgjA549w"
}

What just happened

1. All access links activated (registration page now live).
2. Automated confirmation emails enabled.
3. Registration opened for attendees.
4. Some settings now locked (event type, meeting type).

Get your registration link

Fetch the event details to get the live registration URL.

Response includes

{
    "event_id": "kNqLPC6hSFiZ9NpgjA549w",
    "name": "Introducing Project Phoenix",
    "status": "Published",
    "event_url": "https://events.zoom.us/e/abc123xyz"
}

Share this URL https://events.zoom.us/e/abc123xyz with your audience for public registration.

Step 5: Pre-register attendees (bonus)

Want to pre-register VIP attendees or import from your CRM? This section shows you how.

5.1 Get the default ticket type

Every published event has at least one ticket type. Get an ID:

Expected response

{
    "total_records": 1,
    "ticket_types": [
        {
            "ticket_type_id": "tt_abc123",
            "name": "Free Admission",
            "cost": 0,
            "currency": "USD"
        }
    ]
}

Note: The ticket_type_id: tt_abc123.

5.2 Create tickets for VIP attendees

Pre-register up to 30 attendees per request:

</details>
<details>
<summary>
  <strong>JavaScript (Node.js)</strong>
</summary>
```javascript
async function preRegisterAttendees(accessToken, eventId, ticketTypeId) {
  // VIP attendees from your CRM
  const vipAttendees = [
    { email: "sarah.chen@techcorp.com", first_name: "Sarah", last_name: "Chen" },
    { email: "james.wilson@partner.com", first_name: "James", last_name: "Wilson" },
    { email: "lisa.martinez@client.com", first_name: "Lisa", last_name: "Martinez" }
  ];
  const ticketsData = {
    tickets: vipAttendees.map(attendee => ({
      ...attendee,
      ticket_type_id: ticketTypeId
    }))
  };
  try {
    const response = await axios.post(
      `https://api.zoom.us/v2/zoom_events/events/${eventId}/tickets`,
      ticketsData,
      {
        headers: {
          'Authorization': `Bearer ${accessToken}`,
          'Content-Type': 'application/json'
        }
      }
    );
    console.log(`Pre-registered ${response.data.tickets.length} attendees`);
    response.data.tickets.forEach(ticket => {
      console.log(`   - ${ticket.first_name} ${ticket.last_name}: ${ticket.join_url}`);
    });
  } catch (error) {
    console.error('Failed to pre-register attendees:', error.response?.data || error.message);
  }
}

Expected response

{
    "tickets": [
        {
            "ticket_id": "tk_001",
            "email": "sarah.chen@techcorp.com",
            "event_join_link": "https://events.zoom.us/j/unique-join-link-1"
        },
        {
            "ticket_id": "tk_002",
            "email": "james.wilson@partner.com",
            "event_join_link": "https://events.zoom.us/j/unique-join-link-2"
        }
    ],
    "errors": []
}

What happened

Each attendee automatically received a confirmation email with their unique join link. They can click it to join the event when it starts.

Scaling tip: Batch pre-registrations in groups of 30 for optimal performance and rate limit compliance.

Common issues and solutions

Issue 1 - "Event is not published yet" (error 26501)

When it happens

Trying to create tickets before publishing the event.

Solution

Publish first, then create tickets.

# 1. Publish
POST /zoom_events/events/{eventId}/event_actions
{"operation": "publish"}
# 2. Then create tickets
POST /zoom_events/events/{eventId}/tickets

Issue 2 - "No permission to create event under hub" (error 26201)

When it happens

OAuth app missing required scopes or hub access denied.

Solution

1. Verify you added zoom_events:write:event:admin scope in OAuth app.
2. Confirm you have host/admin access to the hub.
3. Re-authenticate to get new token with updated scopes.

Issue 3 - Access token expired

When it happens: Making API calls after 1 hour (token expiry)

Solution

Implement token refresh in your code.

import time
def get_fresh_token():
    # Your token request logic from Step 1
    token_data = authenticate()
    expires_at = time.time() + token_data['expires_in']
    return token_data['access_token'], expires_at
# Use in your app
access_token, expires_at = get_fresh_token()
# Before each API call
if time.time() >= expires_at - 60:  # Refresh 1 min before expiry
    access_token, expires_at = get_fresh_token()

Issue 4 - Rate limit exceeded (HTTP 429)

When it happens

Too many API calls in a short time.

Solution

Implement exponential backoff.

import time
def api_call_with_retry(func, max_retries=3):
    for attempt in range(max_retries):
        try:
            return func()
        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 429:
                wait_time = 2 ** attempt  # 1s, 2s, 4s
                print(f"Rate limited. Waiting {wait_time}s...")
                time.sleep(wait_time)
            else:
                raise
    raise Exception("Max retries exceeded")

What you just accomplished

Congratulations! You have now:

• Set up OAuth authentication with automatic token management.
• Learned how to choose the right event type for your use case.
• Created and published your first live Zoom Event.
• Pre-registered attendees programmatically.
• Got a working integration that can handle real events.

Your event is now live at the registration URL, ready for attendees to sign up.

Quick reference

Essential endpoints

Authentication:
POST https://zoom.us/oauth/token
Hubs:
GET /zoom_events/hubs
Events:
POST   /zoom_events/events              (create)
GET    /zoom_events/events/{eventId}    (read)
PATCH  /zoom_events/events/{eventId}    (update)
POST   /zoom_events/events/{eventId}/event_actions  (publish/archive)
Tickets:
GET  /zoom_events/events/{eventId}/ticket_types
POST /zoom_events/events/{eventId}/tickets

Event type quick reference

Date time format

Always use ISO 8601 UTC format:

"start_time": "2025-12-15T18:00:00Z"

Additional resources

External documentation

• Zoom Developer Portal - API reference, OAuth setup
• OAuth Documentation - Authentication details
• Rate Limits - Request limits and best practices
• Webhook Reference - Real-time notifications

FAQ

Can I change the event type after creating an event?

No, event type is permanently locked at creation. If you need to change it, you must create a new event, migrate registrations, and delete the old event. Always choose carefully.

What is the difference between MEETING and WEBINAR for meeting_type?

This value is required only for single session Event.

• MEETING: Interactive experience, max 1,000 attendees, everyone can see each other
• WEBINAR: Broadcast-style, up to 100,000 attendees, only hosts or panelists visible

Cannot be changed after publishing if registrations exist.

Why isn't my registration link working after creating the event?

Events start in draft status with inactive links. You must publish the event first:

POST /zoom_events/events/{eventId}/event_actions
{"operation": "publish"}

How do I know which hub to use?

Use GET /zoom_events/hubs?role_type=host to list hubs. Choose based on:

• Team ownership (Marketing, Training, etc.)
• Content hub branding (if publishing recordings)
• Organizational structure

You must have host or admin permissions on the hub to create events.

Can I pre-register attendees before publishing the event?

No. Pre-registration (ticket creation) requires the event to be in published status. Attempting to create tickets in draft mode returns error 26501.

Correct order

1. Create event (draft).
2. Publish event.
3. Create tickets.

How many attendees can I add in one API call?

Up to 30 tickets per request for optimal performance. For larger lists:

# Batch in groups of 30
for i in range(0, len(attendees), 30):
    batch = attendees[i:i+30]
    create_tickets(batch)
    time.sleep(0.1)  # Rate limit compliance

Do attendees receive confirmation emails automatically?

Yes - When you create tickets via the API, Zoom automatically sends confirmation emails with unique join links to each attendee. You can also customize email templates in the event settings.

What timezone should I use for start_time and end_time?

Always use UTC (format: 2025-12-15T18:00:00Z). For SIMPLE_EVENT, include these in a calendar array. Set the event's local timezone separately using the timezone field. Zoom handles conversion for attendees.

How do I test my integration without creating real events?

Unfortunately, Webinars Plus & Events doesn't offer a sandbox environment. Best practices:

1. Create a test hub specifically for development.
2. Use obvious test names ("TEST - Do Not Register").
3. Delete test events after validation.
4. Start with draft events (links inactive) for safe testing.

Tutorial complete

You now have the foundation to build powerful Webinars Plus & Events integrations. Start with the examples in this guide, then explore the advanced topics in the next steps section as your needs grow.

Questions or feedback Check the Zoom Developer Forum or API Documentation.

Thank you for using the Webinars Plus & Events API