AutoGineer
Generated banner for Zoom General
Generated logo for Zoom General

Zoom General

AnthropicOfficialCreated by ZoomDistributed by Anthropic

  • Skill
  • Meta (authoring, orchestration, planning, memory)
  • Agent tooling
  • MIT
  • Medium risk
Download ZIP

From the author

Cross-product Zoom reference skill. Use after the workflow is clear when you need shared platform guidance, app-model comparisons, authentication context, scopes, marketplace considerations, or API-vs-MCP routing.
— the description by Zoom

AutoGineer summary

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

The zoom-general skill serves as the primary entry point and classification layer for developers working with the Zoom platform. It provides a structured framework to identify the correct Zoom product, SDK, or API path based on user intent. It includes logic for routing complex queries, chaining multiple skills (such as combining REST APIs with OAuth and webhooks), and resolving ambiguities between deterministic automation and AI-driven agentic workflows.

What it does

  • Classifies developer queries to identify the appropriate Zoom product or SDK.
  • Provides a routing matrix to distinguish between REST API, MCP, and SDK use cases.
  • Offers guidance on choosing the correct Zoom app type (General, S2S, or Webhook-only).
  • Facilitates skill chaining for multi-step integrations like OAuth and webhook setups.
  • Provides decision frameworks for API vs. MCP and SDK vs. REST implementation paths.
  • Acts as a central index for all specialized Zoom developer skills.

When to use it

  • When you are unsure which Zoom SDK or API is required for your project.
  • When you need to determine if your task requires REST APIs, MCP tools, or a hybrid approach.
  • When planning a complex integration that involves authentication, webhooks, and API orchestration.
  • When you need to compare different Zoom app types to match your architectural requirements.
  • When you need to resolve ambiguity between similar Zoom products like Meeting SDK and Video SDK.

Advantages

  • Reduces development friction by directing users to the most relevant documentation and skills.
  • Ensures architectural consistency by enforcing standard routing patterns.
  • Simplifies complex decision-making through clear matrices and guardrails.
  • Promotes best practices for authentication and event-driven design.
  • Provides a unified entry point for navigating the entire Zoom developer ecosystem.

Usage examples

“I want to build a custom video UI for a Zoom meeting on the web, what should I use?”
The skill identifies the requirement for a custom UI around a real meeting and routes the user to the zoom-meeting-sdk-web-component-view skill.
“Should I use the REST API or MCP for my AI agent?”
The skill provides the API vs. MCP routing matrix, explaining that REST is for deterministic automation while MCP is for dynamic AI tool orchestration.
“How do I set up a server-side integration that handles meetings and webhooks?”
The skill suggests the Rivet SDK for scaffolding or chains the zoom-rest-api, zoom-oauth, and zoom-webhooks skills.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/anthropics/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 (Cross-Product Skills)

Background reference for cross-product Zoom questions. Prefer the workflow skills first, then use this file for shared platform guidance and routing detail.

How zoom-general Routes a Complex Developer Query

Use zoom-general as the classifier and chaining layer:

  1. detect product signals in the query

  2. pick one primary skill

  3. attach secondary skills for auth, events, or deployment edges

  4. ask one short clarifier only when two routes match with similar confidence

Minimal implementation:

type SkillId =
  | 'zoom-general'
  | 'zoom-rest-api'
  | 'zoom-webhooks'
  | 'zoom-oauth'
  | 'zoom-meeting-sdk-web-component-view'
  | 'zoom-video-sdk'
  | 'zoom-mcp';

const hasAny = (q: string, words: string[]) => words.some((w) => q.includes(w));

function detectSignals(rawQuery: string) {
  const q = rawQuery.toLowerCase();
  return {
    meetingCustomUi: hasAny(q, ['zoom meeting', 'custom ui', 'component view', 'embed meeting']),
    customVideo: hasAny(q, ['video sdk', 'custom video session', 'peer-video-state-change']),
    restApi: hasAny(q, ['rest api', '/v2/', 'create meeting', 'list users', 's2s oauth']),
    webhooks: hasAny(q, ['webhook', 'x-zm-signature', 'event subscription', 'crc']),
    oauth: hasAny(q, ['oauth', 'pkce', 'token refresh', 'account_credentials']),
    mcp: hasAny(q, ['zoom mcp', 'agentic retrieval', 'tools/list', 'semantic meeting search']),
  };
}

