ElevenLabs API Price (2026): Cost per 1,000 Characters

The ElevenLabs API price is mostly a function of one number: how many characters of text you send. Audio length, voice choice and output format matter far less than people expect, because ElevenLabs text to speech models are billed against the text going in, not the seconds coming out. Once you understand that, and the rounding rules around it, you can predict a voice bill to the cent before you write a line of production code.

This post covers how the billing model works, what changes between buying from ElevenLabs directly and buying through an aggregator, the exact credit cost of each ElevenLabs model on Unicorn API, a worked example for a real project, working code, and the mistakes that quietly double a bill.

How the ElevenLabs API price works

ElevenLabs is an AI voice company best known for realistic text to speech (TTS), the conversion of written text into spoken audio. Its API exposes several speech models, and nearly all of them are priced by character count. A character is any letter, digit, space or punctuation mark in the text field. “Hello, world.” is 13 characters.

Three things decide what a request costs:

• The model. Faster, lighter models cost less per character than the higher-quality multilingual ones.
• The character count. Longer text costs more, in a straight line.
• Rounding. Most providers bill in blocks, so a request is rounded up to the next block. This is where small requests get expensive.

Some newer features break the per-character pattern. Multi-speaker dialogue, for example, can be priced per request rather than per character, and conversational agents and speech-to-text are usually billed by time. When you compare any ElevenLabs API price, check which unit applies before you multiply anything.

Why characters and not minutes?

Characters are known before the job runs. Audio duration is not: it depends on the voice, the speed setting and how the model paces the sentence. Billing on input means you can calculate cost from the text alone, which is good for budgeting. The catch is that your “cost per minute” varies with how fast the voice speaks. If you need a per-minute figure for a business case, generate a representative sample, measure the audio length and divide. Do not trust a generic conversion.

What ElevenLabs charges directly: plans, limits and licences

Buying straight from ElevenLabs means choosing a subscription tier. Each tier comes with a monthly allowance of characters or credits, and higher tiers add features such as more voice slots, higher-quality audio output formats, professional voice cloning and a commercial licence. There is a free tier aimed at evaluation, and it carries restrictions on commercial use and attribution. Enterprise contracts are negotiated separately. We will not quote their figures here because they change; check their current pricing page before you commit.

The structural points matter more than the numbers:

• Allowances are monthly. Unused characters on a subscription typically do not carry forward forever, so a quiet month is money left on the table.
• Usage beyond the allowance is billed at an overage rate or requires an upgrade, depending on the tier.
• Features are gated by tier. If you need ElevenLabs voice cloning or a particular audio quality through the API, that can push you up a tier even if your volume is small.
• It is one vendor. If your product also generates images, music or video, that is a separate account, key and bill for each provider.

That last point is why many teams buy ElevenLabs models through a single API instead. You give up some account-level features (custom cloned voices tied to an ElevenLabs workspace, for example) and get one key, one balance and per-request pricing across every model you use.

ElevenLabs API price on Unicorn API, model by model

Unicorn API offers three ElevenLabs voice models. Each request is charged in credits, and the price of any request is available before you run it. On a monthly plan a credit costs $0.01. Top-up credits cost $0.015 each and never expire.

Model	How it is billed	Credits	On a plan ($0.01/credit)	With top-ups ($0.015/credit)
Elevenlabs Text to Speech Turbo V2.5	Per started 1,000 characters	6	$0.06 per 1,000 chars	$0.09 per 1,000 chars
Elevenlabs Text to Speech Multilingual V2	Per started 1,000 characters	12	$0.12 per 1,000 chars	$0.18 per 1,000 chars
Elevenlabs Text to Dialogue V3	Flat, per request	14	$0.14 per request	$0.21 per request

The rounding rule

For the two text to speech models, the charge is the per-block rate multiplied by ceil(length of text / 1000), the character count divided by 1,000 and rounded up. In practice:

• A 40-character notification costs one block: 6 credits on Turbo.
• A 1,000-character paragraph costs one block: 6 credits.
• A 1,001-character paragraph costs two blocks: 12 credits.
• A 2,400-character script costs three blocks: 18 credits on Turbo, 36 on Multilingual.

So the effective ElevenLabs API price per character is lowest when each request is close to, but not over, 1,000 characters.

What the plans buy you

Plan	Monthly price	Credits	Turbo V2.5 characters	Multilingual V2 characters	Dialogue V3 requests
Starter	$25	2,500	up to 416,000	up to 208,000	178
Creator	$50	5,000	up to 833,000	up to 416,000	357
Studio	$100	10,000	up to 1,666,000	up to 833,000	714
Pro	$200	20,000	up to 3,333,000	up to 1,666,000	1,428

