ElevenLabs vs Cartesia: Best Voice AI API 2026

TL;DR

Cartesia for real-time voice agents — 27x cheaper at $0.011/1K chars; the latency evidence below does not establish a general winner for conversational AI. ElevenLabs for quality-first audio production — 70+ languages, the broadest voice library, dubbing, sound effects, and a complete platform for content creators and multilingual apps. For latency-sensitive applications: evaluate both providers with the same model-specific, region-specific test before choosing.

Key Takeaways

Cartesia pricing: $0.011/1K chars (~27x cheaper than ElevenLabs)
ElevenLabs pricing: ~$0.206/1K chars (equivalent on creator+ plans)
Latency evidence: the figures previously shown were historical vendor-sourced claims, not APIScout measurements.
Measurement: distinguish first-byte, first-audible-audio, and application playback latency.
Architecture: Cartesia uses State Space Models (SSMs); ElevenLabs uses transformers
Language support: ElevenLabs 70+ languages; Cartesia 15 languages
Voice cloning: Cartesia requires 3 seconds; ElevenLabs requires 30 seconds
Platform scope: ElevenLabs is full audio platform; Cartesia is API-only TTS

Why Voice AI Latency Matters

For voice agents (AI phone calls, real-time assistants, customer support bots), TTS is one part of the delay before a caller hears a reply. Measure the full turn rather than treating a single TTS figure as the conversation's latency.

User speaks → STT transcription → LLM inference → TTS → User hears response

Measure each stage from the same deployment, including network and playback buffering; the historical TTS figures do not establish full-turn latency.

An isolated TTS latency figure does not establish deployment share or the quality of a complete voice conversation.

Cartesia

Architecture: State Space Models

Cartesia's Sonic model is built on State Space Models (SSMs) — a fundamentally different architecture from transformer-based TTS. SSMs maintain a compact recurrent state that updates incrementally as text arrives, enabling streaming synthesis before the full sentence is processed.

# Cartesia Python SDK
from cartesia import Cartesia
import pyaudio

client = Cartesia(api_key=os.environ["CARTESIA_API_KEY"])

# Stream audio for low-latency playback
p = pyaudio.PyAudio()
rate = 44100
stream = p.open(format=pyaudio.paFloat32, channels=1, rate=rate, output=True)

# Generate and stream immediately
output_format = {
    "container": "raw",
    "encoding": "pcm_f32le",
    "sample_rate": rate,
}

for output in client.tts.sse(
    model_id="sonic-2",
    transcript="Hello, how can I help you today?",
    voice={"mode": "id", "id": "a0e99841-438c-4a64-b679-ae501e7d6091"},
    output_format=output_format,
    stream=True,
):
    buffer = output.get("audio")
    if buffer:
        stream.write(buffer)

stream.stop_stream()
stream.close()
p.terminate()

WebSocket API for Real-Time Agents

For voice agents, use the WebSocket API to send text chunks as they arrive from the LLM:

import asyncio
import websockets
import json

async def voice_agent_response(llm_text_stream, voice_id: str):
    """Stream LLM output directly to Cartesia for ultra-low latency."""
    uri = "wss://api.cartesia.ai/tts/websocket"
    headers = {
        "Cartesia-Version": "2024-06-10",
        "X-API-Key": os.environ["CARTESIA_API_KEY"],
    }

    async with websockets.connect(uri, additional_headers=headers) as ws:
        context_id = "ctx-001"

        # Send text chunks as they arrive from LLM streaming
        async for text_chunk in llm_text_stream:
            await ws.send(json.dumps({
                "context_id": context_id,
                "model_id": "sonic-2",
                "transcript": text_chunk,
                "voice": {"mode": "id", "id": voice_id},
                "output_format": {
                    "container": "raw",
                    "encoding": "pcm_f32le",
                    "sample_rate": 16000,
                },
                "continue": True,  # More chunks coming
            }))

        # Signal end of utterance
        await ws.send(json.dumps({
            "context_id": context_id,
            "transcript": "",
            "continue": False,
        }))

        # Receive audio chunks and play/send to telephony
        async for message in ws:
            data = json.loads(message)
            if audio := data.get("audio"):
                yield base64.b64decode(audio)

Voice Cloning (3 seconds of audio)

# Clone a voice from 3 seconds of audio
import requests

response = requests.post(
    "https://api.cartesia.ai/voices/clone/clip",
    headers={
        "Cartesia-Version": "2024-06-10",
        "X-API-Key": os.environ["CARTESIA_API_KEY"],
    },
    files={"clip": open("sample.wav", "rb")},
    data={"name": "Custom Voice"},
)
voice_id = response.json()["id"]