function pickPrimarySkill(s: ReturnType<typeof detectSignals>): SkillId {
  if (s.meetingCustomUi) return 'zoom-meeting-sdk-web-component-view';
  if (s.mcp) return 'zoom-mcp';
  if (s.restApi) return 'zoom-rest-api';
  if (s.customVideo) return 'zoom-video-sdk';
  return 'zoom-general';
}

function buildChain(primary: SkillId, s: ReturnType<typeof detectSignals>): SkillId[] {
  const chain = [primary];
  if (s.oauth && !chain.includes('zoom-oauth')) chain.push('zoom-oauth');
  if (s.webhooks && !chain.includes('zoom-webhooks')) chain.push('zoom-webhooks');
  return chain;
}

Example:

  • Create a meeting, configure webhooks, and handle OAuth token refresh -> zoom-rest-api -> zoom-oauth -> zoom-webhooks

  • Build a custom video UI for a Zoom meeting on web -> zoom-meeting-sdk-web-component-view

For the full TypeScript implementation and handoff contract, use references/routing-implementation.md.

Choose Your Path

I want to...Use this skill
Build a custom web UI around a real Zoom meetingzoom-meeting-sdk-web-component-view
Build deterministic automation/configuration/reporting with explicit request controlzoom-rest-api
Receive event notifications (HTTP push)zoom-webhooks
Receive event notifications (WebSocket, low-latency)zoom-websockets
Embed Zoom meetings in my appzoom-meeting-sdk
Build custom video experiences (Web, React Native, Flutter, Android, iOS, macOS, Unity, Linux)zoom-video-sdk
Build an app that runs inside Zoom clientzoom-apps-sdk
Transcribe uploaded or stored media with AI Services Scribescribe
Access live audio/video/transcripts from meetingszoom-rtms
Enable collaborative browsing for supportzoom-cobrowse-sdk
Build Contact Center apps and channel integrationscontact-center
Build Virtual Agent web/mobile chatbot experiencesvirtual-agent
Build Zoom Phone integrations (Smart Embed, Phone API, webhooks, URI flows)phone
Build Team Chat apps and integrationszoom-team-chat
Build server-side integrations with Rivet (auth + webhooks + APIs)rivet-sdk
Run browser/device/network preflight diagnostics before joinprobe-sdk
Add pre-built UI components for Video SDKzoom-ui-toolkit
Implement OAuth authentication (all grant types)zoom-oauth
Build AI-driven tool workflows (AI Companion/agents) over Zoom datazoom-mcp
Build AI-driven Whiteboard workflows over Zoom Whiteboard MCPzoom-mcp/whiteboard
Build enterprise AI systems with stable API core + AI tool layerzoom-rest-api + zoom-mcp

Planning Checkpoint: Rivet SDK (Optional)

When a user starts planning a server-side integration that combines auth + webhooks + API calls, ask this first:

  • Rivet SDK is a Node.js framework that bundles Zoom auth handling, webhook receivers, and typed API wrappers.

  • Do you want to use Rivet SDK for faster scaffolding, or do you prefer a direct OAuth + REST implementation without Rivet?

Routing after answer:

  • If user chooses Rivet: chain rivet-sdk + oauth + rest-api.

  • If user declines Rivet: chain oauth + rest-api (+ webhooks or product skill as needed).

SDK vs REST Routing Matrix (Hard Stop)
User intentCorrect pathDo not route to
Embed Zoom meeting in app UIzoom-meeting-sdkREST-only join_url flow
Build custom web UI for a real Zoom meetingzoom-meeting-sdk-web-component-viewzoom-video-sdk
Build custom video UI/session appzoom-video-sdkMeeting SDK or REST meeting links
Get browser join links / manage meeting resourceszoom-rest-apiMeeting SDK join implementation

