AutoGineer
Generated banner for Build Zoom Rest API App
Generated logo for Build Zoom Rest API App

Build Zoom Rest API App

OpenAIOfficialCreated by ZoomDistributed by OpenAI

  • Skill
  • Tool integration
  • Software development
  • MIT
  • Medium risk
Download ZIP

From the author

Use when calling REST APIs.
— the description by Zoom

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to interacting with the Zoom REST API. It offers guidance on selecting appropriate authentication flows, managing resources such as meetings and users, and implementing robust API interaction patterns like pagination and rate-limit handling. It includes reference documentation for various Zoom product areas, including account management and AI Companion services, to assist developers in building API-integrated applications.

What it does

  • Provides endpoint inventories for Zoom API product areas.
  • Outlines authentication requirements for user-level, account-level, and server-to-server workflows.
  • Defines patterns for implementing API wrappers with pagination and retry logic.
  • Offers guidance on webhook processing, including signature verification.
  • Assists in troubleshooting common API issues like scope mismatches and rate limits.

When to use it

  • When developing applications that need to programmatically manage Zoom meetings, users, or recordings.
  • When integrating Zoom account settings or dashboard metrics into custom software.
  • When setting up event-driven workflows using Zoom webhooks.
  • When debugging authentication or scope-related errors during Zoom API integration.

Advantages

  • Centralizes access to official Zoom API endpoint documentation.
  • Standardizes the implementation of API interaction patterns.
  • Clarifies the selection of correct authentication scopes for different API operations.
  • Provides a clear methodology for handling API rate limits and resource management.

Usage examples

“How do I list meeting participants using the Zoom API?”
The agent provides the correct endpoint path from the dashboard references and explains the necessary OAuth scopes and pagination requirements.
“What authentication should I use for an account-level Zoom integration?”
The agent guides you through the account-level OAuth flow requirements as defined in the authentication documentation.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/openai/build-zoom-rest-api-app/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip build-zoom-rest-api-app.zip -d .agents/skills

Documentation by Zoom

Build Zoom REST API App

Use this skill when the task needs deterministic Zoom API calls or resource management from application code.

Workflow

  1. Define the resource and actor: user, meeting, webinar, recording, docs, chat, phone, account, or admin-level workflow.

  2. Select the endpoint and required scopes from the reference files before coding.

  3. Confirm auth fit: user-level OAuth for user-owned resources, account-level OAuth for admin workflows, and only use server-to-server OAuth where the target API documents support for it.

  4. Implement narrow API wrappers with explicit pagination, retry, idempotency, and rate-limit handling.

  5. Treat webhook processing as a separate event-ingestion path with signature verification and replay protection.

  6. Debug by checking token audience, missing scopes, resource ownership, account settings, API enablement, and rate-limit headers.

References

Files

examples/meeting-lifecycle.md

Meeting Lifecycle - Complete CRUD with Webhook Integration

Complete working examples for the full meeting lifecycle: Create → Update → Start → End → Delete, with webhook event integration.

Prerequisites

  • Server-to-Server OAuth token (see Authentication Flows)

  • Scopes: meeting:write, meeting:read (minimum)

  • Base URL: https://api.zoom.us/v2

Step 1: Create a Meeting

Instant Meeting (No Fixed Time)
curl -X POST "https://api.zoom.us/v2/users/me/meetings" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "Quick Team Sync",
    "type": 1,
    "settings": {
      "join_before_host": false,
      "waiting_room": true,
      "approval_type": 2
    }
  }'
Scheduled Meeting
curl -X POST "https://api.zoom.us/v2/users/me/meetings" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type": application/json" \
  -d '{
    "topic": "Q1 Planning Meeting",
    "type": 2,
    "start_time": "2025-03-15T10:00:00Z",
    "duration": 60,
    "timezone": "America/New_York",
    "agenda": "Discuss Q1 goals and milestones",
    "settings": {
      "host_video": true,
      "participant_video": false,
      "join_before_host": false,
      "waiting_room": true,
      "mute_upon_entry": true,
      "approval_type": 2,
      "auto_recording": "cloud",
      "alternative_hosts": "[email protected]"
    }
  }'