The character figures assume full 1,000-character blocks. Lots of short requests will lower them. The same credits also work on every other model in the catalog, so a single balance can pay for voiceover, background music and images in the same project. Full plan details are on the pricing page.

A worked example: pricing a real voice project

Say you are building a learning app with 40 short lessons. Each lesson has a narrated script of about 6,500 characters, and you want English narration plus a Spanish version. You also want a 30-request batch of two-speaker dialogue clips for practice exercises.

Step 1: count the characters per request

A 6,500-character script sent as one request is 7 blocks. Sent as seven chunks of about 930 characters each, it is still 7 blocks, but chunking gives you smaller jobs that retry cheaply if one fails. Avoid chunking into, say, ten pieces of 650 characters: that is 10 blocks for the same text.

Step 2: pick the model per job

English narration goes to Turbo V2.5 to keep costs down. Spanish goes to Multilingual V2, which you might choose for non-English output after comparing samples in the audio playground.

Step 3: multiply

Job	Calculation	Credits
English narration, Turbo V2.5	40 lessons x 7 blocks x 6 credits	1,680
Spanish narration, Multilingual V2	40 lessons x 7 blocks x 12 credits	3,360
Dialogue clips, Dialogue V3	30 requests x 14 credits	420
Total		5,460

At $0.01 per credit that is $54.60. The Creator plan’s 5,000 credits cover most of it, and the remaining 460 credits as top-ups cost $6.90, for a total of $56.90. Alternatively, Studio at $100 covers it with room for revisions. Budget for regeneration: if you expect to re-record a fifth of the lines after review, add 20% to the voice lines of the estimate.

This is the kind of calculation an “ElevenLabs API price calculator” does, and it is worth writing into your own pipeline so every batch logs its expected cost before it runs.

How to call the ElevenLabs API and check the price first

All three ElevenLabs models run as asynchronous jobs. You submit a job with POST /v1/jobs, poll GET /v1/jobs/{id} until its status is "succeeded", then download the audio from job.outputs[0].url. Before submitting, you can call POST /v1/models/price to get the exact cost of the request; the request shape for it is in the API documentation.

First, create an API key and export it:

export UNICORN_API_KEY="your-key-here"

Python: estimate, generate and download speech

import math
import os
import time

import requests

API = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}

# Credits per started block of 1,000 characters
RATES = {
    "elevenlabs-text-to-speech-turbo-2-5": 6,
    "elevenlabs-text-to-speech-multilingual-v2": 12,
}


def estimate_credits(text, model):
    """Local estimate using the per-1,000-character rule."""
    return RATES[model] * math.ceil(len(text) / 1000)


def run_job(body, poll_seconds=2, max_wait=300):
    r = requests.post(f"{API}/v1/jobs", json=body, headers=HEADERS, timeout=30)
    r.raise_for_status()
    job = r.json()

    waited = 0
    while job["status"] != "succeeded":
        if job["status"] in ("failed", "canceled", "cancelled", "error"):
            raise RuntimeError(f"Job {job['id']} ended as {job['status']}")
        if waited >= max_wait:
            raise TimeoutError(f"Job {job['id']} still {job['status']}")
        time.sleep(poll_seconds)
        waited += poll_seconds
        r = requests.get(f"{API}/v1/jobs/{job['id']}", headers=HEADERS, timeout=30)
        r.raise_for_status()
        job = r.json()

    return job["outputs"][0]["url"]


def speak(text, model="elevenlabs-text-to-speech-turbo-2-5",
          voice="EkK5I93UQWFDigLMpZcX"):
    print(f"{len(text)} chars, about {estimate_credits(text, model)} credits")
    body = {"model": model, "input": {"text": text, "voice": voice}}
    return run_job(body)


if __name__ == "__main__":
    script = (
        "Welcome to lesson one. Today we will look at how sound travels, "
        "why it slows down in warm air, and how to hear the difference."
    )
    url = speak(script)
    audio = requests.get(url, timeout=60)
    audio.raise_for_status()
    with open("lesson-1.mp3", "wb") as f:
        f.write(audio.content)
    print("Saved lesson-1.mp3")

The local estimate is useful for logging and for refusing oversized batches, but treat the price endpoint as the source of truth when the number matters, for example before a job that spends thousands of credits. The file extension above is a convenience; check the content type of the returned URL if your player is strict about formats.

curl: a two-speaker dialogue request

Dialogue V3 takes a dialogue array, where each item has the line of text and the voice that speaks it. It costs 14 credits per request regardless of how many lines you include, which makes it cheap for short multi-speaker scenes.

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": "Did you finish the recording?", "voice": "EkK5I93UQWFDigLMpZcX"},
        {"text": "Almost. One more take and it is done.", "voice": "EkK5I93UQWFDigLMpZcX"}
      ]
    }
  }'

