ElevenLabs AI Voices: Pricing and API Code (2026)

ElevenLabs AI voices are the text-to-speech models behind a large share of the narration you now hear in YouTube explainers, audiobook samples, e-learning modules and AI-generated video. You give the model a block of written text and an identifier for a speaker, and it returns an audio file of that speaker reading your words. What follows is the practical version of that: which models exist, what each one actually charges, the request shape that produces audio, and the specific things that go wrong when people wire this into a product for the first time.

What are ElevenLabs AI voices, exactly?

Speech synthesis, the artificial production of human speech by a computer, is an old field; the first electronic speech synthesizers date back decades and sounded like it. What changed recently is the method. Instead of stitching together recorded phonemes, modern systems generate the waveform directly from a neural model trained on speech, which is why they carry intonation, pauses and breath rather than a flat robotic cadence. ElevenLabs AI voices sit in that newer category, alongside the other generative models that produce images, video and music from a prompt.

Two terms matter before you write any code.

• Voice ID. A fixed string such as EkK5I93UQWFDigLMpZcX that always maps to the same speaker. It is not a name you make up; it is an identifier you pass in the request. The same ID produces the same narrator across a thousand separate calls, which is what lets you keep one consistent host across an entire series.
• Prosody controls. Numeric parameters that shape delivery rather than content: stability, style, similarity_boost and speed. These are the difference between a read that sounds like an audiobook and one that sounds like a hyperactive advert.

One thing to set expectations on: these models take plain text and parameters, not SSML, the XML markup language that older speech engines use to annotate pauses and emphasis tag by tag. You shape delivery through punctuation, line breaks and the parameters above. If you are migrating from a cloud TTS service, that is usually the single largest change to your pipeline: your SSML templates do not come with you.

Which models produce ElevenLabs AI voices?

Through Unicorn API there are three, and they split along a clean line. Two take a single block of text and one speaker. The third takes a conversation with several speakers.

Model	Takes	Price	Use it for
Text to Speech Turbo V2.5	text, voice, speed, style, stability	6 credits per 1,000 characters	Drafts, short clips, high-volume output
Text to Speech Multilingual V2	Same fields, plus language_code	12 credits per 1,000 characters	Long-form narration, non-English scripts
Text to Dialogue V3	dialogue array, stability, language_code	14 credits per request	Two-person scenes, interview formats

Note what each price scales with, because this is where budgets go sideways. The two text-to-speech models bill per 1,000 characters of input, rounded up: a 1,001-character script costs the same as a 2,000-character one. Dialogue V3 bills a flat 14 credits per request no matter how many turns the conversation contains, which makes long multi-speaker scenes cheap and single-line exchanges relatively expensive.

The company behind these models publishes its own research and tooling, and the model names you see here match the versions it ships. Turbo V2.5 and Multilingual V2 both carry a 2025-09-01 release date in the catalog; Dialogue V3 landed on 2026-01-14.

Choosing the right voice and settings for your project

Most people pick a voice by listening to five samples and choosing the one that sounds nicest in isolation. That is the wrong test. A voice that sounds pleasant on one sentence can become grating across forty minutes, and a voice that sounds slightly plain on a single line often carries long narration better. Audition with 200 to 300 words of your actual script, not a demo sentence.

What the parameters do

• stability controls how much the delivery varies between runs and within a passage. Low values give more emotional range and more surprises; high values give a predictable, even read. Long narration wants high stability. A character shouting in a game cutscene does not.
• similarity_boost pushes the output closer to the reference timbre of the chosen voice. Pushed too far it can amplify artefacts along with the likeness.
• style exaggerates the expressive character of the delivery. Useful in small amounts for adverts and trailers; it is the parameter most likely to make a read sound unhinged if you max it.
• speed adjusts pacing. Prefer rewriting the script over large speed changes; a sentence that needs a 1.3x read is usually a sentence that is too long.

Matching voice to format

For narration, audiobooks and documentary voiceover, favour high stability, moderate similarity boost and almost no style, then use Multilingual V2 because it holds tone more consistently across long passages. For short vertical video, the opposite: lower stability and a touch of style produce the quicker, punchier delivery that format expects, and Turbo V2.5 at half the price lets you regenerate the hook twenty times without thinking about it. For characters and conversation, go straight to Dialogue V3 rather than generating each line separately and splicing them; the model sequences the turns itself and the timing between speakers sounds far more natural than anything you will assemble in an editor.

How to generate ElevenLabs AI voices with the API

Every media model on Unicorn API follows the same two-step shape. You submit a job, then you poll it until it finishes. Start by creating a key at /keys and exporting it as UNICORN_API_KEY.

Submitting the job

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "elevenlabs-text-to-speech-turbo-2-5",
    "input": {
      "text": "Welcome back. In this episode we are going to take apart a request and see exactly what it costs."
    }
  }'

That returns a job object with an id and a status. Poll GET /v1/jobs/{id} until status is succeeded, then read the audio file from outputs[0].url.

A complete Python example

This version uses Multilingual V2 with an explicit voice and prosody settings, waits for the job and writes the file to disk.

import os, time, requests

BASE = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}

script = """The harbour was quiet that morning, the kind of quiet that
makes you check your watch twice."""

job = requests.post(
    f"{BASE}/v1/jobs",
    headers=HEADERS,
    json={
        "model": "elevenlabs-text-to-speech-multilingual-v2",
        "input": {
            "text": script,
            "voice": "EkK5I93UQWFDigLMpZcX",
            "stability": 0.7,
            "similarity_boost": 0.75,
            "language_code": "en",
        },
    },
).json()

