# ElevenLabs Eleven v4 API: access, pricing and code

> Get the official Eleven v4 text-to-speech API from ElevenLabs on Runway Dev: model ID, price per character, voices, inputs and code in curl, Node and Python.

Author: Runway · Published: 2026-11-04 · Updated: 2026-11-04 · Source: https://dev.runway.com/learn/eleven-v4-api

## Summary

Runway Dev gives you the official Eleven v4 API from ElevenLabs, its most expressive text-to-speech model.\
\
Eleven v4 reads a script aloud in a preset voice and performs the audio tags written into it, such as [whispers] and [laughs].\
\
The same Runway Dev key also reaches Runway's own models and other labs' video, image and audio models.\
\
This page covers access, pricing, inputs and code, and how your coding agent can build the integration for you.

Eleven v4 fits anywhere a product needs a voice: narration for generated video, voiceovers for ads, characters in games and lines read in your users' languages.

## What is Eleven v4?

Eleven v4 is ElevenLabs' text-to-speech model, [introduced on September 28, 2026](https://elevenlabs.io/blog/eleven-v4) as its most emotive voice model. It turns a written script into speech in one of 49 preset voices on Runway Dev, in more than 90 languages. Delivery is directed in the script itself: an audio tag in square brackets tells the voice to whisper, pause, laugh or change its tone, and the model performs the tag instead of reading it out. Runway Dev serves the official Eleven v4 model on `POST /v1/text_to_speech`, and each request returns an MP3 file.

![Maya whispers a warning, pauses, then excitedly points out the midnight bells and laughs](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/eleven-v4-api-hero-night-market-27b62581.mp4 'One Eleven v4 request in the Maya voice: the audio tags set the whisper, the pause, the excitement and the laugh. Turn the sound on to hear it.')

```text
[whispers] Keep your voice down. The night market only opens once the lanterns go out. [pause] [excited] There, do you hear the bells? [laughs] Every stall owner in Port Sallow rings one at midnight.
```

Eleven v4 is built for speech that carries feeling: audiobook narration, character dialogue in games, voiceovers for ads and one product's lines read in many languages.

## What are the ways to use Eleven v4 on Runway Dev?

Eleven v4 is available on Runway Dev in three ways.