# Then poll until status is "succeeded" and read outputs[0].url
curl https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

Replace the second voice ID with a different voice to get two distinct speakers. If you work from an AI coding assistant, the same API is available as tools through Cursor, Claude Code and other agents via MCP, which is handy for generating test audio while you build.

Turbo, Multilingual or Dialogue: which one should you pay for?

The ElevenLabs API price per character doubles between Turbo V2.5 and Multilingual V2, so the choice is worth a few minutes of listening tests. Both accept the same input fields: text, voice, speed, style, stability, similarity_boost, language_code, timestamps, previous_text and next_text. That means you can swap the model ID and compare output without changing anything else in your code.

If you need	Start with	Why
High-volume narration, notifications, drafts	Turbo V2.5	Half the credit cost per 1,000 characters
Final audio where quality in a specific language matters	Multilingual V2	Worth comparing against Turbo on your own scripts before paying double
Short scenes with more than one speaker	Dialogue V3	Flat 14 credits per request, voices set per line

A few field notes that affect cost indirectly:

• previous_text and next_text let you pass the surrounding text when you split a long script into chunks, so each chunk is read with its context. Check in the docs how these count toward the billed length before relying on them heavily.
• stability and similarity_boost control how consistent the voice sounds. Getting them right on a sample saves regenerations, and regenerations are the hidden cost in every voice project.
• timestamps is useful if you need captions or lip-sync timing alongside the audio.

A sensible workflow is to draft everything on Turbo, review, and only regenerate the lines that need it on Multilingual. If your project also needs background music or sound beds, models like Ai Music API Sounds run on the same credit balance.

Mistakes that inflate your text to speech bill

Most surprises with any ElevenLabs API price come from how requests are shaped, not from the rate card. These are the common ones.

1. Sending many tiny requests. Every request on the speech models pays for at least one full 1,000-character block. Twenty 50-character UI prompts cost 20 blocks; joined into one request and split afterwards, they could cost one. Where you can, batch short lines.
2. Chunking at the wrong size. Splitting a long script at 1,050 characters doubles the cost of each chunk. Split on sentence boundaries with a ceiling just under 1,000.
3. Counting words instead of characters. Spaces and punctuation count. Count with len(text) on the exact string you send, after any cleanup.
4. Leaving junk in the text. HTML tags, markdown symbols, long URLs and duplicate whitespace are billed as characters and often read aloud badly. Strip them first.
5. Using the premium model for drafts. Multilingual V2 is twice the credit cost of Turbo V2.5. Iterate on the cheaper model.
6. No cache. If the same sentence (“Your order has shipped”) is generated for every user, store the audio file and reuse it. Hash the text, voice and settings to build the cache key.
7. Converting to per-minute costs from guesses. Voices speak at different speeds. Measure your own samples if you need minutes.
8. Ignoring the credit source. Plan credits cost $0.01 and top-ups $0.015. If you spend steadily each month, a plan keeps the ElevenLabs API price per character lower; if usage is spiky, non-expiring top-ups avoid paying for unused allowance.

A chunking helper that respects the 1,000-character block

import re


def chunk_text(text, limit=980):
    """Split on sentence ends so each chunk stays under one billing block."""
    sentences = re.split(r"(?<=[.!?])\s+", text.strip())
    chunks, current = [], ""
    for s in sentences:
        candidate = f"{current} {s}".strip()
        if len(candidate) <= limit:
            current = candidate
        else:
            if current:
                chunks.append(current)
            current = s  # a single sentence longer than limit stays whole
    if current:
        chunks.append(current)
    return chunks

Pass each chunk to speak() from the earlier example and concatenate the files. With a limit slightly under 1,000, a 6,500-character script lands at 7 blocks, the minimum possible.

Is the ElevenLabs API price worth it?

For most products, yes, as long as you control the shape of your requests. At $0.06 per 1,000 characters on Turbo V2.5 with plan credits, a full lesson, article or product walkthrough costs cents to narrate. The real decisions are which model each job deserves and whether you want a separate ElevenLabs subscription or a single balance that also covers your other media models.

Choose a direct ElevenLabs subscription if you depend on account-level features such as cloned voices in your own workspace. Choose per-request credits if you want exact, predictable costs per job, a price check before every run, and one key for voice, music, images and video. Either way, the ElevenLabs API price you actually pay comes down to three habits: count characters, fill each block, and draft on the cheaper model.

To try it, generate a few lines in the audio playground, then create a key and run the Python example above against your own script.