# Use immediately in generation
for output in client.tts.sse(
    model_id="sonic-2",
    transcript="Your cloned voice is ready.",
    voice={"mode": "id", "id": voice_id},
    output_format={"container": "mp3", "bit_rate": 128000, "sample_rate": 44100},
):
    pass  # Process audio chunks

ElevenLabs

The Full Audio Platform

ElevenLabs is more than TTS — it's a complete audio production platform. Beyond the API, it includes:

Conversational AI: Pre-built voice agent framework with turn detection, interruption handling, and telephony integrations
AI Dubbing: Automatically dub content into 29 languages preserving the original speaker's voice
Text to Sound Effects: Generate custom SFX from text descriptions
Studio: Long-form audio editor for narration and audiobooks
ElevenReader: iOS/Android app that reads any content aloud

For developers, the API covers TTS, speech-to-speech, voice cloning, and the Conversational AI framework.

TTS API

from elevenlabs import ElevenLabs

client = ElevenLabs(api_key=os.environ["ELEVENLABS_API_KEY"])

# Basic TTS with the best quality model
audio = client.text_to_speech.convert(
    voice_id="JBFqnCBsd6RMkjVDRZzb",  # George — deep British narrator
    model_id="eleven_turbo_v2_5",       # Best latency/quality balance
    text="The quick brown fox jumps over the lazy dog.",
    output_format="mp3_44100_128",
    voice_settings={
        "stability": 0.5,
        "similarity_boost": 0.75,
        "style": 0.0,
        "use_speaker_boost": True,
    },
)

with open("output.mp3", "wb") as f:
    for chunk in audio:
        f.write(chunk)

Streaming for Low-Latency Apps

The SDK example below is unchanged. Its inline latency estimate is historical, not a current benchmark or latency guarantee.

# Streaming TTS for voice agents
for audio_chunk in client.text_to_speech.convert_as_stream(
    voice_id="JBFqnCBsd6RMkjVDRZzb",
    model_id="eleven_flash_v2_5",  # Fastest ElevenLabs model (~300ms enterprise)
    text="How can I help you today?",
    output_format="pcm_16000",  # Raw PCM for telephony
):
    # Send to telephony / WebSocket / audio buffer
    send_audio(audio_chunk)

Multilingual TTS (70+ Languages)

# ElevenLabs handles non-English natively
audio = client.text_to_speech.convert(
    voice_id="JBFqnCBsd6RMkjVDRZzb",
    model_id="eleven_multilingual_v2",
    text="Bonjour, comment puis-je vous aider aujourd'hui?",  # French
    language_code="fr",
    output_format="mp3_44100_128",
)

# Auto-detect language (no language_code needed)
audio_ja = client.text_to_speech.convert(
    voice_id="JBFqnCBsd6RMkjVDRZzb",
    model_id="eleven_multilingual_v2",
    text="こんにちは、本日はどのようなご用件でしょうか？",  # Japanese
)

Conversational AI (Voice Agent Framework)

ElevenLabs includes a full voice agent SDK — not just TTS:

from elevenlabs.conversational_ai.conversation import Conversation
from elevenlabs.conversational_ai.default_audio_interface import DefaultAudioInterface

conversation = Conversation(
    client=client,
    agent_id=os.environ["ELEVENLABS_AGENT_ID"],
    requires_auth=False,
    audio_interface=DefaultAudioInterface(),
    callback_agent_response=lambda response: print(f"Agent: {response}"),
    callback_user_transcript=lambda transcript: print(f"User: {transcript}"),
)

conversation.start_session()
# Real-time two-way voice conversation — handles STT + LLM + TTS

Pricing Comparison

Cartesia (2026 pricing):
  Free:        1,000 characters/month
  Scale:       $0.011 per 1,000 characters
  Enterprise:  Custom (volume discounts)

  Example: 10M characters/month → $110/month

ElevenLabs (2026 pricing):
  Free:        10,000 chars/month
  Starter:     $5/month — 30,000 chars ($0.167/K chars)
  Creator:     $22/month — 100,000 chars ($0.22/K chars)
  Pro:         $99/month — 500,000 chars ($0.198/K chars)
  Scale:       $330/month — 2,000,000 chars ($0.165/K chars)
  Business:    $1,320/month — 10,000,000 chars ($0.132/K chars)
  Enterprise:  Custom

  Example: 10M characters/month → $1,320/month (vs Cartesia $110)

Cost ratio at 10M chars/month: ElevenLabs costs ~12x more. At 100M chars, Cartesia wins by an even larger margin. ElevenLabs' per-character rate improves with volume but never approaches Cartesia's pricing.

Latency Benchmarks

The previous table was labelled p50 measurements, but its figures came from vendor materials cited in March 2026, not an APIScout head-to-head test. We have removed it rather than present those figures as current, comparable measurements.