Routing guardrails:

  • If user asks for SDK embed/join behavior, stay in SDK path.

  • If the prompt says meeting plus custom UI/video/layout/embed, prefer zoom-meeting-sdk-web-component-view.

  • Only use zoom-video-sdk when the user is building a custom session product rather than a Zoom meeting.

  • Only use REST path for resource management, reporting, or link distribution unless user explicitly requests a mixed architecture.

  • For executable classification/chaining logic and error handling, see references/routing-implementation.md.

API vs MCP Routing Matrix (Hard Stop)
User intentCorrect pathWhy
Deterministic backend automation, account/user configuration, reporting, scheduled jobszoom-rest-apiExplicit request/response control and repeatable behavior
AI agent chooses tools dynamically, cross-platform AI tool interoperabilityzoom-mcpMCP is optimized for dynamic tool discovery and agentic workflows
Enterprise AI architecture (stable core + adaptive AI layer)zoom-rest-api + zoom-mcpAPIs run core system actions; MCP exposes curated AI tools/context

Routing guardrails:

  • Do not replace deterministic backend APIs with MCP-only routing.

  • Do not force raw REST-first routing when the task is AI-agent tool orchestration.

  • Prefer hybrid routing when the user needs both stable automation and AI-driven interactions.

  • MCP remote server works over Streamable HTTP/SSE; use this path when the target client/agent supports MCP transports (for example Claude or VS Code).

  • Do not design per-tenant custom MCP endpoint provisioning; Zoom MCP endpoints are shared at instance/cluster level.

  • Source: https://developers.zoom.us/docs/mcp/library/resources/apis-vs-mcp/

Ambiguity Resolution (Ask Before Routing)

When a prompt matches both API and MCP paths with similar confidence, ask one short clarifier before execution:

  • Do you want deterministic REST API automation, AI-agent MCP tooling, or a hybrid of both?

Then route as:

  • REST answer → zoom-rest-api

  • MCP answer → zoom-mcp

  • Hybrid answer → zoom-rest-api + zoom-mcp

MCP Availability and Topology Notes

  • Zoom-hosted MCP access is evolving; docs indicate a model where Zoom exposes product-scoped MCP servers (for example Meetings, Team Chat, Whiteboard).

  • Use zoom-mcp as the parent MCP entry point.

  • Route Whiteboard-specific MCP requests to zoom-mcp/whiteboard.

  • When a request is product-specific and MCP coverage exists, route to that MCP product surface first; otherwise use REST/SDK skills for deterministic implementation.

Webhooks vs WebSockets

Both receive event notifications, but differ in approach:

Aspectwebhookszoom-websockets
ConnectionHTTP POST to your endpointPersistent WebSocket
LatencyHigherLower
SecurityRequires public endpointNo exposed endpoint
SetupSimplerMore complex
Best forMost use casesReal-time, security-sensitive

Common Use Cases

