Transcribe live audio

Upload audio to the Sync API as it is recorded, so the transcript is ready almost as soon as the speaker stops.

Overview

transcribe() needs the whole clip before it can send anything. transcribe_live() starts the request on the first chunk and uploads audio as your code produces it, so by the time the speaker stops, most of the work is already done. What is left to wait for is the tail of the audio.

Both return the same result and post to POST https://sync.assemblyai.com/v1/transcribe/live.

For short audio only

Live upload is for short clips: the Sync API caps audio at 120 seconds, and it returns one finished transcript when the audio ends. If you need words back while the speaker is still talking, or you need to capture more than 2 minutes of audio, use the Real-time STT API, which opens a WebSocket connection for up to 3 hours.

It is worth using only when the audio is genuinely still being produced. Streaming a file that already exists on disk is slower than transcribe(), which sends it in one piece.

Before you begin

To complete this guide, you need:

• An API key — copy it from API Keys and set it once:

  export ASSEMBLYAI_API_KEY=<your-key>
  

• A live audio source — a microphone, an in-progress call, an upload from a browser. This guide uses the microphone.

• Python 3.8+ for the Python SDK, or Node.js 18+ for the JavaScript SDK.

• The microphone examples use sounddevice (Python) and SoX (JavaScript). Any source that hands you audio chunks works.

Transcribe live audio

transcribe_live() in Python and transcribeLive() in JavaScript take a source that produces audio over time, upload each chunk as it arrives, and return the transcript once the source ends.

Microphone audio is raw PCM with no header, so the config names the sample rate and channel count.

Python SDK

The source is any iterable of bytes. This generator records from the default microphone until you press Enter. The capture callback puts each chunk on a queue and the generator drains it, so recording continues while transcribe_live() is busy on the network. A blocking read() inside the generator would instead overflow the device buffer and silently drop audio whenever the upload stalls:

import queue
import threading

import sounddevice as sd  # pip install sounddevice

from assemblyai.sync.v1 import SyncTranscriber, SyncTranscriptionConfig

RATE = 16000
config = SyncTranscriptionConfig(sample_rate=RATE, channels=1)


def microphone():
    """Yield raw 16-bit PCM from the default microphone until Enter is pressed."""
    chunks = queue.Queue()

    def stop():
        input("Recording. Speak now, then press Enter to stop... ")
        chunks.put(None)

    with sd.RawInputStream(
        samplerate=RATE, channels=1, dtype="int16",
        callback=lambda data, *_: chunks.put(bytes(data)),
    ):
        threading.Thread(target=stop, daemon=True).start()
        while (chunk := chunks.get()) is not None:
            yield chunk


result = SyncTranscriber().transcribe_live(microphone(), config=config)
print(result.text)

JavaScript SDK

The source is any async iterable, Node Readable, or web ReadableStream. Node has no built-in microphone, so this example uses SoX to record raw PCM to stdout and passes that stream straight in:

import { spawn } from "node:child_process";
import { AssemblyAI } from "assemblyai";

const client = new AssemblyAI({ apiKey: process.env.ASSEMBLYAI_API_KEY });

// Records 16 kHz, 16-bit, mono PCM to stdout until the process exits.
const microphone = spawn("sox", [
  "--default-device", "--no-show-progress",
  "--rate", "16000", "--channels", "1",
  "--encoding", "signed-integer", "--bits", "16", "--type", "raw", "-",
]);

console.log("Recording. Speak now, then press Ctrl+C to stop...");
process.on("SIGINT", () => microphone.kill()); // ends the stream

const result = await client.sync.transcribeLive(microphone.stdout, {
  sample_rate: 16000,
  channels: 1,
});
console.log(result.text);

Run it, say a sentence, and the transcript prints when the recording ends.

Use your own audio source

The call is the same for any source that produces audio over time. Replace the microphone with whatever you already have:

Python SDK

# Frames from a phone call, a WebSocket, or a file still being written.
result = transcriber.transcribe_live(frames_from_call(), config=config)

async generators work too, with AsyncSyncTranscriber.transcribe_live().

JavaScript SDK

// A browser posting PCM to your server as it records: `req` is a Readable.
const result = await client.sync.transcribeLive(req, {
  sample_rate: 16000,
  channels: 1,
});

A fetch response body or an async generator over WebSocket messages works the same way.

If your audio arrives through a callback rather than something you can iterate, such as a capture library or a WebRTC track, open a session instead: open_live() returns an object you write() each chunk to and close() when the speaker stops. The Quickstart has a runnable microphone version.

Ending the source normally uploads everything you sent. To throw a recording away without transcribing it, because the user cancelled or the call dropped, use session.abort(); result() then raises.

Audio you already hold in full, such as a buffer, a Blob, or a file on disk, belongs in transcribe(). Streaming a finished clip is slower than sending it whole.

What to keep in mind

• Keep producing until you’re done. An upload that goes silent for too long is aborted server-side. Finish by ending the source (or calling close()), not by pausing it.
• The saving comes from overlap. All but the last speech segment are transcribed while you record, so the win grows with clip length. Below roughly a minute there is only one segment, so the only saving is the elided upload.
• Errors can surface mid-upload. Authorization, rate-limit, and capacity failures can arrive part-way through the upload rather than at the end, as a SyncTranscriptError. Call warm() before you start recording to open the connection ahead of time.
• The audio limit is unchanged. The Sync API still caps audio at 120 seconds. The default request budget is 180 seconds, covering the recording as well as the transcription.

Next steps

• Transcribe a short audio file — the buffered path, for audio you already hold whole
• Connection pre-warming — open the connection before recording starts
• Prompting and keyterms — improve accuracy with contextual prompts and keyterm biasing
• Word timestamps — get per-word start/end timings
• Error handling — status codes and retry guidance
• API reference — full endpoint documentation

Need help?

If you get stuck, contact our support team at [e-mail] or create a support ticket. Include the session_id from the response to help us look up your request.