> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Text to Dialogue-streaming met tijdstempels

POST https://api.elevenlabs.io/v1/text-to-dialogue/stream/with-timestamps
Content-Type: application/json

Zet een lijst met tekst- en stem-ID-paren om in spraak (dialoog) en retourneert een stream van JSON-blobs met audio als een base64-gecodeerde string en timestamps

Reference: https://elevenlabs.io/docs/api-reference/text-to-dialogue/stream-with-timestamps

## Servers

- `https://api.elevenlabs.io` (Production, default)
- `https://api.us.elevenlabs.io` (Production US)
- `https://api.eu.residency.elevenlabs.io` (Production EU)
- `https://api.in.residency.elevenlabs.io` (Production India)
- `https://api.sg.residency.elevenlabs.io` (Production Singapore)

## Request

### Query parameters

- `output_format` (enum, optional) — Output format of the generated audio. Formatted as codec_sample_rate_bitrate. So an mp3 with 22.05kHz sample rate at 32kbs is represented as mp3_22050_32. MP3 with 192kbps bitrate requires you to be subscribed to Creator tier or above. PCM with 44.1kHz sample rate requires you to be subscribed to Pro tier or above. Note that the μ-law format (sometimes written mu-law, often approximated as u-law) is commonly used for Twilio audio inputs.
  - Allowed values: `mp3_22050_32`, `mp3_24000_48`, `mp3_44100_32`, `mp3_44100_64`, `mp3_44100_96`, `mp3_44100_128`, `mp3_44100_192`, `pcm_8000`, `pcm_16000`, `pcm_22050`, `pcm_24000`, `pcm_32000`, `pcm_44100`, `pcm_48000`, `ulaw_8000`, `alaw_8000`, `opus_48000_32`, `opus_48000_64`, `opus_48000_96`, `opus_48000_128`, `opus_48000_192`
- `enable_logging` (boolean, optional, default: true) — Wanneer enable_logging is ingesteld op false, wordt voor het request de modus zonder gegevensbewaring gebruikt. Hierdoor zijn geschiedenisfuncties, waaronder request stitching, niet beschikbaar voor dit request. De modus zonder gegevensbewaring is alleen beschikbaar voor Enterprise-klanten.

### Body (application/json)

This endpoint expects a Body_text_to_dialogue_stream_with_timestamps.

- `inputs` (list of DialogueInput, required) — Een lijst met dialooginvoer, elk met tekst en een stem-ID die wordt omgezet in spraak. Het maximale aantal unieke stem-ID's is 10. Houd voor betrouwbare generatie het totale aantal tekens in alle waarden van `inputs[].text` op maximaal 2.000 tekens per request. Langere requests kunnen bij streamingresponses voortijdig eindigen of een validatiefout retourneren.
- `model_id` (string, optional, default: eleven_v3) — ID van het model dat wordt gebruikt. Je kunt modellen opvragen met GET /v1/models. Het model moet Text to Speech ondersteunen; je kunt dit controleren met de eigenschap can_do_text_to_speech.
- `language_code` (string, optional, nullable) — Taalcode (ISO 639-1) die wordt gebruikt om een taal af te dwingen voor het model en tekstnormalisatie. Als het model de opgegeven taalcode niet ondersteunt, wordt deze genegeerd. Deze parameter wordt niet ondersteund voor multilingual_v2-modellen.
- `settings` (ToDialogueSettingsResponseModel, optional, nullable) — Instellingen voor het genereren van dialogen.
- `pronunciation_dictionary_locators` (list of PronunciationDictionaryVersionLocatorRequestModel, optional, nullable) — Een lijst met locators voor uitspraakwoordenboeken (id, version_id) die op de tekst worden toegepast. Ze worden op volgorde toegepast. Je kunt maximaal 3 locators per request opgeven
- `seed` (integer, optional, nullable) — Als dit wordt opgegeven, doet ons systeem zijn best om deterministisch te samplen, zodat herhaalde requests met dezelfde seed en parameters hetzelfde resultaat zouden moeten opleveren. Determinisme is niet gegarandeerd. Moet een geheel getal tussen 0 en 4294967295 zijn.
- `apply_text_normalization` (enum, optional, default: auto) — Deze parameter regelt tekstnormalisatie met drie modi: 'auto', 'on' en 'off'. Wanneer deze is ingesteld op 'auto', bepaalt het systeem automatisch of tekstnormalisatie wordt toegepast (bijvoorbeeld het uitschrijven van getallen). Met 'on' wordt tekstnormalisatie altijd toegepast, terwijl deze met 'off' wordt overgeslagen.
  - Allowed values: `auto`, `on`, `off`
