Zoom Recording Bot API: How to Get Recordings Programmatically

According to Cisco’s 2023 Visual Networking Index, global video traffic is projected to grow threefold by 2025, with meeting recordings representing one of the fastest-growing categories of enterprise data. Yet most development teams still rely on manual processes to capture that data, waiting on Zoom’s cloud processing pipeline before they can act on it.

For developers building analytics platforms, AI assistants, or compliance tools, that delay is a real bottleneck. Zoom’s native recording requires the host to press a button, only works on paid plans for cloud storage, and can take hours before files are accessible. When you need recordings triggered by your backend, not by a human, the built-in tools simply do not fit the job.

A Zoom recording bot API solves this by sending a software participant into any meeting. The bot joins automatically, captures the audio and video streams in real time, and delivers clean MP4 and MP3 files to your application the moment the meeting ends, no host action required.

In this article, we’ll explore how to build a recording pipeline using a Zoom recording bot API, covering bot creation, webhook handling, and file retrieval with practical code examples. Let’s get started!

What Is a Zoom Recording Bot?

A Zoom recording bot is a software participant that joins your meeting, captures the audio and video streams, and delivers them to your application. Unlike Zoom’s native cloud recording (which requires the host to press a button and waits for Zoom’s processing pipeline), a recording bot API gives you programmatic control. You dispatch it, it joins, it records, and it delivers the media back to your backend when the meeting ends.

The bot joins the meeting just like a human participant, which means it works across all Zoom plan tiers (including free accounts) and does not require the meeting host to take any action to start recording.

Zoom Recording Bot API vs Other Recording Methods

What You Need Before You Start

Before writing any code, make sure you have three things in place:

1. A recording bot API key — the credential your backend uses to dispatch bots and authenticate media retrieval requests. Get a free MeetStream API key →
2. A publicly accessible webhook URL — during development, a tunneling tool like ngrok works well
3. A basic backend server — capable of making HTTP POST requests to launch the bot and receiving HTTP POST callbacks

Step 1: Launch the Bot into the Meeting

Your backend sends the bot into the Zoom meeting with a single POST request:

curl -X POST https://api.meetstream.ai/v1/bots 
  -H "Authorization: Bearer YOUR_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "meeting_url": "https://zoom.us/j/123456789",
    "webhook_url": "https://your-app.com/webhooks/meetstream",
    "config": {
      "recording": {
        "video_mixed_mp4": true,
        "audio_mixed_mp3": true
      }
    }
  }'

curl -X POST https://api.meetstream.ai/v1/bots 
  -H "Authorization: Bearer YOUR_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "meeting_url": "https://zoom.us/j/123456789",
    "webhook_url": "https://your-app.com/webhooks/meetstream",
    "config": {
      "recording": {
        "video_mixed_mp4": true,
        "audio_mixed_mp3": true
      }
    }
  }'

The recording configuration tells the API what output formats you want. For most use cases, video_mixed_mp4 gives you a combined video recording and audio_mixed_mp3 provides the audio track. You can also request per-participant audio and video for speaker-level separation and diarization.

When the bot is created, the API returns a bot ID. Store this — you’ll use it to retrieve recordings and query the bot’s status throughout the meeting.

Step 2: Handle Webhook Events

While the bot is in the meeting, the API sends webhook events to the URL you provided. The most important events to handle are:

• bot.joined — Bot successfully joined the meeting
• bot.recording — Recording is in progress
• bot.done — Meeting ended and recording is ready for download

Your webhook handler should listen for bot.done specifically. This is the signal that the recording is ready. The event payload contains a recording ID that you use to retrieve the actual media files.

Associate the recording ID with the bot session using the bot ID you saved in Step 1. Without this association, you cannot link incoming webhooks back to the right meeting in your database.

Step 3: Retrieve the Video Recording

Once the bot.done webhook arrives, your backend calls the video retrieval endpoint with the recording ID. The API returns a response that includes a download_url field pointing to the processed MP4 file, which your application can download, store, or stream directly to your users.

The response also includes a status field — always check this before attempting to use the download URL. In most cases, by the time bot.done fires, the file is immediately available.

Step 4: Retrieve the Audio Recording

Audio retrieval follows the same pattern. Call the audio retrieval endpoint with the same recording ID and receive a download URL pointing to the MP3 file. If your use case involves transcription, sentiment analysis, or speaker diarization downstream, the MP3 file is the input you feed into those pipelines.

For applications that need per-participant audio rather than a mixed track, request audio_separate in the recording configuration when you create the bot. This gives you an individual audio file for each participant.

Real-Time Streaming as an Alternative

If your use case requires data during the meeting rather than after it, the recording bot approach also supports real-time delivery. You can receive raw audio frames via WebSocket as the meeting happens. This makes the bot approach viable for live transcription, real-time coaching tools, and automated meeting analysis that cannot wait until the call ends.

Real-time video delivery happens via RTMP, suitable for observer room applications or live monitoring scenarios. The same bot handles both — configure which delivery modes you want when you create the bot.

Why the Bot Approach Beats Building from Scratch

Building your own Zoom SDK bot is theoretically possible, but it takes a skilled team months and requires ongoing maintenance as Zoom updates its SDK. You need to manage raw PCM audio encoding, YUV video frame processing, server fleet scaling for concurrent meetings, waiting room handling, and token management.

Using a recording bot API eliminates all of that. You make a single POST request to start a bot, listen for a webhook, and fetch the file. Your team writes application logic instead of media infrastructure. The bot approach also works across all Zoom plan tiers, requires no action from the meeting host, and delivers consistent output regardless of account settings.

Get Started with MeetStream

MeetStream gives you a Zoom recording bot API that handles all of this out of the box. One API call sends a bot into any Zoom meeting. Webhooks notify you the moment recordings are ready. You retrieve clean MP4 and MP3 files without writing a single line of media processing code.

MeetStream also supports Google Meet and Microsoft Teams with the same unified API. Get your free API key →

Related Guides

• How to Record a Zoom Meeting: Complete Guide
• Meeting Bot API: Complete Guide for Developers
• Building a Meeting Bot with Python: Step-by-Step
• How to Record Google Meet with a Bot
• MeetStream vs Recall.ai: Complete Comparison

FAQs