Use CaseDescriptionSkills Needed
Meeting + Webhooks + OAuth RefreshCreate a meeting, process real-time updates, and refresh OAuth tokens safely in one designzoom-rest-api + zoom-oauth + zoom-webhooks
Scribe Transcription PipelineTranscribe uploaded files or S3 archives with AI Services Scribe using fast mode or batch jobsscribe + optional zoom-rest-api + optional zoom-webhooks
APIs vs MCP RoutingDecide whether to route to deterministic Zoom APIs, AI-driven MCP, or a hybrid designzoom-rest-api and/or zoom-mcp
Custom Meeting UI (Web)Build a custom video UI for a real Zoom meeting in a web app using Meeting SDK Component Viewzoom-meeting-sdk-web-component-view + zoom-oauth
Meeting AutomationSchedule, update, delete meetings programmaticallyzoom-rest-api
Meeting BotsBuild bots that join meetings for AI/transcription/recordingmeeting-sdk/linux + zoom-rest-api + optional zoom-webhooks
High-Volume Meeting PlatformDesign distributed meeting creation and event processing with retries, queues, and reconciliationzoom-rest-api + zoom-webhooks + zoom-oauth
Recording & TranscriptionDownload recordings, get transcriptszoom-webhooks + zoom-rest-api
Recording Download PipelineAuto-download recordings to your own storage (S3, GCS, etc.)zoom-webhooks + zoom-rest-api
Real-Time Media StreamsAccess live audio, video, transcripts via WebSocketzoom-rtms + zoom-webhooks
In-Meeting AppsBuild apps that run inside Zoom meetingszoom-apps-sdk + zoom-oauth
React Native Meeting EmbedEmbed meetings into iOS/Android React Native appszoom-meeting-sdk-react-native + zoom-oauth
Native Meeting SDK Multi-Platform DeliveryAlign Android, iOS, macOS, and Unreal Meeting SDK implementations under one auth/version strategyzoom-meeting-sdk + platform skills
Native Video SDK Multi-Platform DeliveryAlign Android, iOS, macOS, and Unity Video SDK implementations under one auth/version strategyzoom-video-sdk + platform skills
Electron Meeting EmbedEmbed meetings into desktop Electron appszoom-meeting-sdk-electron + zoom-oauth
Flutter Video SessionsBuild custom mobile video sessions in Flutterzoom-video-sdk-flutter + zoom-oauth
React Native Video SessionsBuild custom mobile video sessions in React Nativezoom-video-sdk-react-native + zoom-oauth
Immersive ExperiencesCustom video layouts with Layers APIzoom-apps-sdk
Collaborative AppsReal-time shared state in meetingszoom-apps-sdk
Contact Center App Lifecycle and Context SwitchingBuild Contact Center apps that handle engagement events and multi-engagement statecontact-center + zoom-apps-sdk
Virtual Agent Campaign Web and Mobile WrapperDeliver one campaign-driven bot flow across web and native mobile wrappersvirtual-agent + contact-center
Virtual Agent Knowledge Base Sync PipelineSync external knowledge content into Zoom Virtual Agent using web sync or custom API connectorsvirtual-agent + zoom-rest-api + zoom-oauth
Zoom Phone Smart Embed CRM IntegrationBuild CRM dialer and call logging flows using Smart Embed plus Phone APIsphone + zoom-oauth + zoom-webhooks
Rivet Event-Driven API OrchestratorBuild a Node.js backend that combines webhooks and API actions through Rivet module clientsrivet-sdk + zoom-oauth + zoom-rest-api
Probe SDK Preflight Readiness GateAdd browser/device/network diagnostics and readiness policy before Meeting SDK or Video SDK joinsprobe-sdk + zoom-meeting-sdk or zoom-video-sdk

Complete Use-Case Index

Prerequisites

  1. Zoom account (Pro, Business, or Enterprise)

  2. App created in Zoom App Marketplace

  3. OAuth credentials (Client ID and Secret)

References

Quick Start

  1. Go to marketplace.zoom.us

  2. Click Develop → Build App

  3. Select app type (see references/app-types.md)

  4. Configure OAuth and scopes

  5. Copy credentials to your application

Detailed References

SDK Maintenance

Resources

Environment Variables

Operations

  • RUNBOOK.md - 5-minute preflight and debugging checklist.

Files

use-cases/form-completion-assistant.md

Form Completion Assistant with Co-Browsing

Guide customers through complex forms in real-time using visual assistance and privacy-protected co-browsing.

Use Case Overview

Problem: High form abandonment rates due to complexity, confusion, or lack of confidence in data entry.

Solution: Implement Zoom Cobrowse SDK to provide real-time visual guidance while protecting sensitive customer data through privacy masking.

Related Skills:

Target Scenarios

Financial Services

  • Loan applications

  • Account opening forms

  • Investment questionnaires

  • Insurance claims

Healthcare

  • Patient intake forms

  • Insurance enrollment

  • Medical history questionnaires

  • Telehealth registration

E-Commerce

  • Complex checkout flows

  • B2B order forms

  • Subscription sign-ups

  • Custom product configurators

Implementation

