Build for free

Nylas
Blog
Developer how-tos
How to integrate Zoom meetings into a SaaS application

How to integrate Zoom meetings into a SaaS application

Sep 22, 2025 • 9 min read

Jump to section

Quick summary:

Compares how developers can use the Zoom Cloud Recording API, custom Linux SDK bots, and meeting bot APIs for building meeting intelligence into applications.

What you’ll learn:

How Zoom’s Cloud Recording API creates host-only access limitations and manual recording dependencies that break in customer-facing applications.
Why building custom meeting bots with the Linux SDK requires 4-6 months of development and ongoing infrastructure maintenance.

Who it’s for: Developers building customer-facing SaaS applications who need reliable meeting data access.

We learned that 67% of SaaS users would switch to a different work software within six months if that software gave them better meeting features.

Users want easy software experiences. They don’t want to hop between different point solutions and bloat their tech stack. More importantly, they want software that can fit around everyday tools.

If they’re using a meeting recording feature, they expect it to work with a meeting platform they already use. It’s too disruptive if they had to use a completely new meeting platform just to get recordings and transcriptions.

With 3.3 billion meeting minutes clocked in annually, Zoom is the most used video conferencing platform. If you’re building a SaaS app with meeting recording features, a smooth integration with Zoom is an expectation you’ll have to meet.

There are a few popular methods for programmatically retrieving recording and meeting transcript files after a Zoom meeting. Let’s compare them.

Zoom’s existing options for integrations

Developers have three main paths for accessing Zoom meeting data:

Cloud Recording API: Retrieves completed meeting recordings and Zoom transcripts after meetings end. The simplest approach but with significant limitations for production applications.

Custom meeting bots with Linux SDK: Build bots that join meetings as participants to capture real-time audio and video. Provides complete control but requires substantial infrastructure development.

Meeting SDK: Embeds Zoom’s meeting interface directly into your application. Designed for displaying meetings, not capturing data.

RTMP Live Streaming: Streams live meeting audio/video to external endpoints. Limited to specific real-time processing scenarios.

Integration method	Best for	Complexity	Features	Limitations
Zoom Cloud Recording API	Post-meeting archives, compliance documentation, internal tools	Medium	Download recordings and transcripts after meetings end, webhook notifications	Host-only access, manual recording triggers, 2x meeting duration processing delay, paid plans required
Custom meeting bots with Linux SDK	Enterprise apps needing complete control, custom audio/video processing	Very high	Real-time audio/video capture, custom transcription, any meeting access	4-6 months development, infrastructure scaling, ongoing maintenance, platform-specific builds
Meeting SDK	Embedding Zoom interface into apps, custom meeting experiences	Medium	Client View or Component View embedding, familiar Zoom UI	No access to recording/transcript data, requires separate APIs for meeting data
RTMP Live Streaming	Live broadcasting, real-time analysis with external processing	High	10-30 second latency streaming, custom endpoints, real-time data access	Manual host setup per meeting, requires external transcription services, Pro/Business plans only

Most developers start with the Cloud Recording API for post-meeting data access, hit its limitations, then evaluate whether to build custom bot infrastructure or use existing solutions.

Method 1: Zoom Cloud Recording API

The Zoom Cloud Recording API doesn’t let you record Zoom meetings live, but it does let you programmatically access completed meeting recordings and transcripts. You can use this method if you’re building for users who will be meeting hosts and have full control over their Zoom settings or can work with an IT department to get this control. It becomes difficult to use for customer-facing applications where users join meetings hosted by external organizations.

How it works

The API provides access to files stored in Zoom’s cloud after meetings are complete. You authenticate via Server-to-Server OAuth, set up webhooks for recording completion notifications, then download transcript and recording files when available.

When to use this method

Choose the Cloud Recording API for internal tools within a single Zoom organization where post-meeting access meets your requirements and you can ensure consistent recording practices. You’ll have to build apps that aren’t restricted by these limitations:

Host-only access: The recorded meeting is only stored in the host’s account, so other users cannot access the meeting and transcript details. Even with proper OAuth scopes, you’ll receive 403 errors if recordings weren’t explicitly shared with your application.
Manual recording triggers: No API exists to start recordings programmatically. Someone must physically click “Record” in every meeting, or your app gets nothing.
Processing delays: After the meeting has ended, it typically takes about 2 times the duration of the recorded meeting for all the recordings to be available. For example, the transcript of a 30 minute long meeting will be available 1 hour after the meeting is done.
Platform restrictions: Requires paid Zoom Business/Enterprise plans. English is the only language supported by Zoom’s transcript feature.

Getting data with the Cloud Recording API

The Zoom Cloud Recording API provides several endpoints for managing meetings and accessing recording data. You can use the API to:

Create meetings with cloud recording
Access recordings and transcripts
Monitor recording completion with webhooks

// Create meeting with cloud recording enabled
const meetingData = {
  topic: "Sales Team Weekly Sync",
  type: 2, // Scheduled meeting
  start_time: "2025-09-20T10:00:00Z",
  duration: 60,
  settings: {
    auto_recording: "cloud",        // Enable cloud recording
    host_video: true,
    participant_video: true,
    waiting_room: false
    // Note: audio_transcript is controlled by account settings, not per-meeting
  }
};

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)
});

const meeting = await response.json();
console.log('Meeting URL:', meeting.join_url);

// Get recordings for a specific meeting
const recordingsResponse = await fetch(
  `https://api.zoom.us/v2/meetings/${meetingId}/recordings`,
  {
    headers: { 'Authorization': `Bearer ${accessToken}` }
  }
);

const recordingsData = await recordingsResponse.json();

// Filter for transcript files (only available if account has transcription enabled)
const transcripts = recordingsData.recording_files?.filter(
  file => file.file_type === 'TRANSCRIPT'
) || [];

// Download transcript content using proper authentication
for (const transcript of transcripts) {
  const transcriptResponse = await fetch(transcript.download_url, {
    headers: { 'Authorization': `Bearer ${accessToken}` }
  });
  const transcriptContent = await transcriptResponse.text();
  
  console.log('Transcript:', transcriptContent);
}

// Webhook endpoint for recording completion events
app.post('/webhook/zoom', (req, res) => {
  const { event, payload } = req.body;
  
  if (event === 'recording.completed') {
    const { recording_files } = payload.object;
    const meetingId = payload.object.uuid;
    
    // Filter for transcript files
    const transcripts = recording_files.filter(
      file => file.file_type === 'TRANSCRIPT'
    );
    
    // Process each transcript
    transcripts.forEach(async (transcript) => {
      if (transcript.status === 'completed') {
        await processTranscript(transcript.download_url, meetingId);
      }
    });
  }
  
  res.status(200).send('OK');
});

async function processTranscript(downloadUrl, meetingId) {
  try {
    const transcriptUrl = `${downloadUrl}?access_token=${accessToken}`;
    const response = await fetch(transcriptUrl);
    const transcriptContent = await response.text();
    
    // Store transcript content
    await storeTranscript(meetingId, transcriptContent);
  } catch (error) {
    console.error('Error processing transcript:', error);
  }
}

Method 2: Building custom meeting bots with Zoom Linux SDK

For applications requiring reliable, automated meeting capture, developers can build custom meeting bots using Zoom’s Linux SDK. This approach provides complete control over audio and video capture but requires significant infrastructure development.

How it works

Meeting bots join Zoom calls as participants, capturing raw audio and video streams directly from the meeting. Unlike the Cloud Recording API, bots work regardless of host settings and can process data in real-time.

But you’ll need the right infrastructure to support this, which will include:

Dedicated servers: Each bot requires its own virtual machine running the Linux Zoom client. You’ll need container orchestration for scaling across multiple meetings.
Raw media processing: The Linux SDK provides I420 video frames and PCM 16LE audio format. Your application must handle encoding, storage, and transcription processing.
Server management: Bot infrastructure needs monitoring, auto-scaling, and replacement handling when bots crash or meetings end unexpectedly.

Development process

Here’s a high-level overview of what you’ll need to do:

Set up Linux environment: Deploy Ubuntu/CentOS servers with the Zoom Linux SDK installed
Bot authentication: Configure OAuth credentials for each bot instance to join meetings
Media stream extraction: Use the SDK’s Raw Data functionality to capture audio and video
Encoding and processing: Convert raw streams to usable formats and send to transcription services
Scaling infrastructure: Build orchestration systems to manage multiple concurrent bots