- `use_pvc_as_ivc` (boolean, optional, default: false) — Of de IVC-versie van een professionele stem moet worden gebruikt. Dit kan de expressiviteit verbeteren en latency verminderen.
- `previous_request_ids` (list of string, optional, nullable) — A list of request_ids of dialogue generations that came before this one. Used to condition the model for continuity when splitting a large task into multiple requests. A maximum of 3 request_ids can be sent. The last request_id is the audio which is closest to the current request. Not supported by every model.
- `next_request_ids` (list of string, optional, nullable) — A list of request_ids of dialogue generations that come after this one. Useful for maintaining continuity when regenerating a clip in the middle of a sequence. A maximum of 3 request_ids can be sent. The first request_id is the audio which is closest to the current request. Not supported by every model.
- `previous_text` (string, optional, nullable) — De tekst die direct vóór deze generatie komt en wordt gebruikt om het model te conditioneren voor prosodische continuïteit. Er kunnen maximaal 100 tekens worden verzonden. Niet door elk model ondersteund.
- `future_text` (string, optional, nullable) — De tekst die direct na deze generatie komt en wordt gebruikt om het model te conditioneren voor prosodische continuïteit. Er kunnen maximaal 100 tekens worden verzonden. Niet door elk model ondersteund.
- `audio_effects` (EffectsSpec-Input, optional, nullable) — Audio-effecten die worden toegepast op de gegenereerde audio. Onbekende ID's retourneren 404, waarbij `param` de naam van het veld bevat. Galm (`environment_id` met `send_level` boven 0) en een niet-nulwaarde voor `pan` produceren stereo-audio en worden afgewezen met 400 voor uitvoerformaten `ulaw_*`, `alaw_*` en `pcm_*`. Effecten veranderen de kosten van de aanvraag niet.

## Response

### 200

Stream van transcriptsegmenten

- Streaming response of `StreamingAudioChunkWithTimestampsAndVoiceSegmentsResponseModel`.
- `audio_base64` (string, required) — Base64-gecodeerde audiogegevens
- `voice_segments` (list of VoiceSegment, required) — Stemsegmenten voor de audio
- `alignment` (CharacterAlignmentResponseModel, optional, nullable) — Tijdstempelinformatie voor elk teken in de oorspronkelijke tekst
- `normalized_alignment` (CharacterAlignmentResponseModel, optional, nullable) — Tijdstempelinformatie voor elk teken in de genormaliseerde tekst

## Errors

### 422 Unprocessable Entity Error

Validatiefout

- `detail` (list of ValidationError, optional)

## Types

### DialogueInput

- `text` (string, required) — De tekst die in spraak moet worden omgezet.
- `voice_id` (string, required) — De ID van de stem die voor de generatie wordt gebruikt.

### ToDialogueSettingsResponseModel

- `stability` (double, optional, nullable, default: 0.5) — Bepaalt hoe stabiel de stem is en de willekeur tussen generaties. Lagere waarden zorgen voor een breder emotioneel bereik van de stem. Hogere waarden kunnen leiden tot een monotone stem met beperkte emotie.
- `similarity` (double, optional, nullable, default: 0.75) — Bepaalt hoe sterk het model tijdens het genereren wordt gestuurd. Hogere waarden zorgen ervoor dat het model de stem nauwkeuriger volgt, ten koste van variatie. Niet ondersteund door elk model.