An October 9, 2026 vendor-run study by SpeechifyAI, which includes its own API, separates first-byte and first-audible timings and reports results by endpoint, region, and warm/cold connection. We have not reproduced that study and do not use it here to declare a general winner.

Current independent methodology from Coval includes leading silence in first-audible latency. Compare results only when the model, transport, measurement definition, region, and connection conditions are clear.

Feature Comparison

Feature	Cartesia	ElevenLabs
Price (per 1K chars)	~$0.011	~$0.132–$0.206
Latency evidence	Vendor-sourced; see latency note	Vendor-sourced; see latency note
Architecture	SSMs (recurrent)	Transformer
Languages	15	70+
Voice cloning speed	3 seconds	30 seconds
Voice cloning slots	Unlimited	10–660 (plan-dependent)
WebSocket streaming	✅	✅
Conversational AI SDK	❌	✅ full framework
AI dubbing	❌	✅ (29 languages)
Sound effects	❌	✅
Voice design	✅	✅
Voice library	Limited	Massive (thousands)
Speech-to-speech	❌	✅
SOC 2	✅	✅
HIPAA	Enterprise	Enterprise
SDKs	Python, JS/TS, Go	Python, JS/TS
Free tier	1K chars/month	10K chars/month

Decision Guide

Choose Cartesia when:

Building real-time voice agents (phone bots, voice assistants)
You have verified its latency against your application's requirements using the same test conditions as alternatives
Cost efficiency matters — high character volume
English-primary or you only need 15 language support
API-only, no platform features needed

Choose ElevenLabs when:

You need 70+ language support
Building multilingual dubbing pipelines
You are evaluating quality and voice variety alongside latency
Using the Conversational AI framework (built-in STT + LLM + TTS orchestration)
Content creation, audiobooks, narration (not just real-time voice agents)
You want the full audio platform (sound effects, studio)

Integrating with Voice Agent Pipelines

Neither Cartesia nor ElevenLabs exists in isolation — in production, they sit inside a pipeline: speech-to-text (STT) → LLM → TTS. The TTS choice affects the whole pipeline's end-to-end latency, not just the TTS step in isolation.

A production voice agent architecture with Cartesia:

User audio → Deepgram (STT, ~200ms) → streaming transcript
                              ↓
                 Claude/GPT-4o (LLM, first token ~200ms)
                              ↓
               Cartesia Sonic (WebSocket; measure latency in your deployment)
                              ↓
                     Audio to telephony/browser

The critical optimization is chaining the streams: as the LLM produces tokens, send them directly to Cartesia's WebSocket API without waiting for the full LLM response. Cartesia's architecture handles incomplete sentences and starts generating audio from the first few words. Streaming can overlap stages, but it does not remove TTS startup, network, or playback delay.

ElevenLabs' Conversational AI framework handles this chaining internally — it manages the STT, LLM, and TTS orchestration so you don't implement the streaming chain yourself. The trade-off: you configure the agent via ElevenLabs' dashboard and their LLM options, rather than bringing your own LLM choice. For teams that want full control over the LLM (model selection, system prompt, tool use), the raw TTS API with custom streaming is the right path.

Telephony integration is a common production scenario. Both Cartesia and ElevenLabs support Twilio integration — Cartesia via WebSocket with pcm_mulaw 8kHz output format (Twilio's format), ElevenLabs via their Conversational AI telephony integration. LiveKit (the leading WebRTC SFU for voice agents) has official integrations with both providers and handles the audio transport, room management, and participant coordination so you focus on the AI logic rather than WebRTC internals.

For browser-based voice interfaces (not telephony), both APIs work via the Web Audio API. Cartesia's raw PCM output requires client-side decoding; ElevenLabs' MP3 streaming is easier to play directly. The additional decode step with Cartesia adds negligible latency in browser contexts.

Methodology

Latency correction reviewed October 21, 2026: the removed numerical table was based on historical vendor materials, not APIScout p50 measurements. The linked October 9 SpeechifyAI study is vendor-run and has not been independently reproduced by us. Coval's current methodology distinguishes first-audible latency from first-chunk arrival by including leading silence, and ElevenLabs' latency documentation distinguishes model inference from application playback latency. No general latency winner is established here. Pricing sourced from both providers' published pricing pages as of March 2026. Character-to-cost ratio comparisons assume the standard plan pricing — ElevenLabs enterprise pricing may differ. Language counts: ElevenLabs 70+ as of March 2026, Cartesia 15 as of March 2026; both providers expand language support on a regular cadence. SSM architecture details sourced from Cartesia's technical blog. The Conversational AI framework comparison is based on ElevenLabs' documented framework capabilities; Cartesia's roadmap may include similar orchestration tooling in future releases. LiveKit integration availability verified from both providers' documentation pages as of March 2026.

Browse all voice AI and TTS APIs at APIScout.