When to use this method

Choose custom meeting bot development only if you have specific customization requirements that third-party solutions can’t meet. Even so, you’ll need to make sure you have dedicated infrastructure teams, 6+ months for development and testing, and aren’t impacted by these limitations:

Each meeting platform (Zoom, Teams, Google Meet) requires separate bot implementations
Managing hundreds of concurrent bots requires sophisticated infrastructure and monitoring
Zoom SDK updates can break bot functionality, requiring ongoing engineering attention

Method 3: Integrating with Nylas Notetaker API

The Nylas Notetaker API provides meeting bot functionality without requiring you to build and maintain the underlying infrastructure. This approach delivers the benefits of meeting bots while letting you focus on your core product features.

How it works

Nylas manages the complexity of deploying meeting bots across Zoom, Teams, and Google Meet. You make API calls to schedule bots, and receive webhook notifications with processed transcripts and recordings when meetings complete. We’ll walk through an example of how you can integrate the Notetaker API into a CRM to add sales transcription or meeting summarization capabilities.

Set up your development environment

# Install the Nylas SDK
npm install nylas dotenv

# Create .env file 
echo "NYLAS_API_KEY=your_api_key_here" > .env 
echo "NYLAS_GRANT_ID=your_grant_id_here" >> .env

import Nylas from 'nylas';
import 'dotenv/config';

const nylas = new Nylas({
  apiKey: process.env.NYLAS_API_KEY,
});

const grantId = process.env.NYLAS_GRANT_ID;

Deploy meeting bots for Zoom calls

Create meeting bots for specific Zoom sessions.

// Create a notetaker for a specific Zoom meeting
async function createMeetingRecorder(meetingLink, meetingTitle) {
  try {
    const notetaker = await nylas.notetakers.create({
      identifier: grantId,
      requestBody: {
        meeting_link: meetingLink, // e.g., "https://zoom.us/j/123456789"
        notetaker_name: `Meeting Recorder - ${meetingTitle}`
        // Note: recording/transcription settings are managed at account level
      }
    });
    
    console.log(`Notetaker created with ID: ${notetaker.data.id}`);
    return notetaker.data.id;
  } catch (error) {
    console.error('Error creating notetaker:', error);
  }
}

// Example usage
const meetingId = await createMeetingRecorder(
  "https://zoom.us/j/123456789", 
  "Sales Team Weekly Sync"
);

For automated deployment, calendar sync is configured through the Nylas Dashboard rather than via API. Once enabled, Nylas automatically deploys notetakers to calendar events based on the rules you configure.

// Calendar sync is managed through the Nylas Dashboard
// The API automatically creates notetakers for scheduled meetings
// based on your configured sync rules

// You can check existing notetakers with:
async function getScheduledNotetakers() {
  try {
    const notetakers = await nylas.notetakers.list({
      identifier: grantId
    });
    
    console.log('Scheduled notetakers:', notetakers.data);
    return notetakers.data;
  } catch (error) {
    console.error('Error fetching notetakers:', error);
  }
}

Retrieve recordings and transcripts

Process meeting data when it becomes available.

// Webhook notifications for real-time processing
app.post('/webhooks/notetaker', async (req, res) => {
  const { type, data } = req.body;
  
  if (type === 'notetaker.media' && data.object.state === 'available') {
    const mediaUrls = data.object.media;
    
    // Download transcript with speaker identification
    const transcriptResponse = await fetch(mediaUrls.transcript);
    const transcriptData = await transcriptResponse.json();
    
    // Process structured transcript data
    transcriptData.forEach(segment => {
      console.log(`${segment.speaker}: ${segment.text}`);
    });
    
    // Integrate with your business systems
    await syncToCRM(transcriptData);
  }
  
  res.status(200).send('Webhook received');
});

Process meeting data

With reliable access to meeting recordings and transcripts, you can build features for

