AutoGineer
Generated banner for Zoom General
Generated logo for Zoom General

Zoom General

OpenAIOfficialCreated by ZoomDistributed by OpenAI

  • Skill
  • Tool integration
  • Automation and integrations
  • MIT
  • Medium risk
Download ZIP

From the author

Use when comparing products.
— the description by Zoom

AutoGineer summary

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

Zoom General serves as a strategic starting point for developers and architects to navigate the Zoom ecosystem. It provides a structured workflow to classify integration requirements, identify the correct Zoom product surface (such as APIs, SDKs, or webhooks), and determine the necessary authentication model. By guiding users through a decision-making process, it ensures that developers select the right tool for their specific use case before routing to more specialized skills.

What it does

  • Classifies integration jobs based on desired outcomes like embedding meetings or automating resources.
  • Maps requirements to specific Zoom surfaces including REST APIs, WebSockets, and various SDKs.
  • Provides guidance on selecting the correct authentication and scope model for an integration.
  • Facilitates routing to specialized skills once the product context is established.
  • Offers comparative context for tasks that span multiple Zoom product boundaries.

When to use it

  • When you are in the early stages of planning a Zoom integration and need to choose the right app type.
  • When you need to compare different Zoom surfaces to determine which fits your technical requirements.
  • When a task involves multiple Zoom products and requires a high-level architectural approach.
  • When you need to confirm the correct authentication flow for a specific integration scenario.

Advantages

  • Prevents premature selection of tools by enforcing a structured classification process.
  • Clarifies the distinction between user-level OAuth, account-level OAuth, and SDK signatures.
  • Reduces complexity by routing users to narrow, specialized skills after initial planning.
  • Provides a clear decision matrix for choosing between General Apps, Server-to-Server OAuth, and Webhook Only apps.

Usage examples

“I want to build an app that automates meeting reports. Which Zoom app type should I use?”
The agent will guide you to classify the job as backend automation, leading to the recommendation of Server-to-Server OAuth for its lack of user interaction requirements.
“Should I use the Meeting SDK or the Video SDK for my project?”
The agent will help you compare the two based on your specific embedding needs and surface requirements, ensuring you choose the correct SDK for your use case.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/openai/zoom-general/download

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

    mkdir -p .agents/skills && unzip zoom-general.zip -d .agents/skills

Documentation by Zoom

Zoom General

Use this skill for cross-product platform context after the user’s goal is understood. For first-step routing, prefer start, plan-zoom-product, or plan-zoom-integration.

Workflow

  1. Classify the job by outcome: embed meetings, custom video, automate resources, consume events, process media, use meeting intelligence, or publish a Marketplace app.

  2. Choose the Zoom surface that owns the behavior: REST API, webhooks, WebSockets, Meeting SDK, Video SDK, Zoom Apps SDK, Phone, Contact Center, Virtual Agent, Scribe, Rivet, or Cobrowse.

  3. Confirm auth and scope model before implementation; Zoom surfaces differ on user-level OAuth, account-level OAuth, and SDK signatures.

  4. Route to the narrow skill once the surface is chosen rather than keeping broad guidance in context.

  5. Use the preserved guide only when a task crosses product boundaries or needs detailed comparison tables.

References

Files

use-cases/prebuilt-video-ui.md

Pre-built Video UI with UI Toolkit

Build video conferencing apps in minutes using Zoom's ready-made UI components.

Use Case

You need to add video conferencing to your web application quickly without building custom UI from scratch. The Zoom Video SDK UI Toolkit provides a complete, production-ready video interface that works across frameworks.

When to Use UI Toolkit

  • ✅ Need video conferencing fast (hours, not weeks)

  • ✅ Want Zoom-like UI consistency

  • ✅ Don't have resources to build custom video UI

  • ✅ Need standard features (chat, share, participants, settings)

  • ✅ Want framework-agnostic solution (React, Vue, Angular, vanilla JS)

When NOT to Use (Use Raw Video SDK Instead)

  • ❌ Need complete custom UI control

  • ❌ Building non-standard video experiences

  • ❌ Need access to raw video/audio data for processing

  • ❌ Want custom rendering pipeline

Architecture

