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/customer-support-cobrowsing.md

Customer Support Co-Browsing

Enable real-time collaborative browsing between support agents and customers for efficient issue resolution and form completion assistance.

Use Case Overview

Problem: Customers struggle to describe issues or complete complex forms, leading to long support calls and high frustration.

Solution: Implement Zoom Cobrowse SDK to allow support agents to view and assist customers' browsers in real-time, with privacy controls for sensitive data.

Related Skills:

Architecture

┌──────────────────────┐         ┌──────────────────────┐
│  Customer Browser    │         │  Support Agent       │
│  • View form/page    │◄───────►│  • View customer     │
│  • Share PIN         │  Sync   │  • Provide guidance  │
│  • Get assistance    │         │  • Draw annotations  │
└──────────────────────┘         └──────────────────────┘
           │                                │
           └────────────┬───────────────────┘
                        ▼
              ┌──────────────────────┐
              │  Your Auth Server    │
              │  • Generate JWTs     │
              │  • Log sessions      │
              │  • Track agents      │
              └──────────────────────┘

Implementation Steps

1. Set Up Authentication Server
// server.js - JWT token generation
const express = require('express');
const { KJUR } = require('jsrsasign');

app.post('/cobrowse-token', (req, res) => {
  const { role, userId, userName, caseId } = req.body;

  const iat = Math.floor(Date.now() / 1000);
  const exp = iat + 60 * 60 * 2; // 2 hours

  const payload = {
    app_key: process.env.ZOOM_SDK_KEY,
    role_type: role,  // 1 = customer, 2 = agent
    user_id: userId,
    user_name: userName,
    iat,
    exp
  };

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

  // Log session for tracking
  logCobrowseSession(caseId, userId, role);

  res.json({ token });
});
2. Integrate Customer Support Page
<!-- support.html -->
<!DOCTYPE html>
<html>
<head>
  <script type="module">
    const ZOOM_SDK_KEY = 'YOUR_SDK_KEY';

    // Load Cobrowse SDK
    (function(r, a, b, f, c, d) {
      r[f] = r[f] || { init: function() { r.ZoomCobrowseSDKInitArgs = arguments }};
      var fragment = a.createDocumentFragment();
      function loadJs(url) {
        c = a.createElement(b);
        d = a.getElementsByTagName(b)[0];
        c["async"] = false;
        c.src = url;
        fragment.appendChild(c);
      }
      loadJs(`https://us01-zcb.zoom.us/static/resource/sdk/${ZOOM_SDK_KEY}/js/2.13.2`);
      d.parentNode.insertBefore(fragment, d);
    })(window, document, "script", "ZoomCobrowseSDK");
  </script>
</head>
<body>
  <div id="support-widget">
    <button id="start-cobrowse">Get Support Help</button>
    <div id="pin-display" style="display:none;">
      <p>Share this PIN with your support agent:</p>
      <div id="pin-code"></div>
    </div>
  </div>

  <!-- Customer form with sensitive fields -->
  <form id="customer-form">
    <input name="name" placeholder="Full Name">
    <input name="email" placeholder="Email">
    <input name="ssn" class="pii-mask" placeholder="SSN">
    <input name="account" class="pii-mask" placeholder="Account Number">
  </form>

  <script>
    let sessionRef = null;

    const settings = {
      allowAgentAnnotation: true,    // Agent can highlight fields
      allowCustomerAnnotation: false, // Customer can't annotate
      piiMask: {
        maskType: "custom_input",
        maskCssSelectors: ".pii-mask"  // Hide sensitive fields from agent
      }
    };

    ZoomCobrowseSDK.init(settings, function({ success, session, error }) {
      if (success) {
        sessionRef = session;

        session.on("pincode_updated", (payload) => {
          document.getElementById("pin-code").innerText = payload.pincode;
          document.getElementById("pin-display").style.display = "block";
        });

        session.on("agent_joined", () => {
          console.log("Support agent connected");
          showNotification("Agent is now viewing your screen");
        });
      }
    });

    document.getElementById("start-cobrowse").addEventListener("click", async () => {
      const caseId = getCurrentCaseId();

      const response = await fetch("/cobrowse-token", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          role: 1,
          userId: "customer_" + Date.now(),
          userName: "Customer",
          caseId: caseId
        })
      });

      const { token } = await response.json();
      sessionRef.start({ sdkToken: token });
    });
  </script>
</body>
</html>
3. Agent Portal Integration
<!-- agent-portal.html -->
<!DOCTYPE html>
<html>
<head>
  <title>Support Agent - Co-Browse</title>
</head>
<body>
  <div class="agent-dashboard">
    <div class="case-info">
      <h2>Case #<span id="case-id"></span></h2>
      <p>Customer: <span id="customer-name"></span></p>
    </div>

    <iframe
      id="cobrowse-frame"
      width="1024"
      height="768"
      allow="autoplay *; camera *; microphone *; display-capture *; geolocation *;"
    ></iframe>
  </div>

  <script>
    async function loadCobrowseSession(caseId) {
      const response = await fetch("/cobrowse-token", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          role: 2,
          userId: "agent_" + Date.now(),
          userName: getAgentName(),
          caseId: caseId
        })
      });

      const { token } = await response.json();

      const iframe = document.getElementById("cobrowse-frame");
      iframe.src = `https://us01-zcb.zoom.us/sdkapi/zcb/frame-templates/desk?access_token=${token}`;
    }

    // Load cobrowse when case requires it
    const caseId = getCurrentCaseId();
    loadCobrowseSession(caseId);
  </script>
