Email API
Calendar API
Contacts API 
Scheduler
Notetaker API
Google email & calendar integration
Outlook email & calendar integration
IMAP integration
Google Meet integration
Zoom integration
Microsoft Teams integration
Calendar management
Embedded contextual email
Scheduling automation
Automated outreach
Expense management
Customer relationship management
Applicant tracking system
Communications platform
Marketplaces
Document management
Docs
SDKs
Tutorials
API status
Changelog
Support
Blog
Events
Guides
Inspiration gallery
Build vs. buy
Customer stories
Security & Compliance
Why Nylas
Newsroom
Jump to section
- Zoom’s existing options for integrations
- Method 1: Zoom Cloud Recording API
- Method 2: Building custom meeting bots with Zoom Linux SDK
- Method 3: Integrating with Nylas Notetaker API
- Integration with Zoom vs Integrating with the Nylas Notetaker API
- Frequently asked questions about integrating Zoom meetings
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
Getting data with the Cloud Recording API
// 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
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 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.
Sync notetakers with calendar events
// 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.
Process meeting data
// 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.