┌─────────────────────────────────────────────────────────────┐
│ Your Web Application                                        │
│                                                             │
│  ┌──────────────────────────────────────────────────────┐  │
│  │  Your Frontend (React/Vue/Angular/Vanilla JS)        │  │
│  │                                                        │  │
│  │  ┌──────────────────────────────────────────────┐    │  │
│  │  │  Zoom UI Toolkit                              │    │  │
│  │  │  ┌────────────────────────────────────────┐  │    │  │
│  │  │  │  Pre-built UI Components               │  │    │  │
│  │  │  │  • Video Grid/Gallery                  │  │    │  │
│  │  │  │  • Control Bar                         │  │    │  │
│  │  │  │  • Chat Panel                          │  │    │  │
│  │  │  │  • Participants List                   │  │    │  │
│  │  │  │  • Settings Panel                      │  │    │  │
│  │  │  └────────────────────────────────────────┘  │    │  │
│  │  │                                                │    │  │
│  │  │  ┌────────────────────────────────────────┐  │    │  │
│  │  │  │  Zoom Video SDK (Underlying Engine)   │  │    │  │
│  │  │  │  • WebRTC                              │  │    │  │
│  │  │  │  • Media Processing                    │  │    │  │
│  │  │  │  • Session Management                  │  │    │  │
│  │  │  └────────────────────────────────────────┘  │    │  │
│  │  └──────────────────────────────────────────────┘    │  │
│  └──────────────────────────────────────────────────────┘  │
│                                                             │
│  ┌──────────────────────────────────────────────────────┐  │
│  │  Your Backend (Node.js/Python/Any)                   │  │
│  │  ┌────────────────────────────────────────────────┐  │  │
│  │  │  JWT Generation Endpoint                        │  │  │
│  │  │  • Uses Video SDK Secret (NEVER expose!)        │  │  │
│  │  │  • Generates session tokens                     │  │  │
│  │  └────────────────────────────────────────────────┘  │  │
│  └──────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Implementation

1. Install UI Toolkit
npm install @zoom/videosdk-zoom-ui-toolkit
npm install react@18 react-dom@18  # Required peer dependency
2. Server-Side JWT Generation (Required)
// Backend: api/zoom-token/route.ts
import { KJUR } from 'jsrsasign';

export async function POST(request) {
  const { sessionName, role, userName } = await request.json();

  const payload = {
    app_key: process.env.ZOOM_VIDEO_SDK_KEY,
    role_type: role, // 0 = participant, 1 = host
    tpc: sessionName,
    version: 1,
    iat: Math.floor(Date.now() / 1000),
    exp: Math.floor(Date.now() / 1000) + 7200 // 2 hours
  };

  const token = KJUR.jws.JWS.sign(
    'HS256',
    JSON.stringify({ alg: 'HS256', typ: 'JWT' }),
    JSON.stringify(payload),
    process.env.ZOOM_VIDEO_SDK_SECRET
  );

  return Response.json({ signature: token });
}
3. Frontend Integration (React Example)
'use client';
import { useEffect, useRef } from 'react';

export default function VideoSession({ sessionName, userName }) {
  const containerRef = useRef<HTMLDivElement>(null);
  const uitoolkitRef = useRef<any>(null);

  useEffect(() => {
    let mounted = true;

    const init = async () => {
      // Fetch JWT from your backend
      const response = await fetch('/api/zoom-token', {
        method: 'POST',
        body: JSON.stringify({ sessionName, userName, role: 1 })
      });
      const { signature } = await response.json();

      // Import UI Toolkit
      const uitoolkitModule = await import('@zoom/videosdk-zoom-ui-toolkit');
      const uitoolkit = uitoolkitModule.default;
      uitoolkitRef.current = uitoolkit;

      // @ts-ignore
      await import('@zoom/videosdk-ui-toolkit/dist/videosdk-zoom-ui-toolkit.css');

      if (!mounted || !containerRef.current) return;

      // Configure session
      const config = {
        videoSDKJWT: signature,
        sessionName,
        userName,
        featuresOptions: {
          video: { enable: true },
          audio: { enable: true },
          share: { enable: true },
          chat: { enable: true },
          users: { enable: true },
          settings: { enable: true }
        }
      };

      // Join session
      uitoolkit.joinSession(containerRef.current, config);

      uitoolkit.onSessionJoined(() => console.log('Joined'));
      uitoolkit.onSessionClosed(() => console.log('Closed'));
    };

    init();

    return () => {
      mounted = false;
      if (uitoolkitRef.current && containerRef.current) {
        uitoolkitRef.current.closeSession(containerRef.current);
        uitoolkitRef.current.destroy();
      }
    };
  }, [sessionName, userName]);

  return <div ref={containerRef} style={{ width: '100%', height: '100vh' }} />;
}