### PronunciationDictionaryVersionLocatorRequestModel

- `pronunciation_dictionary_id` (string, required) — De ID van het uitspraakwoordenboek.
- `version_id` (string, optional, nullable) — De ID van de versie van het uitspraakwoordenboek. Als deze niet wordt opgegeven, wordt de nieuwste versie gebruikt.

### EffectsSpec-Input

Audio-effecten die worden toegepast op gegenereerde spraak: een filterpreset, waargenomen afstand, een galm- omgeving, achtergrondruis en stereopanning. Laat elk veld op de standaardwaarde staan om onbewerkte audio te krijgen.

- `filter_preset_id` (string, optional, nullable) — ID van een filterpreset die de stem kleurt, zoals `phone` of `old_radio`. Geef geldige ID's weer met `GET /v1/audio-effects/catalog`.
- `distance` (double, optional, default: 0) — Hoe ver de spreker van de microfoon lijkt te staan, van 0 (dichtbij, ongewijzigd) tot 1 (ver weg). Hogere waarden dempen lage en hoge frequenties en verschuiven, wanneer een omgeving is ingesteld, de balans van de droge stem naar de galm.
- `environment_id` (string, optional, nullable) — ID van een reverbomgeving die de stem in een ruimte plaatst, zoals `small_room` of `hall`. Geef geldige ID's weer met `GET /v1/audio-effects/catalog`. Reverb wordt in stereo gerenderd en voegt een galmstaart van maximaal enkele seconden toe nadat de spraak eindigt.
- `background_noise_id` (string, optional, nullable) — ID van een achtergrondgeluidsbed dat onder de stem wordt geloopt, zoals `cafe` of `keyboard`. Geef geldige ID's weer met `GET /v1/audio-effects/catalog`.
- `send_level` (double, optional, default: 1) — Hoeveel van de stem naar de reverb gaat, van 0 (geen) tot 1 (volledig). Geldt alleen wanneer `environment_id` is ingesteld; 0 schakelt de reverb uit.
- `pan` (double, optional, default: 0) — Stereopositie van de stem, van -1 (volledig links) via 0 (midden) tot 1 (volledig rechts). Alleen de stem wordt gepand; galm en achtergrondruis blijven in het midden.
- `seed` (integer, optional, nullable, deprecated) — Heeft geen effect.

### VoiceSegment

- `voice_id` (string, required) — De stem-ID die voor dit segment wordt gebruikt
- `start_time_seconds` (double, required) — Begintijd van dit stemsegment
- `end_time_seconds` (double, required) — Eindtijd van dit stemsegment
- `character_start_index` (integer, required) — Beginindex in de characters-array
- `character_end_index` (integer, required) — Eindindex in de characters-array (exclusief)
- `dialogue_input_index` (integer, required) — Regel van de dialoog (script) waarvan dit segment deel uitmaakt.

### CharacterAlignmentResponseModel

- `characters` (list of string, required)
- `character_start_times_seconds` (list of double, required)
- `character_end_times_seconds` (list of double, required)

### ValidationError

- `loc` (list of ValidationErrorLocItems, required)
- `msg` (string, required)
- `type` (string, required)

### ValidationErrorLocItems

## Examples

**Request**

```json
{
  "inputs": [
    {
      "text": "Hello, how are you?",
      "voice_id": "bYTqZQo3Jz7LQtmGTgwi"
    },
    {
      "text": "I'm doing well, thank you!",
      "voice_id": "6lCwbsX1yVjD49QmpkTR"
    }
  ]
}
```

**Response**