Quick Start Pattern
<!DOCTYPE html>
<html>
<head>
  <title>Loan Application - Form Assistant</title>
  <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 class="form-header">
    <h1>Loan Application</h1>
    <button id="help-btn">Need Help Completing This Form?</button>
  </div>
  
  <form id="loan-application">
    <!-- Step 1: Personal Information -->
    <section class="form-step" data-step="1">
      <h2>Personal Information</h2>
      <input name="firstName" placeholder="First Name" required>
      <input name="lastName" placeholder="Last Name" required>
      <input name="email" type="email" placeholder="Email" required>
      <input name="phone" type="tel" placeholder="Phone Number" required>
    </section>
    
    <!-- Step 2: Sensitive Information (MASKED) -->
    <section class="form-step" data-step="2">
      <h2>Identification</h2>
      <input name="ssn" class="pii-mask" placeholder="SSN" 
             pattern="[0-9]{3}-[0-9]{2}-[0-9]{4}">
      <small>🔒 This field is hidden from support agents</small>
      
      <input name="dob" class="pii-mask" type="date" placeholder="Date of Birth">
      <small>🔒 This field is hidden from support agents</small>
    </section>
    
    <!-- Step 3: Financial Information (PARTIALLY MASKED) -->
    <section class="form-step" data-step="3">
      <h2>Financial Information</h2>
      <input name="income" type="number" placeholder="Annual Income">
      <input name="employer" placeholder="Employer Name">
      
      <input name="accountNumber" class="pii-mask" placeholder="Bank Account Number">
      <small>🔒 This field is hidden from support agents</small>
      
      <input name="routingNumber" class="pii-mask" placeholder="Routing Number">
      <small>🔒 This field is hidden from support agents</small>
    </section>
    
    <!-- Step 4: Loan Details -->
    <section class="form-step" data-step="4">
      <h2>Loan Request</h2>
      <input name="loanAmount" type="number" placeholder="Requested Amount">
      <select name="loanPurpose">
        <option value="">Select Purpose</option>
        <option value="home">Home Purchase</option>
        <option value="auto">Auto Purchase</option>
        <option value="personal">Personal</option>
      </select>
    </section>
  </form>
  
  <div id="help-widget" style="display:none;">
    <p>Share this PIN with your support agent:</p>
    <div id="pin-code"></div>
    <button id="end-session">End Assistance</button>
  </div>
  
  <script>
    let sessionRef = null;
    let currentStep = 1;
    
    const settings = {
      allowAgentAnnotation: true,     // Agent can highlight fields
      allowCustomerAnnotation: false,
      piiMask: {
        maskType: "custom_input",
        maskCssSelectors: ".pii-mask"  // Hide sensitive fields
      }
    };
    
    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("help-widget").style.display = "block";
          
          // Optional: Auto-dial support or show phone number
          showSupportContact(payload.pincode);
        });
        
        session.on("agent_joined", () => {
          showBanner("Support agent is now helping you");
          trackEvent("form_assistance_started");
        });
        
        session.on("agent_left", () => {
          showBanner("Support agent has left");
          trackEvent("form_assistance_ended");
        });
      }
    });
    
    // Help button handler
    document.getElementById("help-btn").addEventListener("click", async () => {
      const response = await fetch("/api/form-assistance-token", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          role: 1,
          formType: "loan_application",
          currentStep: currentStep,
          userId: getOrCreateUserId()
        })
      });
      
      const { token } = await response.json();
      sessionRef.start({ sdkToken: token });
      
      // Track that user requested help
      trackEvent("form_help_requested", {
        formType: "loan_application",
        step: currentStep
      });
    });
    
    // End session handler
    document.getElementById("end-session").addEventListener("click", () => {
      if (sessionRef) {
        sessionRef.end();
        document.getElementById("help-widget").style.display = "none";
      }
    });
    
    // Track form completion
    document.getElementById("loan-application").addEventListener("submit", (e) => {
      e.preventDefault();
      
      trackEvent("form_completed", {
        hadAssistance: sessionRef !== null,
        steps: currentStep
      });
      
      submitForm();
    });
  </script>
</body>
</html>

Key Features

Progressive Privacy Masking

Mask fields based on sensitivity level:

