
Eleven Realtime Mini vs Max: I Tested Latency and Cost
Start with Eleven Realtime v1 Mini. In my test, Max didn't get to the first word any faster, but it went silent for 1.4 to 1.7 seconds after each tool result, where Mini took 0.3 seconds. Max's extra cost is real but smaller than the token prices suggest, because connected audio is most of the bill. Pick Max when you need Zero Retention Mode or HIPAA, or when Mini fails your long instructions. Everything else on the spec sheet is close. Below are the numbers from 12 sessions, the client I used, and two things in the event stream that will trip up your logging.
What Are Eleven Realtime Mini and Max?
They're ElevenLabs' managed voice-agent models, launched October 19 and opened to every workspace on November 2, 2026. You pick one model and ElevenLabs runs the speech recognition, LLM and TTS behind it. Mini (eleven_realtime_v1_mini) is the default and the cheap one. Max (eleven_realtime_v1_max) "reasons before it responds," per the Realtime models docs. The FAQ there says both are cascaded, not fused speech-to-speech models.
You can use them two ways: flip an existing ElevenAgents agent to Realtime voice mode, or talk to the OpenAI-compatible Realtime WebSocket directly. I used the WebSocket because it gave me raw event timestamps. ElevenLabs publishes 620 ms to first audio for Mini and 570 ms for Max. Every review I found repeats those numbers. Nobody had posted their own measurements, so I took some.
On paper, Max is faster, smarter at tools and about 9x pricier per input token. In my test, only the last part held up the way the spec sheet implies.
How I Tested Mini vs Max
Same setup for both models, from my Mac mini in Allen, Texas, on November 12, 2026:
- A plumbing-receptionist prompt with hours, an $89 diagnostic fee, a rule for when the fee is waived, and two tools:
check_availabilityandbook_appointment. The stub always returned 1:00 PM and 3:30 PM. - Four caller questions recorded with macOS
say, converted to 24 kHz PCM16, and streamed in 100 ms chunks at real-time pace, followed by silence so turn detection could close the turn. Defaultsemantic_vad, medium eagerness. - One fresh client secret and WebSocket per session. Latency is measured from the caller's last voiced sample (I trimmed the ~0.2 s of trailing silence in each file) to the first
response.output_audio.delta.
This was on a free-tier workspace, and the 10,000 monthly credits ran out after 12 complete Realtime sessions (6 per model) and a handful of Custom-mode runs. So it's a small sample. The tool-call gap was big enough that I'm confident in it. The first-audio difference isn't, and I'll say so where it matters.
Is Eleven Realtime Max Slower Than Mini?
Not to the first word. Here's everything I measured:
| Measured | Realtime v1 Mini | Realtime v1 Max |
|---|---|---|
| Caller's last word to first audio (median) | 1.03 s | 0.86 s |
| Caller's last word to first audio (range) | 0.69 to 1.09 s | 0.65 to 1.34 s |
| Tool result sent to first audio | 0.30 to 0.32 s | 1.44 to 1.71 s |
| Called a tool when the question needed one | 2 of 2 | 2 of 3 |
| Reply audio, same 4 questions (repeats averaged) | 38.9 s | 47.1 s (+21%) |
| Token credits metered (6 sessions) | 26 | 279 |
| Wrong facts (hours, fee, waiver rule) | 0 | 0 |
Both models landed between 0.65 and 1.34 seconds, which is slower than the published 570 to 620 ms. That's expected. My number includes the time turn detection waits to decide you're done talking, plus the network from Texas. The vendor number almost certainly doesn't.
The shortest question ("are you guys open on Saturday?") was the slowest on both models, 1.07 to 1.34 s, every time. The longer questions came back in 0.65 to 0.98 s. That pattern points at end-of-turn detection, not at the model. If your callers ask short questions, both models will feel a beat slow. I wrote about the other side of that tradeoff in why voice agents keep interrupting callers.
I wouldn't read much into Max's lower median. Six sessions per model, overlapping ranges. What I'd say is that Max's reasoning doesn't add a delay before the first word on simple turns.
Where Does Max Lose Time?
After tool calls. When the model calls check_availability, your code sends back a function_call_output and a response.create. From that moment, Mini started speaking in 0.30 and 0.32 seconds. Max took 1.44 and 1.71 seconds.
On a phone call, 1.5 seconds of silence after "let me check" is where callers say "hello?" Both models spoke a short preamble before calling the tool ("Let me check our availability for next Tuesday afternoon"), which covers some of it. Max's gap is on top of that, after the tool already answered. If you run Max with tools, keep your tool fast and make the preamble a little longer.
Tool behavior itself was mixed. When the caller asked for "next Tuesday afternoon," Mini called check_availability(one run before my credits ran out). Max got that question twice and called the tool once. The other time it just asked "What time works best for you?", which is legal under my prompt but not what I wanted. On the long booking request, both checked Thursday, saw that 2 PM wasn't open, offered the two real slots and got the fee rule right. Max also said "I will also look up the fee policy for you," and there was no tool for that.
ElevenLabs says Max wins on tool-call success, and on harder multi-step chains it probably does. On a two-tool receptionist, I didn't see it.
How Much Does Eleven Realtime Cost, Mini vs Max?
List pricing on the ElevenLabs API pricing page is $0.08 per connected minute for both models. On top of that, Mini charges $0.20 per million input tokens and $6.00 per million output tokens. Max charges $1.80 and $9.00. Read only the token columns and Max looks 9x more expensive.
Here's what the usage API actually metered for my run:
GET /v1/usage/character-stats?breakdown_type=model&aggregation_interval=hour&...
eleven_realtime_v1_audio 2575 # connected audio, both models share this meter
eleven_realtime_v1_max 279 # Max tokens
eleven_realtime_v1_mini 26 # Mini tokens
convai_v0 347 # the Custom-mode comparison agent
deepseek-v41-flash 28 # its LLMMax burned 10.7x the token credits of Mini (279 vs 26), but connected audio was 89% of the Realtime spend. Splitting the shared audio meter by connected time (95.7 s for Max, 85.9 s for Mini), Max came out roughly 1.3x Mini per session. That's a rough estimate, not a line item, and the two models didn't run identical session mixes.
There's a second, quieter cost. Max talks more. Its replies were longer on every one of the four questions, 21% more audio overall, mostly from tacking on "Would you like to schedule an appointment?" Longer answers keep the line open longer, and the line is what you pay for. At scale, that 21% could cost you more than the token difference.
If you're comparing platforms on per-minute cost, my ElevenLabs Agents vs Retell AI breakdown covers what else gets billed on a real call.
What Will Trip Up Your Logging?
Four things in the event stream that I didn't see documented anywhere.
1. speech_stopped is not a latency marker
In 10 of 12 sessions, input_audio_buffer.speech_stoppedarrived within 15 ms of the first audio delta. The server holds the event until it has a reply ready, so timing from it makes every model look instant. Time from your own end of audio. Here's a Mini session:
t=3.0507 client.speech_end # last chunk sent (0.21 s of trailing silence in the file)
t=3.9115 input_audio_buffer.speech_stopped
t=3.9117 input_audio_buffer.committed
t=3.9117 conversation.item.input_audio_transcription.completed "Hi. Are you guys open on Saturday?"
t=3.9130 response.created
t=3.9133 response.output_audio.delta # first audio, 0.3 ms after response.created
t=10.9274 response.output_audio_transcript.done "[friendly] No, we are closed on Saturdays. ..."
t=10.9275 response.done usage: null2. There's no usage in response.done
OpenAI's Realtime API puts token counts on response.done. Here it was null on all 12 sessions. To get per-model cost, use /v1/usage/character-stats with breakdown_type=modeland an hourly interval, like the block above. You can't attribute cost per call from the socket alone.
3. Transcripts contain tags the voice doesn't say
5 of 15 agent transcripts had expressive tags in them: [Sorry], [friendly], [polite], sometimes in the middle of a sentence. I ran three of those replies through Whisper locally and none of the tags were spoken. They're delivery hints. But if you push response.output_audio_transcript.done into a CRM or an SMS follow-up, they go with it. Strip them:
import re
TAG = re.compile(r"\[[A-Za-z][A-Za-z ]{0,30}\]\s*")
def clean(transcript: str) -> str:
return TAG.sub("", transcript).strip()
clean("We are closed on Saturdays. Our hours are [polite] Monday through Friday")
# 'We are closed on Saturdays. Our hours are Monday through Friday'4. call_id formats differ between models
Mini's tool call IDs looked like chatcmpl-tool-bfc59e68…. Max's looked like check_availability_ba8333…. If anything in your stack validates or parses call IDs, switching models will break it. Treat them as opaque strings.
Is Realtime Faster Than a Custom-Mode Agent?
Not in my test. I created a throwaway ElevenAgents agent with the same prompt and left it in Custom mode. Created through the API on November 12, it defaulted to deepseek-v41-flash with eleven_v4_turbo and expressive mode on. The November 2 changelog says new agents default to Gemini 3.5 Flash, so check what yours got.
On the fee question, over the agent conversation WebSocket, it started answering 0.53 to 0.62 s after the caller stopped talking (5 runs). Mini took 0.69 s on that question and Max 0.94 s.
Big caveat: it's a different endpoint with different turn detection (turn_v3 with speculative turns on). My credits ran out before I could flip that agent to Realtime mode and test it like for like. So it's a hint, not a verdict. Still, if you already have a tuned Custom agent, don't assume Realtime will make it snappier. Measure it. If you're tuning the TTS side, my Eleven v4 Turbo WebSocket tests go deeper.
Remember that you can't use Realtime with a custom LLM or Bedrock, or with workflow nodes that override the LLM or TTS. Realtime agents can't transfer to Custom agents either. Publishing fails on those, and a transfer into a Realtime agent from a Custom one only fails during the call.
How Do I Run This Test on My Own Script?
This is the core of the client I used, trimmed. INSTRUCTIONS and TOOLS are your prompt and your function schemas. The full version also handles the tool round trip: when response.done contains a function_call, send function_call_output and response.create, and time to the next delta.
import asyncio, base64, json, os, time, urllib.request
import websockets # 17.4
def mint(model):
body = {"session": {"type": "realtime", "model": model,
"instructions": INSTRUCTIONS, "tools": TOOLS,
"output_modalities": ["audio"]},
"expires_after": {"seconds": 300}}
req = urllib.request.Request(
"https://api.elevenlabs.io/v1/convai/realtime/client_secrets",
data=json.dumps(body).encode(), method="POST",
headers={"xi-api-key": os.environ["ELEVENLABS_API_KEY"],
"Content-Type": "application/json"})
return json.load(urllib.request.urlopen(req))["value"]
async def one_turn(model, pcm): # pcm = 24 kHz mono PCM16
async with websockets.connect(
"wss://api.elevenlabs.io/v1/convai/realtime",
additional_headers={"Authorization": f"Bearer {mint(model)}"},
subprotocols=["realtime"], max_size=None) as ws:
marks = {}
async def talk():
for i in range(0, len(pcm), 4800): # 100 ms chunks
await ws.send(json.dumps({"type": "input_audio_buffer.append",
"audio": base64.b64encode(pcm[i:i + 4800]).decode()}))
await asyncio.sleep(0.1)
marks["spoke"] = time.perf_counter()
for _ in range(150): # keep the line open
await ws.send(json.dumps({"type": "input_audio_buffer.append",
"audio": base64.b64encode(b"\0" * 4800).decode()}))
await asyncio.sleep(0.1)
talker = asyncio.create_task(talk())
async for raw in ws:
m = json.loads(raw)
if m["type"] == "response.output_audio.delta" and "first" not in marks:
marks["first"] = time.perf_counter()
if m["type"] == "response.done":
break
talker.cancel()
return marks["first"] - marks["spoke"]Two notes. Minting a client secret took 60 to 430 ms (median under 0.1 s), and the gap from socket open to session.created was 0.9 to 1.7 s (median 1.1 s). On inbound phone calls, open the session while the call is ringing, not after pickup. And budget your test: on the free tier, 12 short sessions plus a few agent runs used about 3,000 credits.
Which One Should You Pick?
- Minifor receptionists, FAQ lines, lead qualification and simple booking. It was just as accurate on my script, called tools at least as reliably, and had a fifth of Max's dead air after tool results.
- Maxwhen you need Zero Retention Mode or HIPAA in the US or EU (Mini isn't available there), or when your prompt is long and Mini keeps dropping rules. Keep the token limit at 1,024 or higher, which Max requires.
- Custom mode when you need a specific LLM, a text-only agent, transfers to existing Custom agents, or your own latency tuning.
Whatever you pick, run your real caller questions through both before you migrate a live line. Six sessions per model took me a few minutes. That's cheap compared to a week of callers saying "hello? are you there?" If you're still choosing a platform, my Retell AI vs Vapi comparison covers the other two names that come up.
Frequently Asked Questions
Is Eleven Realtime Max slower than Mini?
Not to the first word: a median 0.86 s for Max vs 1.03 s for Mini in my test. After tool calls, yes: 1.4 to 1.7 s of silence for Max vs about 0.3 s for Mini.
How much does Eleven Realtime cost?
$0.08 per connected minute plus tokens. Mini: $0.20 / $6.00 per million input/output tokens. Max: $1.80 / $9.00. Connected audio was 89% of my spend, so Max cost about 1.3x Mini per session.
When should I use Eleven Realtime Max instead of Mini?
Under Zero Retention Mode or HIPAA, where Mini isn't offered, or when Mini fails long, complex instructions. For simple booking and FAQ agents, Mini did as well.
Why do Eleven Realtime transcripts contain words in brackets?
They're expressive tags like [Sorry] or [polite]. They appeared in 5 of 15 transcripts and weren't spoken. Strip them before storing transcripts.
Is Eleven Realtime faster than a Custom-mode agent?
Not in my test: 0.53 to 0.62 s for a Custom agent vs 0.69 s (Mini) and 0.94 s (Max) on the same question. Turn detection differs between the two paths, so test your own setup.
Deciding Whether to Move Your Voice Agent to Realtime?
I build and run voice agents for service businesses on ElevenLabs and Retell. Send me your script and your tools, and I'll tell you which mode fits and where the dead air will be before your callers find it.
Related Posts
Voice AI
Eleven v4 Turbo WebSocket Error: Fix + Latency Test
eleven_v4_turbo returns a 400 unsupported_model on the ElevenLabs TTS WebSocket. Moving to the Text to Dialogue socket fixes it, then brings a 20-second idle close, a 40-character buffer and session-based concurrency. Measured: 114 ms to first audio vs 138 ms on Flash v2.5.
Voice AI
ElevenLabs Agents vs Retell AI: The Real Per-Minute Cost
ElevenLabs Agents bills $0.08/min for hosting only — the LLM and the phone line are extra. Retell's $0.07 is $0.055 infrastructure plus $0.015 voice plus $0.015 telephony plus the model you pick. Worked math on a 3,000-minute month, why concurrency (not rate) decides the platform, and the finding that the model line moves the bill harder than the platform does.
Voice AI
Retell CLI: Ship Voice Agent Updates Without Breaking Prod
I ran @retell-ai/retell-cli 0.47.0 against throwaway agents. Publishing locks a version, so update-agent returns 422 until you create a draft; get-agent returns that draft; and a while-read loop feeds your input file into the request body.