Node.js Example
async function createMeeting(accessToken, meetingData) {
  const response = await fetch('https://api.zoom.us/v2/users/me/meetings', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(meetingData)
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Failed to create meeting: ${error.message}`);
  }

  return await response.json();
}

// Usage
const meetingData = {
  topic: 'Team Standup',
  type: 2,  // Scheduled
  start_time: '2025-03-15T14:00:00Z',
  duration: 30,
  settings: {
    join_before_host: false,
    waiting_room: true
  }
};

const meeting = await createMeeting(accessToken, meetingData);
console.log('Meeting created:', meeting.id);
console.log('Join URL:', meeting.join_url);
Response
{
  "id": 93123456789,
  "uuid": "xyzAbC1234==",
  "host_id": "abc123def456",
  "topic": "Q1 Planning Meeting",
  "type": 2,
  "start_time": "2025-03-15T10:00:00Z",
  "duration": 60,
  "timezone": "America/New_York",
  "created_at": "2025-02-09T12:30:00Z",
  "join_url": "https://zoom.us/j/93123456789",
  "start_url": "https://zoom.us/s/93123456789?zak=...",
  "settings": {
    "host_video": true,
    "participant_video": false,
    "waiting_room": true,
    "auto_recording": "cloud"
  }
}
Meeting Types
TypeValueDescription
Instant1Start immediately, no fixed time
Scheduled2Fixed date/time
Recurring (no fixed time)3PMI meetings
Recurring (fixed time)8Series with schedule

Step 2: Update a Meeting

Update Meeting Details
curl -X PATCH "https://api.zoom.us/v2/meetings/93123456789" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "Q1 Planning - Updated",
    "start_time": "2025-03-15T14:00:00Z",
    "duration": 90,
    "settings": {
      "waiting_room": false
    }
  }'
Node.js Example
async function updateMeeting(accessToken, meetingId, updates) {
  const response = await fetch(`https://api.zoom.us/v2/meetings/${meetingId}`, {
    method: 'PATCH',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(updates)
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Failed to update meeting: ${error.message}`);
  }

  // PATCH returns 204 No Content on success
  return response.status === 204;
}

// Usage
const updates = {
  topic: 'Q1 Planning - Updated Agenda',
  duration: 90
};

await updateMeeting(accessToken, 93123456789, updates);
console.log('Meeting updated successfully');
Partial Updates

You only need to include fields you want to change:

// Only update topic
await updateMeeting(accessToken, meetingId, {
  topic: 'New Topic'
});

// Only update settings
await updateMeeting(accessToken, meetingId, {
  settings: {
    waiting_room: true,
    mute_upon_entry: true
  }
});

Step 3: Get Meeting Details

curl "https://api.zoom.us/v2/meetings/93123456789" \
  -H "Authorization: Bearer ACCESS_TOKEN"
Node.js Example
async function getMeeting(accessToken, meetingId) {
  const response = await fetch(
    `https://api.zoom.us/v2/meetings/${meetingId}`,
    {
      headers: {
        'Authorization': `Bearer ${accessToken}`
      }
    }
  );

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Failed to get meeting: ${error.message}`);
  }

  return await response.json();
}

// Usage
const meeting = await getMeeting(accessToken, 93123456789);
console.log('Meeting:', meeting.topic);
console.log('Start time:', meeting.start_time);
console.log('Join URL:', meeting.join_url);

Step 4: List User's Meetings

curl "https://api.zoom.us/v2/users/me/meetings?type=scheduled&page_size=30" \
  -H "Authorization: Bearer ACCESS_TOKEN"
Node.js with Pagination
async function listAllMeetings(accessToken, userId = 'me') {
  let allMeetings = [];
  let nextPageToken = '';

  while (true) {
    const params = new URLSearchParams({
      type: 'scheduled',
      page_size: 300,
      ...(nextPageToken && { next_page_token: nextPageToken })
    });

    const response = await fetch(
      `https://api.zoom.us/v2/users/${userId}/meetings?${params}`,
      {
        headers: {
          'Authorization': `Bearer ${accessToken}`
        }
      }
    );

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`Failed to list meetings: ${error.message}`);
    }

    const data = await response.json();
    allMeetings = allMeetings.concat(data.meetings);

    nextPageToken = data.next_page_token;
    if (!nextPageToken) break;
  }

  return allMeetings;
}