CRM updates: Pull deal updates and customer feedback from sales calls to update records automatically.
Task creation: Turn meeting discussions into tasks that sync with project tools.
Training docs: Create documentation and action items from team meetings and training sessions.
Compliance records: Keep searchable meeting archives with speaker names for regulatory requirements.
Auto-generated summaries: Nylas is adding built-in summaries and action items to the /media endpoint in September 2025. Turn on this feature with one API call to automatically generate summaries and action items for all meetings.

Integration with Zoom vs Integrating with the Nylas Notetaker API

When building customer-facing applications, Nylas gives you reliable data to power your AI products without the complexity of managing bot infrastructure across platforms. You get:

Cross-platform coverage: Same API works for Zoom, Teams, and Google Meet
Production-ready transcripts: Built-in AssemblyAI integration provides speaker diarization and high accuracy
Calendar automation: Automatic bot scheduling based on calendar events
Enterprise compliance: SOC-2, HIPAA, and GDPR handling included
Reduced maintenance: Nylas handles platform updates and infrastructure scaling

Factor	Cloud Recording API	Custom Linux SDK Bots	Nylas Notetaker API
Meeting access	Host organization only	Any meeting participant	Any meeting participant
Recording control	Manual UI button required	Programmatic bot deployment	Programmatic bot deployment
Setup complexity	Medium (OAuth, webhooks)	Very High (Infrastructure + SDK)	Low (OAuth only)
Development timeline	2-3 weeks	4-6 months	1-2 weeks
Transcript quality	Basic, English-only	Depends on chosen transcription service	Production-ready with speaker diarization
Cross-platform	Zoom only	Requires separate bot development	Zoom, Teams, Google Meet
Infrastructure costs	Included with Zoom plans	High ($50-200+ per concurrent bot)	Usage-based pricing
Ongoing maintenance	Medium (API updates)	High (Infrastructure + platform changes)	Low (Nylas manages infrastructure)
Customization	Limited to API capabilities	Complete control	High (API integration flexibility)

Frequently asked questions about integrating Zoom meetings

How do I embed Zoom meetings directly into my application?

Use the Zoom Meeting SDK. It gives you two options: Client View (full Zoom interface) or Component View (customizable components). This handles the meeting experience but doesn’t give you access to recording or transcript data. You need the Cloud Recording API for that.

Can I automatically start recording for all Zoom meetings?

No. Zoom has no API to start recordings programmatically. Someone must click “Record” in each meeting. Meeting bots solve this by joining as participants and recording automatically.

What’s the difference between building custom bots and using a meeting bot API?

Custom bots take 4-6 months to build, need ongoing maintenance, and require separate implementations for each platform. Meeting bot APIs provide the same functionality with pre-built infrastructure.

How do I handle scaling meeting bots across multiple platforms?

Building bots for Zoom, Teams, and Google Meet requires separate implementations since each platform has different SDKs. Meeting bot APIs provide unified access across platforms.

Can I get real-time transcripts during Zoom meetings?

The Cloud Recording API only works after meetings end. Meeting bots can process audio during meetings for real-time transcription.

How do I ensure compliance when recording meetings?

Meeting bots operate within platform permission frameworks and trigger native consent dialogs. Choose solutions with built-in compliance features rather than building compliance handling yourself.

Related resources

What to do when there’s no email admin

Nylas’ security & compliance program for communication APIs

How Foundersuite Helped 100,000+ Startups Raise $21 Billion With Better Email Capabilities

The State of Agentic AI in 2026: What teams are actually shipping

How to integrate Zoom meetings into a SaaS application

The State of Agentic AI in 2026: What teams are actually shipping

Nylas Transactional Send public beta launch

Introducing Summaries and Action Items for the Notetaker API

Quick summary:

Zoom’s existing options for integrations

Method 1: Zoom Cloud Recording API

How it works

When to use this method

Getting data with the Cloud Recording API

Method 2: Building custom meeting bots with Zoom Linux SDK

How it works

Development process

When to use this method

Method 3: Integrating with Nylas Notetaker API

How it works

Integration with Zoom vs Integrating with the Nylas Notetaker API

Frequently asked questions about integrating Zoom meetings

Related resources

Why emails sent via your app go to spam (but Outlook delivers them just fine)

How to fix Microsoft’s “service abuse mode” error

How to read Office 365 spam headers: A simple guide for non-admins