ElevenLabs Scribe v2 Realtime Tutorial: Real-Time Speech-to-Text in Python

Scribe v2 Realtime is ElevenLabs' streaming speech-to-text model. It returns text while people are still talking, in under 150ms according to ElevenLabs, and it handles more than 90 languages with a low error rate across accents. That makes it a good fit for voice agents, live captions, and meeting note-takers.

In our YouTube preview, a voice agent uses Scribe v2 Realtime to transcribe the conversation as it happens. This guide rebuilds that agent in Python with Vision Agents, then adds the parts the short video skips: saving the transcript, tuning recognition, and transcribing audio files.

Updated November 2026: The code now matches the current Vision Agents release. We also added sections on saving transcripts, tuning the model, batch transcription, and ElevenLabs' new Scribe v3 Live model, which launched on November 10.

How the Pieces Fit Together

The agent listens to a WebRTC call, sends the incoming audio to Scribe v2 Realtime, and passes each finished sentence to an LLM. The LLM's reply goes to ElevenLabs text-to-speech and is played back into the call. Vision Agents connects these steps, so you only pick a provider for each one:

Scribe also tells the agent when someone has finished speaking, using voice activity detection (VAD). The agent doesn't need a separate turn-detection model.

Set Up the Project

You need four keys: ElevenLabs, Google AI Studio for Gemini, and a Stream API key and secret. Save them in the .env file of your Python project, or permanently on your machine, for example in .zprofile on a Mac.

ELEVENLABS_API_KEY=...
GOOGLE_API_KEY=...
STREAM_API_KEY=...
STREAM_API_SECRET=...

Then create a project with uv and install Vision Agents with the three plugins this agent uses:

uv init scribe-realtime-agent
cd scribe-realtime-agent

uv add "vision-agents[getstream, gemini, elevenlabs]" python-dotenv

Run a Voice Agent with Scribe v2 Realtime

Replace the content of your project's main.py with this script:

from dotenv import load_dotenv
from vision_agents.core import Agent, AgentLauncher, Runner, User
from vision_agents.plugins import elevenlabs, gemini, getstream

load_dotenv()


async def create_agent(**kwargs) -> Agent:
    return Agent(
        edge=getstream.Edge(),
        agent_user=User(name="Assistant", id="agent"),
        instructions="You're a helpful voice assistant. Be concise.",
        llm=gemini.LLM("gemini-flash-lite-latest"),
        stt=elevenlabs.STT(model_id="scribe_v2_realtime"),
        tts=elevenlabs.TTS(),
    )


async def join_call(agent: Agent, call_type: str, call_id: str, **kwargs) -> None:
    call = await agent.create_call(call_type, call_id)
    async with agent.join(call):
        await agent.responses.create("Greet the user")
        await agent.finish()


if __name__ == "__main__":
    Runner(AgentLauncher(create_agent=create_agent, join_call=join_call)).cli()

Start it with uv run main.py run. The CLI prints a link to a browser call. Join it and start talking: Scribe transcribes what you say, Gemini answers, and the agent replies out loud.

scribe_v2_realtime is already the plugin's default, so elevenlabs.STT() does the same thing. We pass it explicitly here so you can see where to change the model later.

Turn the Conversation into Meeting Notes

Hearing the agent is one thing, but for note-taking you want the text. Vision Agents sends a UserTranscriptEvent each time Scribe finishes transcribing something a person said. Subscribe to it inside create_agent and write each line to a file:

from datetime import datetime

from vision_agents.core import Agent, User
from vision_agents.core.agents.events import UserTranscriptEvent
from vision_agents.plugins import elevenlabs, gemini, getstream


async def create_agent(**kwargs) -> Agent:
    agent = Agent(
        edge=getstream.Edge(),
        agent_user=User(name="Note Taker", id="agent"),
        instructions="You take notes in meetings. Only speak when someone asks you a question.",
        llm=gemini.LLM("gemini-flash-lite-latest"),
        stt=elevenlabs.STT(model_id="scribe_v2_realtime"),
        tts=elevenlabs.TTS(),
    )

    @agent.events.subscribe
    async def save_transcript(event: UserTranscriptEvent):
        participant = event.participant
        speaker = (participant.name or participant.user_id) if participant else "Unknown"
        timestamp = datetime.now().strftime("%H:%M:%S")
        with open("meeting-notes.txt", "a") as notes:
            notes.write(f"[{timestamp}] {speaker}: {event.text}\n")

    return agent