// Usage
const meetings = await listAllMeetings(accessToken);
console.log(`Found ${meetings.length} meetings`);
meetings.forEach(m => console.log(`- ${m.topic} (${m.start_time})`));
Meeting List Types
TypeValueDescription
ScheduledscheduledFuture meetings
LiveliveCurrently active
UpcomingupcomingWithin next 30 days

Step 5: Delete a Meeting

curl -X DELETE "https://api.zoom.us/v2/meetings/93123456789" \
  -H "Authorization: Bearer ACCESS_TOKEN"
Node.js Example
async function deleteMeeting(accessToken, meetingId, options = {}) {
  const params = new URLSearchParams();

  // Optional: Cancel single occurrence of recurring meeting
  if (options.occurrenceId) {
    params.append('occurrence_id', options.occurrenceId);
  }

  // Optional: Send cancellation email
  if (options.scheduleForReminder !== undefined) {
    params.append('schedule_for_reminder', options.scheduleForReminder);
  }

  const url = `https://api.zoom.us/v2/meetings/${meetingId}${params.toString() ? '?' + params.toString() : ''}`;

  const response = await fetch(url, {
    method: 'DELETE',
    headers: {
      'Authorization': `Bearer ${accessToken}`
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Failed to delete meeting: ${error.message}`);
  }

  // DELETE returns 204 No Content on success
  return response.status === 204;
}

// Usage
await deleteMeeting(accessToken, 93123456789);
console.log('Meeting deleted successfully');

Webhook Integration

To receive real-time events for meeting lifecycle, set up webhooks. See Webhook Server Example for full implementation.

Key Meeting Events
EventWhen It Fires
meeting.createdMeeting is created
meeting.updatedMeeting details changed
meeting.deletedMeeting is deleted
meeting.startedMeeting begins
meeting.endedMeeting ends
meeting.participant_joinedParticipant joins
meeting.participant_leftParticipant leaves
recording.completedCloud recording finishes processing
Webhook Payload Example

Event: meeting.started

{
  "event": "meeting.started",
  "event_ts": 1707486720000,
  "payload": {
    "account_id": "abc123",
    "object": {
      "id": "93123456789",
      "uuid": "xyzAbC1234==",
      "host_id": "def456",
      "topic": "Q1 Planning Meeting",
      "type": 2,
      "start_time": "2025-03-15T14:00:00Z",
      "duration": 60,
      "timezone": "America/New_York"
    }
  }
}
Webhook Handler Example
// Express.js webhook endpoint
app.post('/webhook', express.json(), (req, res) => {
  const { event, payload } = req.body;

  switch (event) {
    case 'meeting.started':
      console.log(`Meeting started: ${payload.object.topic}`);
      // Trigger recording, send notifications, etc.
      break;

    case 'meeting.ended':
      console.log(`Meeting ended: ${payload.object.topic}`);
      // Process analytics, download recordings, etc.
      break;

    case 'recording.completed':
      console.log(`Recording ready: ${payload.object.topic}`);
      // Download recording (see recording-pipeline.md)
      break;

    default:
      console.log(`Unhandled event: ${event}`);
  }

  // Respond with 200 to acknowledge receipt
  res.status(200).send();
});

Complete Lifecycle Workflow

Automated Meeting Management
class MeetingManager {
  constructor(accessToken) {
    this.accessToken = accessToken;
  }

  async createScheduledMeeting(topic, startTime, duration = 60) {
    const meetingData = {
      topic,
      type: 2,
      start_time: startTime,
      duration,
      settings: {
        join_before_host: false,
        waiting_room: true,
        auto_recording: 'cloud'
      }
    };

    const meeting = await this.createMeeting(meetingData);
    console.log(`Created meeting: ${meeting.id}`);

    return meeting;
  }

  async updateMeetingTime(meetingId, newStartTime) {
    await this.updateMeeting(meetingId, {
      start_time: newStartTime
    });
    console.log(`Updated meeting ${meetingId} start time`);
  }

  async cancelMeeting(meetingId) {
    await this.deleteMeeting(meetingId, {
      schedule_for_reminder: true  // Send cancellation email
    });
    console.log(`Cancelled meeting ${meetingId}`);
  }

  async getUpcomingMeetings() {
    const meetings = await this.listAllMeetings();
    const now = new Date();

    return meetings.filter(m => {
      const startTime = new Date(m.start_time);
      return startTime > now;
    });
  }

  // Helper methods (implementations from above examples)
  async createMeeting(data) { /* ... */ }
  async updateMeeting(id, updates) { /* ... */ }
  async deleteMeeting(id, options) { /* ... */ }
  async listAllMeetings() { /* ... */ }
}

// Usage
const manager = new MeetingManager(accessToken);

// Create meeting
const meeting = await manager.createScheduledMeeting(
  'Team Standup',
  '2025-03-15T10:00:00Z',
  30
);

// Update if needed
await manager.updateMeetingTime(meeting.id, '2025-03-15T14:00:00Z');

// Get all upcoming meetings
const upcoming = await manager.getUpcomingMeetings();
console.log(`${upcoming.length} upcoming meetings`);

// Cancel if needed
await manager.cancelMeeting(meeting.id);

Common Patterns

Recurring Meeting Series
const recurringMeeting = {
  topic: 'Weekly Team Sync',
  type: 8,  // Recurring with fixed time
  start_time: '2025-03-15T10:00:00Z',
  duration: 30,
  recurrence: {
    type: 2,  // Weekly
    repeat_interval: 1,
    weekly_days: '1,3,5',  // Monday, Wednesday, Friday
    end_times: 20  // 20 occurrences
  }
};

const meeting = await createMeeting(accessToken, recurringMeeting);
Meeting with Registration
const meetingWithRegistration = {
  topic: 'Product Demo',
  type: 2,
  start_time: '2025-03-15T14:00:00Z',
  duration: 60,
  settings: {
    approval_type: 0,  // Automatic approval
    registration_type: 1,  // Attendees register once
    meeting_authentication: false
  }
};

const meeting = await createMeeting(accessToken, meetingWithRegistration);
console.log('Registration URL:', meeting.registration_url);
PMI Meeting
const pmiMeeting = {
  topic: 'My Personal Room',
  type: 3,  // Recurring with no fixed time (PMI)
  settings: {
    use_pmi: true,
    join_before_host: true
  }
};

const meeting = await createMeeting(accessToken, pmiMeeting);

Error Handling

Per-User Daily Limit

Meeting/webinar create/update operations are limited to 100 per day per user (resets at 00:00 UTC).

async function createMeetingWithRetry(accessToken, meetingData, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await createMeeting(accessToken, meetingData);
    } catch (error) {
      if (error.message.includes('Too many requests')) {
        console.log(`Hit per-user limit. Attempt ${attempt}/${maxRetries}`);
        if (attempt < maxRetries) {
          await sleep(5000);  // Wait 5 seconds
          continue;
        }
      }
      throw error;
    }
  }
}
Validation Errors
try {
  await createMeeting(accessToken, meetingData);
} catch (error) {
  if (error.message.includes('Invalid field')) {
    console.error('Validation error:', error);
    // Check start_time format, type value, etc.
  } else if (error.message.includes('User does not exist')) {
    console.error('Invalid userId');
  } else {
    throw error;
  }
}

Related Documentation

Resources

Requirements and compatibility

Written for: OpenAI Codex

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

What our scanner noticed· Medium risk

  • Possible data-exfiltration endpoints
  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Zoom
Publisher
OpenAI (Official)
Distributed by
OpenAI
Source
openai/plugins · plugins/zoom/skills/rest-api · commit d420d13
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from plugins/zoom/LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Zoom or OpenAI.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download build-zoom-rest-api-app.zip