Zoom General

GET /v2/meetings/{meetingUUID}/meeting_summary

// Get meeting summary
async function getMeetingSummary(meetingUUID) {
  // Double-encode UUID if it contains / or //
  const encodedUUID = meetingUUID.startsWith('/')
    ? encodeURIComponent(encodeURIComponent(meetingUUID))
    : encodeURIComponent(meetingUUID);

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

  return response.json();
}

// Response example
{
  "meeting_uuid": "abc123...",
  "meeting_id": 12345678901,
  "meeting_topic": "Weekly Team Sync",
  "meeting_start_time": "2024-01-15T10:00:00Z",
  "meeting_end_time": "2024-01-15T10:45:00Z",
  "summary_start_time": "2024-01-15T10:00:00Z",
  "summary_end_time": "2024-01-15T10:45:00Z",
  "summary_content": {
    "summary": "The team discussed Q1 roadmap priorities...",
    "next_steps": [
      "John to finalize design specs by Friday",
      "Sarah to schedule customer interviews"
    ],
    "keywords": ["roadmap", "Q1", "design", "customers"]
  }
}

GET /v2/meetings/{meetingId}/recordings

async function getMeetingTranscript(meetingId) {
  const response = await fetch(
    `https://api.zoom.us/v2/meetings/${meetingId}/recordings`,
    {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );

  const data = await response.json();

  // Find transcript files
  const transcriptFiles = data.recording_files.filter(
    file => file.file_type === 'TRANSCRIPT' ||
            file.file_type === 'CC' ||
            file.file_type === 'SUMMARY'
  );

  // Download transcript
  for (const file of transcriptFiles) {
    const transcriptResponse = await fetch(file.download_url, {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    });

    if (file.file_extension === 'VTT') {
      const vttContent = await transcriptResponse.text();
      console.log('VTT Transcript:', vttContent);
    } else if (file.file_extension === 'JSON') {
      const jsonContent = await transcriptResponse.json();
      console.log('JSON Transcript:', jsonContent);
    }
  }

  return transcriptFiles;
}

// Webhook handler
app.post('/webhook', (req, res) => {
  const { event, payload } = req.body;

  switch (event) {
    case 'recording.transcript_completed':
      // Transcript is ready
      console.log('Transcript ready for meeting:', payload.object.uuid);
      fetchAndStoreTranscript(payload.object.uuid);
      break;

    case 'recording.completed':
      // Recording processing complete (may include summary)
      console.log('Recording ready:', payload.object.uuid);
      break;

    case 'meeting.ended':
      // Meeting ended - summary will be generated soon
      console.log('Meeting ended:', payload.object.uuid);
      break;
  }

  res.sendStatus(200);
});

import { RTMSClient } from "@zoom/rtms";

const client = new RTMSClient({
  clientId: process.env.ZOOM_CLIENT_ID,
  clientSecret: process.env.ZOOM_CLIENT_SECRET,
  secretToken: process.env.ZOOM_SECRET_TOKEN
});

// Connect to meeting
await client.joinMeeting({
  meetingUuid: meetingUUID,
  streamId: streamId,
  serverUrl: "wss://rtms.zoom.us"
});

// Listen for transcript events
client.on('transcript', (data) => {
  console.log(`[${data.speakerName}]: ${data.text}`);

  // Process real-time transcript
  // - Send to AI for sentiment analysis
  // - Display live captions
  // - Log for compliance
});

// Check if AI Companion is available
const aiCompanionStatus = ZoomMtg.getAICompanionStatus();

// AI Companion features are controlled by meeting settings
// The SDK respects account/meeting-level AI Companion settings

// Android example
InMeetingAICompanionController aiController =
    ZoomSDK.getInstance().getInMeetingService().getInMeetingAICompanionController();

// Check AI Companion status
boolean isEnabled = aiController.isAICompanionEnabled();

// Get available features
AICompanionFeature[] features = aiController.getAvailableFeatures();
// Features: QUERY, SMART_SUMMARY, SMART_RECORDING

// iOS example
let aiController = MobileRTC.shared().getMeetingService()?.getInMeetingAICompanionController()

if let isEnabled = aiController?.isAICompanionEnabled() {
    print("AI Companion enabled: \(isEnabled)")
}

// Get conversation archives
async function getConversationArchives(userId) {
  const response = await fetch(
    `https://api.zoom.us/v2/users/${userId}/conversation_archive`,
    {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    }
  );

  return response.json();
}

// 1. Listen for meeting end
webhooks.on('meeting.ended', async (meeting) => {
  // 2. Wait for transcript to be ready (or use webhook)
  await delay(60000); // Processing time varies

  // 3. Fetch summary
  const summary = await getMeetingSummary(meeting.uuid);

  // 4. Store or distribute
  await saveSummaryToDatabase(summary);
  await sendSummaryToParticipants(meeting.participants, summary);
});

// Using RTMS for live processing
rtmsClient.on('transcript', async (data) => {
  // Send to your AI service for analysis
  const sentiment = await analyzesentiment(data.text);
  const actionItems = await extractActionItems(data.text);

  // Update live dashboard
  updateDashboard({ sentiment, actionItems });
});

// Archive all AI-generated content
async function archiveMeetingAIContent(meetingId) {
  const [summary, transcript, archives] = await Promise.all([
    getMeetingSummary(meetingId),
    getMeetingTranscript(meetingId),
    getConversationArchives(meetingId)
  ]);

  await complianceStore.save({
    meetingId,
    summary,
    transcript,
    aiConversations: archives,
    archivedAt: new Date()
  });
}