// Tier 1: Fully masked (never visible to agent)
// - SSN, passwords, credit cards
const tier1Fields = ".pii-mask, [data-privacy='full']";

// Tier 2: Masked by default, can be unmasked with consent
// - Bank account numbers, tax IDs
const tier2Fields = "[data-privacy='optional']";

const settings = {
  piiMask: {
    maskType: "custom_input",
    maskCssSelectors: tier1Fields,
  }
};
Smart Annotation Guidance

Agent can highlight and guide:

<!-- Agent's view shows annotations -->
<style>
  /* Agent's annotation appears on customer's screen */
  .agent-highlight {
    border: 2px solid #0e72ed;
    box-shadow: 0 0 8px rgba(14, 114, 237, 0.6);
  }
</style>
Real-Time Validation Assistance

Agent sees validation errors in real-time:

// Show validation status to agent
form.addEventListener("blur", (e) => {
  if (e.target.validity.valid) {
    e.target.classList.add("valid");
  } else {
    e.target.classList.add("invalid");
    // Agent can see this and provide guidance
  }
}, true);

Workflow Example

Multi-Step Form Assistance
CUSTOMER                           AGENT
   │                                 │
   │  1. Opens loan application      │
   │     (Step 1 of 4)               │
   │                                 │
   │  2. Confused at Step 2          │
   │  Clicks "Need Help?"            │
   ├────────► Request Help           │
   │          (PIN: 123456)          │
   │                                 │
   │  3. Calls support               │
   │     "I need help with           │
   │      loan application"          │
   │                                 │
   │                                 │  4. Agent opens case
   │                                 │     Enters PIN: 123456
   │                                 │
   │  ◄─────── Agent Joined ─────────┤
   │                                 │
   │  5. Agent sees form (Step 2)    │
   │     Masked fields: SSN, DOB     │
   │     Visible: Everything else    │
   │                                 │
   │                                 │  6. Agent uses pen tool
   │  ◄────── Highlight field ───────┤     Highlights "SSN"
   │                                 │     Says: "Enter your SSN"
   │                                 │
   │  7. Enters SSN                  │
   │     (Agent sees: ***-**-****)   │
   │                                 │
   │                                 │  8. Agent highlights next
   │  ◄────── Highlight DOB ─────────┤     "Now your date of birth"
   │                                 │
   │  9. Completes Step 2            │
   │     Moves to Step 3             │
   │                                 │
   │  10. Finishes form              │
   │  ─────► Form Submitted ─────────►
   │                                 │
   │  11. Thanks agent               │
   │  ◄────── Session Ends ──────────┤

Privacy Protection Patterns

Pattern 1: Full Masking (Recommended)
// All sensitive fields completely hidden
const settings = {
  piiMask: {
    maskType: "custom_input",
    maskCssSelectors: ".pii-mask, .sensitive, [data-private]"
  }
};

Use for: SSN, passwords, credit cards, medical records

Pattern 2: Partial Masking
// Show last 4 digits (not natively supported, requires custom implementation)
function partialMask(value) {
  return '*'.repeat(value.length - 4) + value.slice(-4);
}

Use for: Phone numbers (show area code), account numbers

Pattern 3: Contextual Masking
// Mask based on form section
function updateMasking(stepNumber) {
  const maskingRules = {
    1: ".none",              // No masking on basic info
    2: ".ssn, .dob",         // Mask ID fields
    3: ".account, .routing", // Mask financial fields
    4: ".none"               // No masking on loan details
  };
  
  // Update SDK settings dynamically
  // Note: Requires re-initialization in current SDK version
}

Analytics and Tracking

Measure Assistance Effectiveness
// Track form completion with/without assistance
const metrics = {
  formType: "loan_application",
  assistanceRequested: true,
  assistanceDuration: 420, // seconds
  stepWhereHelpRequested: 2,
  completionRate: 1,       // 1 = completed, 0 = abandoned
  timeToComplete: 1200,    // seconds
  fieldsModified: 18,
  validationErrors: 2
};