</body>
</html>

Key Features

Privacy Masking

Automatically hide sensitive customer data:

const settings = {
  piiMask: {
    maskType: "custom_input",
    maskCssSelectors: ".pii-mask, .sensitive, [data-private]",
    maskHTMLAttributes: "data-private=true"
  }
};

What gets masked:

  • Social Security Numbers

  • Credit Card Numbers

  • Bank Account Numbers

  • Passwords

  • Any field with .pii-mask class

Annotation Tools

Agents can guide customers visually:

  • Pen tool: Highlight form fields

  • Rectangle: Circle important sections

  • Pointer: Direct attention to specific elements

Session Management

Track and log all cobrowse sessions:

function logCobrowseSession(caseId, userId, role) {
  const log = {
    caseId,
    userId,
    role: role === 1 ? 'customer' : 'agent',
    timestamp: new Date(),
    sessionType: 'cobrowse'
  };

  database.sessions.insert(log);
}

Use Case Scenarios

Scenario 1: Complex Form Assistance

Context: Customer struggles with multi-step insurance application

Flow:

  1. Customer clicks "Get Help" on form page

  2. PIN generated and displayed

  3. Customer calls support, shares PIN

  4. Agent enters PIN, sees customer's form

  5. Agent uses annotation to highlight next field

  6. Customer fills form with real-time guidance

  7. Sensitive fields (SSN, medical info) masked from agent

Outcome: Form completed in 5 minutes vs 20 minutes phone call

Scenario 2: Technical Troubleshooting

Context: Customer can't find account settings

Flow:

  1. Customer initiates cobrowse from help chat

  2. Agent joins session

  3. Agent uses pointer to show navigation path

  4. Customer follows visual guidance

  5. Issue resolved in real-time

Outcome: No screen sharing software needed, instant resolution

Scenario 3: Onboarding New Users

Context: First-time user needs guided tour

Flow:

  1. Onboarding specialist starts cobrowse

  2. Customer joins via PIN

  3. Specialist guides through features

  4. Annotations highlight key functions

  5. Customer follows along in their browser

Outcome: Interactive onboarding, higher completion rate

Security Considerations

1. Privacy Compliance
// GDPR/CCPA compliant data handling
const privacySettings = {
  piiMask: {
    maskType: "custom_input",
    maskCssSelectors: ".pii-mask"
  },
  sessionRecording: false,  // Don't record sessions
  dataRetention: "24h"      // Auto-delete session logs
};
2. Agent Authentication
// Verify agent credentials before token generation
async function validateAgent(agentId) {
  const agent = await database.agents.findOne({ id: agentId });

  if (!agent || !agent.cobrowseEnabled) {
    throw new Error("Agent not authorized for cobrowse");
  }

  return agent;
}
3. Session Limits

  • Max 5 agents per customer session

  • 2-hour token expiration

  • Automatic session end on inactivity (10 minutes)

  • HTTPS required for all connections

Metrics and Analytics

Track cobrowse effectiveness:

// Track session metrics
const metrics = {
  sessionDuration: calculateDuration(startTime, endTime),
  issueResolved: true,
  customerSatisfaction: 5,
  formFieldsCompleted: 12,
  annotationsUsed: 8
};

analytics.track('cobrowse_session_completed', metrics);

Key Metrics:

  • Average session duration

  • Issue resolution rate

  • Customer satisfaction (CSAT)

  • Time saved vs phone support

  • Conversion rate (form completion)

Integration with Existing Systems

Salesforce Integration
// Log cobrowse session to Salesforce case
async function logToSalesforce(caseId, sessionData) {
  await salesforce.cases.update(caseId, {
    Cobrowse_Session_Date__c: new Date(),
    Cobrowse_PIN__c: sessionData.pin,
    Agent_Id__c: sessionData.agentId,
    Session_Duration__c: sessionData.duration
  });
}
Zendesk Integration
// Add cobrowse note to Zendesk ticket
await zendesk.tickets.addComment(ticketId, {
  body: `Cobrowse session completed. PIN: ${pin}. Duration: ${duration}`,
  public: false
});

Best Practices

  1. Clear Privacy Disclosure

    • Inform customer what agent can see

    • Display "Agent is viewing your screen" banner

  2. Selective Masking

    • Mask by default, unmask if needed

    • Use .pii-mask class liberally

  3. Session Logging

    • Track all sessions for compliance

    • Log agent actions for quality assurance

  4. Agent Training

    • Train agents on privacy controls

    • Establish annotation best practices

  5. Customer Consent

    • Get explicit consent before starting

    • Allow customer to end session anytime

Cost Considerations

Zoom SDK Pricing:

  • Pay per cobrowse minute

  • SDK Universal Credits required

  • See Zoom pricing

Estimated Costs:

  • 100 sessions/day × 10 min avg = 1,000 minutes/day

  • ~$30-50/day depending on plan

Related Resources

Common Issues

Issue: Customer can't see PIN Solution: Check pincode_updated event handler is properly attached

Issue: Agent sees sensitive data Solution: Verify .pii-mask class applied to sensitive fields

Issue: Session disconnects on page refresh Solution: Implement auto-reconnection pattern (see Auto-Reconnection)

Next Steps

  1. Review Get Started Guide

  2. Set up auth server using JWT Authentication

  3. Integrate customer page with Customer Integration

  4. Deploy agent portal with Agent Integration

  5. Test privacy masking with Privacy Masking Example

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