Real-Time Audio Streaming API: Stream Live Audio from Zoom, Google Meet & Microsoft Teams to Any App
Post-call transcription is useful when you only need notes after a meeting. It is not enough when your product needs to react while people are still talking.
That is where a real-time audio streaming API for meetings helps. MeetStream sends a bot into a Zoom, Microsoft Teams or Google Meet call, captures the audio, and streams it to your app over WebSocket. Your app can then transcribe it, send it to OpenAI Whisper, AssemblyAI, or Deepgram, run compliance checks, power a voice AI agent, trigger alerts during the call or build any real-time audio AI application you can think of.
This tutorial shows how to stream audio from Zoom meeting programmatically. The same setup also works for a live audio stream from Google Meet and Microsoft Teams because your app talks to MeetStream instead of building a separate integration for every meeting platform.
What You Will Build
You will build a live meeting audio pipeline that does five things:
1. Sends a MeetStream bot into a Zoom, Google Meet or Microsoft Teams call.
2. Receives speaker-tagged audio while the meeting is happening
3. Rebroadcasts the meeting bot WebSocket audio feed to your own app.
4. Sends the live audio to OpenAI Whisper, AssemblyAI, Deepgram, or another AI system.
5. Stores clean audio files for later review.
The end result is simple: your app can capture meeting audio stream for AI processing while the call is still in progress.
Source code is in MeetStream Labs under post-call-transcription.
Prerequisites
· Node.js v18+
· A MeetStream API key → app.meetstream.ai
· A free ngrok auth token → dashboard.ngrok.com
How It Works
At a high level, there are three moving parts: your app, the MeetStream API, and your server. Your app asks MeetStream to create a bot. MeetStream joins the Zoom, Teams or Google Meet call. Your server receives status updates, transcript events, and the live audio stream while the meeting is still happening.
The simple version: your app sends the meeting link to MeetStream, MeetStream joins the meeting as a bot, and your server receives a live feed while people are talking.
A webhook is just a notification from MeetStream to your server. A WebSocket is the open line used for the live audio. Once your server has that audio, it can send it to OpenAI Whisper, AssemblyAI, Deepgram, a voice AI agent, an analytics system, or your own internal app.
That is useful for live transcription, call coaching, sentiment analysis, compliance monitoring, voice AI agents, and any workflow where waiting for a post-call recording is too slow.
What Is a Real-Time Audio Streaming API?
A real-time audio streaming API lets your application receive meeting audio as it is captured, not after the meeting ends.
Traditional meeting transcription usually works like this:
1. Record the meeting.
2. Wait for the recording to process.
3. Send the file to a transcription service.
4. Read the transcript after the call.
A real-time pipeline works differently:
1. A bot joins the meeting.
2. The bot listens to the meeting audio.
3. Audio frames are sent to your server over WebSocket.
4. Your app processes the audio immediately.
That difference matters. If you are building an AI meeting assistant, a live compliance alert, a sales coaching tool, or a realtime voice workflow, your product needs the audio during the meeting, not ten minutes later.
When You Need This
A real-time meeting audio stream is the right fit when you need to act during the call.
Use it for:
· Live transcription inside your product.
· AI meeting assistants that listen while the call is happening.
· Keyword or risk detection during customer conversations.
· Coaching prompts for sales or support teams.
· Meeting analytics that track talk time, interruptions, or sentiment.
· Voice AI agents that need to understand a call in real time.
If all you need is a transcript after the call, a post-call transcription API may be enough. If your product needs to respond in the moment, you need live audio.
Project Setup
Start with the audio streaming example from MeetStream Labs
git clone https://github.com/meetstream-ai/labs
cd labs/audio-streaming
npm install
cp .env.example .env
MEETSTREAM_API_KEY=your_meetstream_api_key
NGROK_AUTHTOKEN=your_ngrok_authtoken
MEETING_LINK=https://meet.google.com/xxx-xxxx-xxx
ngrok is only used to expose your local server during development. In production, you would use your own public server URL.
Step 1: Start the Local Server and Tunnel
Your app needs a public URL so MeetStream can send events and audio to it. During local development, ngrok gives your laptop a public HTTPS and WebSocket address.
const listener = await ngrok.connect({
addr: PORT,
authtoken: process.env.NGROK_AUTHTOKEN,
});
const publicUrl = listener.url();
const callbackUrl = `${publicUrl}/webhook/callback`;
const transcriptUrl = `${publicUrl}/webhook/transcript`;
const audioWsUrl = `${publicUrl.replace("https://", "wss://")}/audio`;
There are three URLs here:
· callbackUrl receives meeting and bot status events.
· transcriptUrl receives live transcript events.
· audioWsUrl receives the raw audio stream.
This order matters. The public URLs must exist before you create the bot, because MeetStream needs to know where to send the live audio.
Step 2: Create the Bot
Once your URLs are ready, create a MeetStream bot and pass in the meeting link.
await fetch("https://api.meetstream.ai/api/v1/bots/create_bot", {
method: "POST",
headers: {
Authorization: `Token ${apiKey}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
meeting_link: meetingLink,
audio_required: true,
callback_url: callbackUrl,
live_transcription_required: {
webhook_url: transcriptUrl,
},
live_audio_required: {
websocket_url: audioWsUrl,
},
recording_config: {
transcript: {
provider: { meeting_captions: {} },
},
},
}),
});
The important field is live_audio_required. That tells MeetStream to open a WebSocket connection to your server and stream the meeting audio there.
This is the key difference between recording a meeting and building a live audio product. A recording waits until the meeting is done. live_audio_required gives your app the stream while people are still talking.
Step 3: Use a WebSocket Audio Streaming Meeting Bot
After the bot joins the meeting, MeetStream connects to your /audio WebSocket and starts sending binary audio frames.
The frame includes:
· The speaker ID.
· The speaker name.
· The raw PCM audio payload.
Audio format:
PCM16 little-endian
48,000 Hz
Mono
Speaker-tagged frames
The handler reads the frame, identifies the speaker, and extracts the audio data.
```javascript
handleFrame(buffer) {
const speakerName = getSpeakerName(buffer);
const pcm = getAudioPayload(buffer);
this.broadcaster.broadcast(speakerName, pcm);
writeToSpeakerArchive(speakerName, pcm);
}
```
That gives you two outputs at the same time:
1. A live stream that your app can use immediately.
2. Per-speaker audio files that you can keep for debugging, QA, or review.
This is the core meeting bot WebSocket audio feed. Your app does not need to know the details of Zoom or Google Meet audio capture. It only needs to consume the stream.
Step 4: Stream Audio from Zoom Meeting Programmatically
To stream audio from Zoom meeting programmatically, pass the Zoom meeting link into the same bot creation request.
MEETING_LINK=https://zoom.us/j/123456789
npm start
The flow stays the same:
1. MeetStream joins the Zoom call as a bot.
2. The bot captures the live audio.
3. MeetStream sends the audio to your WebSocket endpoint.
4. Your server forwards it to the app or AI provider you choose.
This avoids building a separate Zoom-only audio capture layer. Your product receives a clean meeting audio stream and can focus on what to do with it.
Step 5: Get a Live Audio Stream from Google Meet Bot
The Google Meet flow is nearly identical. Use a Google Meet link in your .env file:
MEETING_LINK=https://meet.google.com/xxx-xxxx-xxx
npm start
MeetStream sends the bot into the Google Meet call and streams audio to the same /audio WebSocket endpoint.
That means your app can use one code path for Zoom and Google Meet:
Meeting link in
Bot joins the call
Audio stream out
Your app processes it
This is useful if your customers use different meeting platforms. You do not need to maintain a different live audio pipeline for each one.
Step 6: Stream Audio from Microsoft Teams Meeting Programmatically
To stream audio from a Microsoft Teams meeting programmatically, update your .env file with a Microsoft Teams meeting link:
MEETING_LINK=https://teams.microsoft.com/l/meetup-join/...npm startThe flow remains exactly the same:
- MeetStream joins the Microsoft Teams meeting as a bot.
- The bot captures the live meeting audio.
- MeetStream streams the audio to your WebSocket endpoint.
- Your server forwards it to the application or AI provider of your choice.
This lets you receive a clean, real-time audio stream without building your own Microsoft Teams media capture solution.
Step 7: Broadcast the Audio to Your App
Most products need more than one consumer for the audio stream. For example, one service may run transcription, another may detect keywords, and another may store audio for QA.
The broadcaster pattern solves this. Your server receives audio from MeetStream once, then rebroadcasts it to any internal service connected to /stream.
// Sent to each /stream consumer
{
type: "audio",
speaker: speakerName,
format: "PCM16LE",
sampleRate: 48000,
channels: 1,
audio: pcm,
}
Every connected consumer gets the same live audio. If one consumer slows down, the broadcaster can disconnect it instead of letting it block the whole pipeline.
That is the part many teams miss. Real-time audio is not just about receiving the stream. You also need to move it through your own system safely.
Step 8: Send the Meeting Audio Stream to OpenAI Whisper, AssemblyAI, or Deepgram
Once your app receives the audio, you can send it to any transcription or AI provider.
The sample bridge connects to /stream and forwards audio to the provider you choose in .env:
STT_PROVIDER=deepgram
DEEPGRAM_API_KEY=your_key_here
npm run bridge
Supported examples include:
· Console output for testing the stream.
· Deepgram for realtime transcription.
· AssemblyAI for streaming transcription.
· OpenAI Whisper for transcription workflows.
· A custom provider you add yourself.
The useful part is that your main meeting pipeline does not change when you switch providers. MeetStream still sends audio to your app. Your bridge decides where that audio goes next.
Here is the provider shape:
export default {
name: "My Provider",
async connect(onResult) {
// Open the provider connection here.
},
sendAudio(pcm, speakerName) {
// Forward raw meeting audio to your provider.
},
async disconnect() {
// Close the provider connection cleanly.
},
};
This makes it easy to test one transcription vendor now and swap later without rewriting the meeting bot flow.
Common Issues and Fixes
The bot cannot join the Google Meet call
Google Meet may block guest participants depending on the meeting settings. Admit the bot from the waiting room or change the meeting access settings so guests can join.
The bot joins, but no audio arrives
Make sure someone is unmuted and speaking after the bot joins. If everyone is muted, there may be no audio frames to stream.
Some files are marked as an unidentified speaker
Speaker detection can take a moment at the start of a meeting. The first few frames may be saved before the speaker name is known. The audio is still valid.
The transcription bridge is silent
Run the bridge in a second terminal after the main server starts.
npm start
npm run bridge
Also check that STT_PROVIDER and the matching API key are set in .env.
Shutdown logs show a harmless file error
If the audio socket closes at the same time as Ctrl+C, cleanup can run twice. The audio files are usually already finalized by the first cleanup.
What You Can Build With This
A real-time meeting audio stream gives your product a new input: what people are saying right now.
You can use it to build:
· A live transcription app using a meeting bot API.
· A voice AI agent that joins and listens to meetings.
· Sales coaching that suggests next questions during the call.
· Compliance alerts when risky language appears.
· Live translation for multilingual teams.
· Talk time analytics and interruption tracking.
· Sentiment analysis during customer calls.
The basic pattern stays the same for each use case. Join the meeting, stream the audio, and send it to the system that needs to act on it.
Why This Approach Works
Building directly against meeting platforms is hard because every platform exposes audio differently. The bot-based approach gives you a stable layer between the meeting and your application.
Your app does not need to handle the meeting platform internals. It only needs to handle one stream:
Speaker-tagged audio over WebSocket
That is why a real-time audio streaming API is a better fit for AI products than a post-call recording workflow. It gives your product live audio, keeps your platform code simpler, and makes it easier to connect the meeting to transcription, analytics, or voice AI.
FAQ
· How do I stream real-time audio from Zoom, Microsoft Teams and Google Meet via API?
Use a meeting bot API that can join the call and send captured audio to your server while the meeting is running. With MeetStream, you create a bot with a meeting link and provide a WebSocket URL. The bot joins Zoom or Google Meet and streams speaker-tagged PCM audio to that endpoint in real time.
· What is the easiest way to get real-time audio from a Zoom meeting?
The easiest path is to send a meeting bot into the Zoom call and enable live audio streaming in the bot creation request. That avoids building directly on top of Zoom SDKs or waiting for a finished recording before your app can act on the audio.
· Can I get a live audio stream from a Google Meet bot?
Yes. MeetStream can send a bot into a Google Meet call and stream the captured audio to your application over WebSocket. Your app receives the audio while people are speaking, so you can use it for transcription, alerts, analytics, or AI processing.
· Which meeting APIs support WebSocket audio streaming?
MeetStream supports WebSocket audio streaming for meeting bots. You provide a WebSocket endpoint, and the bot pushes audio frames to your server for the duration of the meeting. This is different from APIs that only provide recordings or transcripts after the call ends.
· How do I pipe meeting audio to OpenAI Whisper or AssemblyAI in real time?
First, receive the meeting audio stream from the bot. Then forward each audio frame to the transcription provider's realtime or streaming endpoint. The sample bridge in this tutorial connects to the MeetStream audio feed and sends the audio to OpenAI Whisper, AssemblyAI, Deepgram, or a custom provider.
· What is the best API for real-time audio streaming from video meetings?
For most developer teams, the best option is the API that reduces platform-specific work. A bot-based meeting audio API gives your app one integration pattern for Zoom, Microsoft Teams and Google Meet, one WebSocket audio contract, and one place to connect transcription, analytics, or AI tools.
· How does real-time audio streaming work in meeting bots?
A meeting bot joins the call as a participant, listens to the meeting audio, packages that audio into small frames, and sends those frames to your server over an open WebSocket connection. Your app can process each frame as it arrives instead of waiting for the meeting to finish.
· Can I use this to build a voice AI agent that joins and listens to meetings?
Yes. The meeting bot handles the hard part: joining the call and delivering live audio to your app. You can then send that audio to a transcription model or realtime voice model so the agent can understand the meeting as it happens.
· What is a low-latency meeting bot API for AI applications?
A low-latency meeting bot API sends audio to your application as the meeting is happening, rather than batching everything into a post-call file. MeetStream streams audio frames over WebSocket, which makes it useful for live transcription, voice AI agents, compliance checks, and in-meeting alerts.
Final Takeaway
If your product only needs a transcript after a meeting, post-call transcription is fine.
If your product needs to understand or react to a meeting while it is happening, you need a live audio stream.
MeetStream gives you that stream through a meeting bot API. Send in the bot, receive speaker-tagged audio over WebSocket, and connect the feed to the transcription, analytics, or AI workflow your product needs.
Full source is in MeetStream Labs under realtime-audio-streaming. Clone it, fill in two keys, run npm start.
Built with the MeetStream API. Supports Google Meet, Zoom, and Microsoft Teams.