That's it! You now have a fully functional video conferencing UI.

Features You Get Out-of-the-Box

FeatureDescription
Video GridGallery and speaker views with automatic switching
Audio ControlsMute/unmute, device selection, background noise suppression
Video ControlsCamera on/off, device selection, virtual backgrounds
Screen ShareShare screen/window with annotation support
ChatIn-session messaging with emoji support
ParticipantsUser list with host controls (mute, remove, etc.)
SettingsDevice management, quality statistics, theme selection
ReactionsEmoji reactions and raised hand

Customization Options

Choose Which Features to Enable
const config = {
  // ... other config
  featuresOptions: {
    preview: { enable: true },        // Pre-join device check
    video: { enable: true },
    audio: { enable: true },
    share: { enable: true },
    chat: { enable: true },
    users: { enable: true },
    settings: { enable: true },
    virtualBackground: {
      enable: true,
      virtualBackgrounds: [
        { url: '/bg1.jpg', displayName: 'Office' }
      ]
    },
    recording: { enable: false },     // Requires paid plan
    caption: { enable: false },       // Requires paid plan
    theme: {
      enable: true,
      defaultTheme: 'dark'            // 'light' | 'dark' | 'blue' | 'green'
    }
  }
};
Two UI Modes

Composite Mode (Full UI - Easiest):

// Single call gets you complete video UI
uitoolkit.joinSession(container, config);

Component Mode (Custom Layouts):

// Show individual pieces where you want
uitoolkit.joinSession(container, config);
uitoolkit.showControlsComponent(controlsContainer);
uitoolkit.showChatComponent(chatContainer);
uitoolkit.showUsersComponent(usersContainer);

Related Use Cases

Related Skills

  • zoom-ui-toolkit - Complete UI Toolkit documentation

  • zoom-video-sdk - Raw Video SDK (when UI Toolkit isn't enough)

  • zoom-general - General Zoom platform knowledge

Security Best Practices

  1. NEVER expose Video SDK Secret in frontend code

  2. ALWAYS generate JWT server-side using the secret

  3. Set appropriate JWT expiration (1-2 hours typical)

  4. Validate user identity before generating tokens

  5. Use HTTPS for production deployments

Production Checklist

  • [ ] JWT generation is server-side only

  • [ ] Proper cleanup on component unmount (uitoolkit.destroy())

  • [ ] Error handling for network issues

  • [ ] Loading states during JWT fetch

  • [ ] Testing across browsers (Chrome, Firefox, Safari, Edge)

  • [ ] Mobile responsive testing (if targeting mobile)

  • [ ] HTTPS enabled for production

  • [ ] Environment variables for SDK credentials

Development Time Comparison

ApproachDevelopment TimeEffort
UI Toolkit1-3 daysLow - Drop-in solution
Raw Video SDK2-4 weeksHigh - Build all UI
Meeting SDK3-5 daysMedium - Embed Zoom Meetings

When You Outgrow UI Toolkit

If you need more customization than UI Toolkit provides:

  1. Access underlying SDK:

    const client = uitoolkit.getClient(); // Get raw Video SDK client
uitoolkit.on('user-added', (payload) => {
  // Listen to 80+ raw SDK events
});

  2. Migrate to raw Video SDK:

    • Keep your JWT generation

    • Replace UI Toolkit with custom UI

    • Use same session/token architecture

    • See zoom-video-sdk for migration guide

Common Gotchas

  1. React 18 Required: UI Toolkit needs React 18 specifically (not 17 or 19)

  2. CSS Import: Must import videosdk-zoom-ui-toolkit.css or UI will be unstyled

  3. Cleanup Required: Always call destroy() on unmount to prevent memory leaks

  4. JWT Security: NEVER put SDK secret in frontend - always use server endpoint

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/general · 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 zoom-general.zip