| Way in                                                                                                                 | Best for                                                                                                    | What you need                                                                                                          |
| ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| [Playground](https://dev.runway.com/endpoints/text_to_speech?modelId=eleven_v4)                                        | Trying a script and a voice, then copying the request as code                                               | A Runway Dev account                                                                                                   |
| [API](https://docs.dev.runwayml.com/guides/using-the-api/) and [SDKs](https://docs.dev.runwayml.com/api-details/sdks/) | Calling Eleven v4 from your own code                                                                        | An API key and credits                                                                                                 |
| Coding agent                                                                                                           | Having Claude Code, Codex, Cursor or Grok Bot build the API integration into your product, tool or pipeline | The [Runway Dev plugin](https://docs.dev.runwayml.com/guides/plugin/) (MCP and skills), plus an API key for live calls |

Eleven v4 is also available in [Model Router](https://dev.runway.com/model-routers), a saved config you send with the request instead of a model ID. You set what to optimize for (cost, quality or latency), a maximum cost per generation and the models allowed, and the router picks one for each request sent to `POST /v1/generate/audio`.

## How do you get access to the Eleven v4 API?

You get access to the Eleven v4 API with a Runway Dev account and an API key, with no separate ElevenLabs account:

1. Create an account at https://dev.runway.com.
2. Create an API key in your project's dashboard.
3. Add credits to your project's balance.
4. Store the key in your environment as `RUNWAYML_API_SECRET`.
5. Send a request to `POST /v1/text_to_speech` with `"model": "eleven_v4"`, a script, a voice and the `X-Runway-Version` header. The code below is ready to run.

## How much does the Eleven v4 API cost?

The Eleven v4 API costs 5 credits ($0.05) per 1,000 characters of script on Runway Dev, with a minimum of 1 credit ($0.01) per request.

| Credits | USD |
| --- | --- |
| 5 credits per 1,000 characters | $0.05 per 1,000 characters |

- Minimum 1 credit ($0.01) per generation.
- Each request rounds up to a whole credit.

Prices current as of November 5, 2026. 1 credit = $0.01.

Runway Dev bills Eleven v4 by the characters in `promptText`, counting each Unicode character once, so an emoji or an accented letter is one character. Audio tags are part of the script and count like any other text. The context you send in `previousText` and `nextText` adds no charge. A request that fails is refunded, except a `SAFETY.INPUT.*` failure. The [pricing guide](https://docs.dev.runwayml.com/guides/pricing/) lists every model's rate, and [dev.runway.com/pricing](https://dev.runway.com/pricing) shows the plans.

## What inputs does Eleven v4 accept?

Eleven v4 takes a script in `promptText` and a voice in `voice`, and every other field adjusts how that voice performs the script.

### `POST /v1/text_to_speech`

| Field | Accepts |
| --- | --- |
| `model` (required) | `eleven_v4` |
| `promptText` (required) | Text |
| `voice` (required) | See the API reference |
| `stability` | Number from 0 to 1 |
| `similarityBoost` | Number from 0 to 1 |
| `style` | Number from 0 to 1 |
| `speed` | Number from 0.7 to 1.2 |
| `useSpeakerBoost` | `true` or `false` |
| `languageCode` | Text, 2 to 16 characters |
| `previousText` | Text |
| `nextText` | Text |
| `seed` | Whole number from 0 to 4,294,967,295 |

Each table shows what a field accepts on its own. Rules that combine fields are checked when the task is submitted, and the [API reference](https://docs.dev.runwayml.com/api/) has them in full.

`promptText` holds up to 2,500 characters, counted per Unicode character. Write the delivery into it with audio tags in square brackets, such as `[whispers]`, `[excited]`, `[laughs]` or `[pause]`. A tag has to sit next to words: a script made only of tags is rejected, and so are SSML `<break>` tags, which `[pause]` replaces.

`voice` names one of the preset voices as `{"type": "runway-preset", "presetId": "<name>"}`, and the [API reference](https://docs.dev.runwayml.com/api/) lists every name. The same script sounds like a different person in each voice:

![Bernard](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/eleven-v4-api-voice-bernard-aba5be9c.mp4 'The same ad read by three preset voices. Pick a voice to hear it.') ![Ella](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/eleven-v4-api-voice-ella-dd0a996e.mp4) ![James](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/eleven-v4-api-voice-james-2300db68.mp4)

```text
Fresh bread every morning, baked two streets from your door. Order by nine and it's on your table by ten.
```

`languageCode` sets the language the voice pronounces, as a code such as `en` or `pt`, and a regional code such as `pt-BR` is read as its language. Write the script in that language, since Eleven v4 speaks the text it gets without translating it. One preset voice keeps its identity from one language to the next:

![English](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/eleven-v4-api-lang-en-a2fdbab3.mp4 'The Maya voice in four languages, each request with its own languageCode. Pick a language to hear it.') ![French](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/eleven-v4-api-lang-fr-96aa6cd2.mp4) ![Spanish](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/eleven-v4-api-lang-es-cd82a2bd.mp4) ![Japanese](https://d3phaj0sisr2ct.cloudfront.net/devportal/learn/eleven-v4-api-lang-ja-c14adf19.mp4)

```text
en: Welcome back. Your order is packed and will arrive tomorrow before noon.
fr: Bon retour. Votre commande est prête et arrivera demain avant midi.
es: Bienvenido de nuevo. Tu pedido está listo y llegará mañana antes del mediodía.
ja: おかえりなさい。ご注文の品は梱包済みで、明日の正午までにお届けします。
```

`previousText` and `nextText` carry the text around a request, so a long script split across several requests keeps one continuous delivery instead of restarting its tone at every cut. Each of `previousText` and `nextText` holds up to 2,500 characters, like the script. `stability`, `similarityBoost`, `style` and `speed` tune the performance: lower stability gives a wider emotional range and higher stability a steadier read. `seed` makes repeat runs sound alike, without a guarantee.

## How do you use the Eleven v4 API?

You use the Eleven v4 API with one request to `POST /v1/text_to_speech`, then wait for the task to finish. This example request, in curl, Node and Python, makes the night market clip above:

**curl**

```bash
curl -X POST https://api.dev.runwayml.com/v1/text_to_speech \
  -H "Authorization: Bearer $RUNWAYML_API_SECRET" \
  -H "X-Runway-Version: 2024-11-06" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "eleven_v4",
    "promptText": "[whispers] Keep your voice down. The night market only opens once the lanterns go out. [pause] [excited] There, do you hear the bells? [laughs] Every stall owner in Port Sallow rings one at midnight.",
    "voice": {
      "type": "runway-preset",
      "presetId": "Maya"
    }
  }'

# The response carries the task id. Poll the task until it finishes:
curl https://api.dev.runwayml.com/v1/tasks/$TASK_ID \
  -H "Authorization: Bearer $RUNWAYML_API_SECRET" \
  -H "X-Runway-Version: 2024-11-06"
```

**Node.js**

```javascript
import RunwayML, { TaskFailedError } from '@runwayml/sdk';

// Reads your API key from RUNWAYML_API_SECRET.
const client = new RunwayML();

try {
  const task = await client.textToSpeech
    .create({
      model: 'eleven_v4',
      promptText: '[whispers] Keep your voice down. The night market only opens once the lanterns go out. [pause] [excited] There, do you hear the bells? [laughs] Every stall owner in Port Sallow rings one at midnight.',
      voice: {
        type: 'runway-preset',
        presetId: 'Maya',
      },
    })
    .waitForTaskOutput();
  console.log(task.output);
} catch (error) {
  if (error instanceof TaskFailedError) {
    console.error(error.taskDetails);
  } else {
    throw error;
  }
}
```

**Python**

```python
from runwayml import RunwayML, TaskFailedError

# Reads your API key from RUNWAYML_API_SECRET.
client = RunwayML()

try:
    task = client.text_to_speech.create(
        model="eleven_v4",
        prompt_text="[whispers] Keep your voice down. The night market only opens once the lanterns go out. [pause] [excited] There, do you hear the bells? [laughs] Every stall owner in Port Sallow rings one at midnight.",
        voice={
            "type": "runway-preset",
            "preset_id": "Maya",
        },
    ).wait_for_task_output()
    print(task.output)
except TaskFailedError as error:
    print(error.task_details)
```

The create request returns a task ID. Poll `GET /v1/tasks/{id}` with backoff until the status is `SUCCEEDED` or `FAILED`. The Node and Python SDKs do this for you with `waitForTaskOutput()` and `wait_for_task_output()`, and raise `TaskFailedError` when the task fails. A `THROTTLED` status means the task is waiting in a queue, not rejected. The output is a URL to an MP3 file, and output URLs are temporary, so download the audio to your own storage when the task succeeds.

To send speech through rules rather than a fixed model, pass a Model Router `configId` to `POST /v1/generate/audio` in place of the model name.

## Why does an Eleven v4 API request fail?

An Eleven v4 API request fails for one of a few reasons, each with its own fix.

- **Validation error on `promptText`, `previousText` or `nextText`.** A text is longer than 2,500 characters, or the script holds only audio tags or uses an SSML `<break>` tag. Split a long script into several requests joined with `previousText` and `nextText`, add words next to the tags, and write `[pause]` instead of `<break>`.
- **Validation error on `voice`.** The `presetId` isn't one of the preset voice names, or `type` isn't `runway-preset`. Names are case-sensitive and listed in the [API reference](https://docs.dev.runwayml.com/api/).
- **A setting has no effect.** A request copied from another speech model can carry fields Eleven v4 doesn't take. They're dropped without an error, so the audio comes back without that setting. Send only the fields in the inputs table above.
- **`SAFETY.INPUT.TEXT`.** Content moderation rejected the script, or the `previousText` or `nextText` around it. The credits aren't refunded, so change the text rather than retrying it.
- **`THIRD_PARTY.UNAVAILABLE`.** ElevenLabs didn't return audio, for example during a short outage. The task is refunded: wait, then retry.
- **Expired output URL.** Output URLs are temporary. Download the MP3 when the task succeeds instead of storing the URL.

The [task failures guide](https://docs.dev.runwayml.com/errors/task-failures/) lists every failure code and what is refunded.

## What does Runway Dev add when you call Eleven v4?

Runway Dev serves Eleven v4 next to [Runway's own models and other labs' models](https://dev.runway.com/models/catalog), behind one API key and one credit balance: you build with a single key and pay a single bill, instead of an account, a key and an invoice per lab. A product that makes a video, voices it and localizes it calls every model with the same key, the same SDKs and the same task flow, ElevenLabs' dubbing and voice isolation models included.

A coding agent can do the Eleven v4 integration for you on Runway Dev, end to end. The [Runway Dev MCP](https://docs.dev.runwayml.com/guides/mcp/) gives the agent your live account: the models with their current prices and input limits, your credit balance and the record behind any task. It writes the integration against what the API accepts today and debugs failures on its own. The [Runway Dev skills](https://docs.dev.runwayml.com/guides/plugin/) show it how Runway integrates with the official SDKs and builds with models, Model Routers, Recipes and Workflows, so a voiceover step lands in your pipeline the way Runway would build it.

[Model Router](https://dev.runway.com/model-routers) carries Runway's judgment about which speech model fits a request, within the rules you set: what to optimize for, a cost cap per generation and the models allowed.

## FAQ

**Is the Eleven v4 API on Runway Dev the official model?**

Yes. Runway Dev serves the official Eleven v4 model from ElevenLabs, the model ElevenLabs introduced on September 28, 2026, under the model ID `eleven_v4`.

**How many credits does an Eleven v4 request use?**

An Eleven v4 request uses 5 credits ($0.05) per 1,000 characters of script, rounded up to a whole credit, with a minimum of 1 credit ($0.01). Prices current as of November 5, 2026, where 1 credit = $0.01.

**Can I use Eleven v4 without writing code?**

Yes. You can try scripts and voices in the [Eleven v4 playground](https://dev.runway.com/endpoints/text_to_speech?modelId=eleven_v4) and copy the request it shows, or ask a coding agent with the [Runway Dev plugin](https://docs.dev.runwayml.com/guides/plugin/) to build the integration for you.

**Does the same Runway Dev API key work for Eleven v4 and other models?**

Yes. One Runway Dev API key calls Eleven v4 and every other model in the catalog with the same SDKs, task flow and credit balance. Switching models is a change to the `model` field, or to a Model Router's rules.

**What is the Eleven v4 model ID on Runway Dev?**

The Eleven v4 model ID on Runway Dev is `eleven_v4`, sent to `POST /v1/text_to_speech`.

**Which voices can Eleven v4 use on Runway Dev?**

Eleven v4 on Runway Dev speaks in 49 preset voices, named in `voice.presetId`, such as Maya, Bernard, Ella and James. The [API reference](https://docs.dev.runwayml.com/api/) lists every name.

**Which languages does Eleven v4 speak?**

Eleven v4 speaks more than 90 languages, among them English, Spanish, French, German, Japanese, Hindi, Arabic and Portuguese. Write the script in the language you want and set `languageCode` to it.

**How long can an Eleven v4 script be?**

An Eleven v4 script holds up to 2,500 characters per request. For a longer script, send it in parts and pass the neighboring text in `previousText` and `nextText`, so the parts sound like one continuous read.

**What audio tags does Eleven v4 follow?**

Eleven v4 follows audio tags in square brackets for emotion (`[excited]`, `[curious]`, `[sarcastic]`), delivery (`[whispers]`, `[shouting]`), reactions (`[laughs]`, `[sighs]`), timing (`[pause]`), accents (`[strong French accent]`) and sound effects (`[applause]`). A tag needs words next to it.

**Can I use Eleven v4 audio commercially?**

[Commercial use of Runway Dev outputs](https://dev.runway.com/learn/commercial-use) explains what Runway's terms allow for the outputs you generate, and the [Terms of Use](https://runwayml.com/terms-of-use) have the full text.

**Can I switch from Eleven v4 to another speech model without changing my code?**

Yes. Send a Model Router `configId` to `POST /v1/generate/audio` instead of a model name, and change the router's rules when you want a different model.

**How do you turn text into speech through an API?**

A text-to-speech API takes a script and a voice and returns an audio file. On Runway Dev, send the script in `promptText` and a preset voice in `voice` to `POST /v1/text_to_speech` with `"model": "eleven_v4"`, then download the MP3 when the task succeeds.