```json
[
  {
    "alignment": {
      "character_end_times_seconds": [
        0.1,
        0.2
      ],
      "character_start_times_seconds": [
        0,
        0.1
      ],
      "characters": [
        "H",
        "e"
      ]
    },
    "audio_base64": "base64_encoded_audio_chunk",
    "normalized_alignment": {
      "character_end_times_seconds": [
        0.1,
        0.2
      ],
      "character_start_times_seconds": [
        0,
        0.1
      ],
      "characters": [
        "H",
        "e"
      ]
    },
    "voice_segments": [
      {
        "character_end_index": 2,
        "character_start_index": 0,
        "dialogue_input_index": 0,
        "end_time_seconds": 0.2,
        "start_time_seconds": 0,
        "voice_id": "VEDscrYI8uIMttlO2Ztu"
      }
    ]
  }
]
```

**SDK Code**

```python
import requests

url = "https://api.elevenlabs.io/v1/text-to-dialogue/stream/with-timestamps"

payload = { "inputs": [
        {
            "text": "Hello, how are you?",
            "voice_id": "bYTqZQo3Jz7LQtmGTgwi"
        },
        {
            "text": "I'm doing well, thank you!",
            "voice_id": "6lCwbsX1yVjD49QmpkTR"
        }
    ] }
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.elevenlabs.io/v1/text-to-dialogue/stream/with-timestamps';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '{"inputs":[{"text":"Hello, how are you?","voice_id":"bYTqZQo3Jz7LQtmGTgwi"},{"text":"I\'m doing well, thank you!","voice_id":"6lCwbsX1yVjD49QmpkTR"}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.elevenlabs.io/v1/text-to-dialogue/stream/with-timestamps"

	payload := strings.NewReader("{\n  \"inputs\": [\n    {\n      \"text\": \"Hello, how are you?\",\n      \"voice_id\": \"bYTqZQo3Jz7LQtmGTgwi\"\n    },\n    {\n      \"text\": \"I'm doing well, thank you!\",\n      \"voice_id\": \"6lCwbsX1yVjD49QmpkTR\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.elevenlabs.io/v1/text-to-dialogue/stream/with-timestamps")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"inputs\": [\n    {\n      \"text\": \"Hello, how are you?\",\n      \"voice_id\": \"bYTqZQo3Jz7LQtmGTgwi\"\n    },\n    {\n      \"text\": \"I'm doing well, thank you!\",\n      \"voice_id\": \"6lCwbsX1yVjD49QmpkTR\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.elevenlabs.io/v1/text-to-dialogue/stream/with-timestamps")
  .header("Content-Type", "application/json")
  .body("{\n  \"inputs\": [\n    {\n      \"text\": \"Hello, how are you?\",\n      \"voice_id\": \"bYTqZQo3Jz7LQtmGTgwi\"\n    },\n    {\n      \"text\": \"I'm doing well, thank you!\",\n      \"voice_id\": \"6lCwbsX1yVjD49QmpkTR\"\n    }\n  ]\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.elevenlabs.io/v1/text-to-dialogue/stream/with-timestamps', [
  'body' => '{
  "inputs": [
    {
      "text": "Hello, how are you?",
      "voice_id": "bYTqZQo3Jz7LQtmGTgwi"
    },
    {
      "text": "I\'m doing well, thank you!",
      "voice_id": "6lCwbsX1yVjD49QmpkTR"
    }
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/text-to-dialogue/stream/with-timestamps");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"inputs\": [\n    {\n      \"text\": \"Hello, how are you?\",\n      \"voice_id\": \"bYTqZQo3Jz7LQtmGTgwi\"\n    },\n    {\n      \"text\": \"I'm doing well, thank you!\",\n      \"voice_id\": \"6lCwbsX1yVjD49QmpkTR\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = ["inputs": [
    [
      "text": "Hello, how are you?",
      "voice_id": "bYTqZQo3Jz7LQtmGTgwi"
    ],
    [
      "text": "I'm doing well, thank you!",
      "voice_id": "6lCwbsX1yVjD49QmpkTR"
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.elevenlabs.io/v1/text-to-dialogue/stream/with-timestamps")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```