job_id = job["id"]

while True:
    job = requests.get(f"{BASE}/v1/jobs/{job_id}", headers=HEADERS).json()
    if job["status"] in ("succeeded", "failed"):
        break
    time.sleep(2)

if job["status"] == "failed":
    raise RuntimeError(job)

audio_url = job["outputs"][0]["url"]
with open("narration.mp3", "wb") as f:
    f.write(requests.get(audio_url).content)

print("wrote narration.mp3")

Two details worth copying into your own code. First, break the loop on failed as well as succeeded, or a rejected job will spin forever. Second, download the file rather than linking to the output URL from your app; fetch once, write it to your own storage, and serve your copy.

Multi-speaker dialogue

Dialogue V3 replaces text with a dialogue array. Each entry has its own text and its own voice, so one request produces a sequenced exchange.

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "elevenlabs-text-to-dialogue-v3",
    "input": {
      "dialogue": [
        {"text": "You said the deploy was clean.", "voice": "EkK5I93UQWFDigLMpZcX"},
        {"text": "It was clean. It was also on the wrong cluster.", "voice": "EkK5I93UQWFDigLMpZcX"}
      ],
      "stability": 0.5
    }
  }'

Give each speaker a different voice ID in production; the example repeats one only because that is the identifier shown in the catalog. The full set of models and their fields lives at /models, and the request reference is in the docs. If you would rather hear a voice before writing anything, the audio playground runs the same models in the browser.

What do ElevenLabs AI voices cost in credits?

Credits are the single unit of account across every model: images, video, chat and audio all draw from one balance. On a monthly plan a credit is $0.01, so plans run from Starter at $25 through Creator at $50, Studio at $100 and Pro at $200 a month. Top-up credits cost $0.015 each and never expire, which makes them the right instrument for an occasional spike rather than steady usage.

Here is what that means for real scripts, at plan rates:

Job	Characters	Turbo V2.5	Multilingual V2
Short video hook	~400	6 credits ($0.06)	12 credits ($0.12)
Five-minute explainer	~4,500	30 credits ($0.30)	60 credits ($0.60)
Podcast episode script	~24,000	144 credits ($1.44)	288 credits ($2.88)

Two practical consequences. Because billing rounds up per 1,000 characters, splitting a 4,500-character script into nine arbitrary 500-character chunks costs nine rounding-ups instead of five: 54 credits rather than 30. Batch sensibly, and split on paragraph boundaries near the 1,000-character mark rather than wherever your loop happens to land. And because Turbo is exactly half the price, the obvious workflow is to iterate on wording with Turbo and render the final take with Multilingual V2, which costs you one extra render instead of twenty.

When you want certainty rather than arithmetic, POST /v1/models/price returns the exact cost of a request body before you run it. Call it with the same payload you are about to submit and you get a number you can show a user or log against a budget. Plans and credit prices are listed in full at /pricing.

Adding music and sound under the voice

A finished piece of audio is rarely just a voice. Once the narration exists you usually want a bed underneath it, and the same key and balance reach the music models in the catalog. Ai Music API Sounds generates short pieces from a text prompt at 3 credits per track, which is cheap enough to generate a dozen beds and pick one. Generate Lyrics and Boost Music Style each cost 1 credit per output and are useful for drafting words and style descriptions before you spend on a full track, while Ai Music API Mashup at 12 credits per track handles longer arrangements built from uploaded references.

The sequence that works: render narration first, time the music to its actual length rather than your estimate, and mix the bed well under the voice. If you are producing music more than speech, the model-by-model music comparison goes deeper than this section can. For reading long documents aloud rather than producing media, the text to speech reader write-up covers that workflow.

Mistakes people make with ElevenLabs AI voices

The failures are consistent, and almost none of them are about model quality.

1. Treating the output URL as permanent hosting. Download the file and serve your own copy. This is the single most common production incident with generated media.
2. Regenerating the whole script to fix one sentence. Render in paragraph-sized chunks so a bad line costs one small re-render rather than a full episode.
3. Pasting in text the model will read literally. Markdown asterisks, URLs, footnote markers and raw numbers like “1,200,000” all get spoken. Normalise your script before sending it: write “one point two million” if that is what you want to hear.
4. Maxing style and wondering why it sounds unstable. Start near the middle, change one parameter at a time, and keep the settings that work in a config file rather than scattered through your code.
5. Changing voice IDs mid-series. Record the ID in version control with the project. A listener will notice a swapped narrator long before they notice a slightly better one.
6. Skipping the disclosure question. Synthetic speech that imitates a real person raises consent and labelling obligations that vary by jurisdiction and platform. Decide your policy before publishing, not after a complaint.
7. Polling too aggressively. Two seconds between status checks is plenty. Tighter loops gain you nothing and make your logs harder to read.

Getting started is deliberately short: create a key, send the Turbo request above, listen to the result, then decide whether the extra 6 credits per 1,000 characters for Multilingual V2 buys you something your audience will hear. If you work from an editor or terminal agent, the MCP integration lets you drive the same models from Cursor or Claude Code without writing the HTTP layer at all. ElevenLabs AI voices are a small part of a pipeline that usually also involves images and video, and the practical argument for running them through one API is simply that you stop reconciling four invoices to answer one question about what a project cost.