Every participant in the call gets their own lines, labeled with their display name. From there, you could ask the LLM to summarize meeting-notes.txt when the call ends, or post the notes to a chat channel.

If you need transcripts and captions for every call without running an agent, Stream Video can also transcribe calls on its own. Our real-time transcription glossary entry covers how the two approaches differ.

Tune Recognition for Your Audio

The ElevenLabs STT plugin assumes English and a fairly quiet room. Two kinds of settings change that:

  • Language. language_code defaults to "en". Set it to the language your users speak, like "es" or "de".
  • When a sentence counts as finished. Scribe decides a speaker has stopped after vad_silence_threshold_secs of silence (0.3 by default). Raise it if the agent cuts people off mid-thought. vad_threshold (0.4 by default) controls how loud audio has to be to count as speech, so raise it in noisy rooms.
from vision_agents.plugins import elevenlabs

stt = elevenlabs.STT(
    model_id="scribe_v2_realtime",
    language_code="es",
    vad_silence_threshold_secs=0.6,
    vad_threshold=0.5,
)

min_speech_duration_ms and min_silence_duration_ms (both 100ms by default) fine-tune the same detection if the two settings above aren't enough.

Building your own app? Get access to our Livestream or Video Calling API and launch in days!

Transcribing Recorded Audio Instead

Scribe v2 Realtime is for live audio. For a file, like a podcast episode or a recorded call, use ElevenLabs' batch model through the official Python SDK (uv add elevenlabs). The batch model can also tell speakers apart and tag sounds like laughter:

import os

from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs

load_dotenv()

client = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))

with open("recording.mp3", "rb") as audio:
    transcription = client.speech_to_text.convert(
        file=audio,
        model_id="scribe_v3",
        diarize=True,  # label who is speaking
        tag_audio_events=True,  # mark laughter, applause, and other sounds
    )

print(transcription.text)

Where Scribe v3 Live Fits

ElevenLabs released Scribe v3 on November 10, 2026, in two versions: scribe_v3 for files (used above) and scribe_v3_live for real-time audio. ElevenLabs reports that v3 Live has 31% lower word error rate than Scribe v2 Realtime across 102 languages. It's also the first ElevenLabs real-time model that labels speakers, and it predicts the end of a turn from the conversation instead of only from silence.

At the time of this update, the Vision Agents ElevenLabs plugin still uses Scribe v2 Realtime and its silence-based turn detection. ElevenLabs hasn't announced a retirement date for Scribe v2 Realtime, so the code in this guide keeps working. Check the plugin's page on PyPI for v3 Live support before switching model_id.

Choosing a Speech-to-Text Provider

Speech-to-text is one setting in a Vision Agents app, so you can test several providers against your own audio:

ElevenLabs Scribe suits multilingual apps, and pairs naturally with ElevenLabs text-to-speech if you want one vendor for both directions.

Deepgram is a long-standing choice for English voice agents, and its Vision Agents plugin covers both speech-to-text and text-to-speech.

Cartesia Ink comes from the team behind the Sonic voices, and its plugin detects turns too. Our Cartesia Sonic tutorial uses it.

Whichever you choose, transcription is only one part of how fast your agent answers. Our breakdown of real-time AI agent latency shows where the rest of the time goes, and the step-by-step voice agent guide puts all the parts together.

Scribe v2 Realtime FAQs

What is ElevenLabs Scribe v2 Realtime?

It's ElevenLabs' streaming speech-to-text model. It transcribes live audio as people speak, supports more than 90 languages, and its API model ID is scribe_v2_realtime.

How fast is Scribe v2 Realtime?

ElevenLabs says it returns transcripts in under 150ms. Your LLM and text-to-speech model add their own delay after that, so measure the full round trip.

What's the difference between Scribe v2 and Scribe v3?

Scribe v3, released in November 2026, is more accurate: ElevenLabs reports 27% fewer word errors for the batch model and 31% fewer for v3 Live compared to v2 Realtime. v3 Live also labels speakers in real time and predicts turns from context.

Can Scribe tell who is speaking?

The batch models can, with diarize=True. Among the real-time models, only Scribe v3 Live does. In a Vision Agents call, the agent processes each participant's audio separately, so transcripts are already tied to a person, as in the meeting-notes example above.

Is there a Python SDK for ElevenLabs speech-to-text?

Yes. The elevenlabs package covers batch and real-time transcription. For voice agents, the Vision Agents ElevenLabs plugin wraps it and handles streaming call audio for you.

Vision Agents and Plugins