analytics.track("form_completion", metrics);
Key Metrics to Track

  1. Form Abandonment Rate

    • Before assistance: 35%

    • With assistance: 8%

    • 73% improvement

  2. Time to Complete

    • Without assistance: 15 min avg

    • With assistance: 8 min avg

    • 47% faster

  3. Error Rate

    • Without assistance: 3.2 errors/form

    • With assistance: 0.8 errors/form

    • 75% fewer errors

  4. Customer Satisfaction

    • CSAT score: 4.7/5

    • NPS: +68

Integration Examples

Salesforce Integration
// Log form assistance session to Salesforce
async function logFormAssistance(leadId, sessionData) {
  await salesforce.leads.update(leadId, {
    Form_Assistance_Date__c: new Date(),
    Assistance_Duration__c: sessionData.duration,
    Form_Completed__c: sessionData.completed,
    Agent_Id__c: sessionData.agentId
  });
}
HubSpot Integration
// Create activity for form assistance
await hubspot.contacts.createActivity(contactId, {
  type: "cobrowse_assistance",
  timestamp: Date.now(),
  properties: {
    form_type: "loan_application",
    duration: sessionDuration,
    completed: formCompleted
  }
});

Best Practices

1. Clear Help Triggers

Place help buttons strategically:

  • Top of form (always visible)

  • Beginning of each complex section

  • Near confusing field labels

2. Privacy First

  • Mask by default, unmask only if absolutely necessary

  • Show clear indicators when fields are masked

  • Get consent before starting session

3. Progress Preservation
// Save form state before assistance
function saveFormState() {
  const formData = new FormData(document.getElementById("loan-application"));
  localStorage.setItem("form_draft", JSON.stringify(Object.fromEntries(formData)));
}

// Restore on page reload
function restoreFormState() {
  const saved = localStorage.getItem("form_draft");
  if (saved) {
    const data = JSON.parse(saved);
    Object.entries(data).forEach(([name, value]) => {
      const field = document.querySelector(`[name="${name}"]`);
      if (field) field.value = value;
    });
  }
}
4. Agent Training

Train agents on:

  • Which fields are masked vs visible

  • How to use annotation tools effectively

  • When to suggest breaks for complex forms

  • Privacy compliance requirements

Common Challenges & Solutions

Challenge: Customer refreshes page during assistance
Solution: Implement auto-reconnection (see Auto-Reconnection Guide)

Challenge: Agent can't see validation errors
Solution: Add visual indicators that aren't masked:

field.parentElement.classList.add("has-error");

Challenge: Multi-page forms lose session
Solution: Use session persistence across page navigation:

const settings = {
  multiTabSessionPersistence: {
    enable: true
  }
};

Cost-Benefit Analysis

Costs

  • Zoom SDK: ~$0.05 per assistance minute

  • Development: 2-3 weeks integration

  • Agent Training: 4 hours per agent

Benefits

  • Reduced Abandonment: 35% → 8% = 27% more conversions

  • Faster Completion: 15 min → 8 min = 47% time saved

  • Fewer Errors: 75% reduction in submission errors

  • Higher CSAT: 4.7/5 satisfaction score

ROI Example (1000 forms/month):

  • Before: 650 completed (35% abandoned)

  • After: 920 completed (8% abandoned)

  • Additional conversions: 270/month

  • Avg value/conversion: $50

  • Additional revenue: $13,500/month

  • SDK cost: ~$500/month

  • Net benefit: $13,000/month

Related Resources

Next Steps

  1. Identify high-abandon forms in your application

  2. Review privacy requirements for your industry

  3. Set up auth server using JWT Authentication

  4. Integrate customer SDK using Customer Integration

  5. Train support agents on co-browsing and privacy controls

  6. Measure results and iterate based on analytics

Requirements and compatibility

Written for: Claude Code, Claude apps

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.

Needs: Claude Code frontmatter, Needs an MCP server

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
Anthropic (Official)
Distributed by
Anthropic
Source
anthropics/knowledge-work-plugins · partner-built/zoom-plugin/skills/general · commit e050c2e
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from partner-built/zoom-plugin/LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

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

Download ZIP

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