> 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.

# Texto para diálogo com streaming e timestamps

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

Converte uma lista de pares de texto e ID de voz em fala (diálogo) e retorna um fluxo de blobs JSON contendo áudio como uma string codificada em base64 e 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) — Quando enable_logging for definido como false, o modo de retenção zero será usado para a solicitação. Isso significa que os recursos de histórico não estarão disponíveis para esta solicitação, incluindo a união de solicitações. O modo de retenção zero só pode ser usado por clientes empresariais.

### Body (application/json)

This endpoint expects a Body_text_to_dialogue_stream_with_timestamps.

- `inputs` (list of DialogueInput, required) — Uma lista de entradas de diálogo, cada uma contendo texto e um ID de voz que será convertido em fala. O número máximo de IDs de voz únicos é 10. Para uma geração confiável, mantenha o total de caracteres em todos os valores de `inputs[].text` em até 2.000 caracteres por solicitação. Solicitações mais longas podem ser encerradas antecipadamente em respostas de streaming ou retornar um erro de validação.
- `model_id` (string, optional, default: eleven_v3) — Identificador do modelo que será usado. Você pode consultá-lo usando GET /v1/models. O modelo precisa oferecer suporte a texto para voz, o que pode ser verificado pela propriedade can_do_text_to_speech.
- `language_code` (string, optional, nullable) — Código de idioma (ISO 639-1) usado para aplicar um idioma ao modelo e à normalização de texto. Se o modelo não oferecer suporte ao código de idioma fornecido, ele será ignorado. Este parâmetro não é compatível com modelos multilingual_v2.
- `settings` (ToDialogueSettingsResponseModel, optional, nullable) — Configurações que controlam a geração de diálogos.
- `pronunciation_dictionary_locators` (list of PronunciationDictionaryVersionLocatorRequestModel, optional, nullable) — Uma lista de localizadores de dicionários de pronúncia (id, version_id) a serem aplicados ao texto. Eles serão aplicados em ordem. Você pode ter até 3 localizadores por solicitação
- `seed` (integer, optional, nullable) — Se especificado, nosso sistema fará o possível para realizar a amostragem de forma determinística, de modo que solicitações repetidas com a mesma semente e os mesmos parâmetros retornem o mesmo resultado. O determinismo não é garantido. Deve ser um número inteiro entre 0 e 4294967295.
- `apply_text_normalization` (enum, optional, default: auto) — Este parâmetro controla a normalização de texto com três modos: 'auto', 'on' e 'off'. Quando definido como 'auto', o sistema decidirá automaticamente se aplicará a normalização de texto, por exemplo, escrever números por extenso. Com 'on', a normalização de texto será sempre aplicada; com 'off', ela será ignorada.
  - Allowed values: `auto`, `on`, `off`
- `use_pvc_as_ivc` (boolean, optional, default: false) — Se deve usar a versão IVC de uma voz profissional. Isso pode melhorar a expressividade e reduzir a latência.
- `previous_request_ids` (list of string, optional, nullable) — Uma lista de request_ids de gerações de diálogo anteriores a esta. Usada para condicionar o modelo para manter a continuidade ao dividir uma tarefa grande em várias solicitações. É possível enviar no máximo 3 request_ids. O último request_id corresponde ao áudio mais próximo da solicitação atual. Não é compatível com todos os modelos.
- `next_request_ids` (list of string, optional, nullable) — Uma lista de request_ids de gerações de diálogo posteriores a esta. Útil para manter a continuidade ao regenerar um clipe no meio de uma sequência. É possível enviar no máximo 3 request_ids. O primeiro request_id corresponde ao áudio mais próximo da solicitação atual. Não é compatível com todos os modelos.
- `previous_text` (string, optional, nullable) — O texto imediatamente anterior a esta geração, usado para condicionar o modelo quanto à continuidade prosódica. É possível enviar no máximo 100 caracteres. Não é compatível com todos os modelos.
- `future_text` (string, optional, nullable) — O texto que vem imediatamente após esta geração, usado para condicionar o modelo à continuidade prosódica. É possível enviar no máximo 100 caracteres. Nem todos os modelos oferecem suporte.
- `audio_effects` (EffectsSpec-Input, optional, nullable) — Efeitos de áudio aplicados ao áudio gerado. IDs desconhecidos retornam 404 com `param` indicando o campo. Reverberação (`environment_id` com `send_level` acima de 0) e um `pan` diferente de zero produzem áudio estéreo e são rejeitados com 400 para os formatos de saída `ulaw_*`, `alaw_*` e `pcm_*`. Os efeitos não alteram o custo da solicitação.

## Response

### 200

Fluxo de trechos de transcrição

- Streaming response of `StreamingAudioChunkWithTimestampsAndVoiceSegmentsResponseModel`.
- `audio_base64` (string, required) — Dados de áudio codificados em Base64
- `voice_segments` (list of VoiceSegment, required) — Segmentos de voz do áudio
- `alignment` (CharacterAlignmentResponseModel, optional, nullable) — Informações de timestamp para cada caractere do texto original
- `normalized_alignment` (CharacterAlignmentResponseModel, optional, nullable) — Informações de timestamp para cada caractere do texto normalizado

## Errors

### 422 Unprocessable Entity Error

Erro de validação

- `detail` (list of ValidationError, optional)

## Types

### DialogueInput

- `text` (string, required) — O texto a ser convertido em fala.
- `voice_id` (string, required) — O ID da voz a ser usada na geração.

### ToDialogueSettingsResponseModel

- `stability` (double, optional, nullable, default: 0.5) — Determina a estabilidade da voz e a aleatoriedade entre cada geração. Valores menores introduzem uma gama emocional mais ampla na voz. Valores maiores podem resultar em uma voz monótona e com emoção limitada.
- `similarity` (double, optional, nullable, default: 0.75) — Determina o quanto o modelo é orientado durante a geração. Valores maiores fazem o modelo se manter mais fiel à voz, com menos variação. Não é compatível com todos os modelos.

### PronunciationDictionaryVersionLocatorRequestModel

- `pronunciation_dictionary_id` (string, required) — O ID do dicionário de pronúncia.
- `version_id` (string, optional, nullable) — O ID da versão do dicionário de pronúncia. Se não for informado, a versão mais recente será usada.

### EffectsSpec-Input

Efeitos de áudio aplicados à fala gerada: uma predefinição de filtro, distância percebida, um ambiente de reverberação, uma camada de ruído de fundo e panoramização estéreo. Deixe todos os campos com os valores padrão para obter áudio sem processamento.

- `filter_preset_id` (string, optional, nullable) — ID de uma predefinição de filtro que modifica o timbre da voz, como `phone` ou `old_radio`. Liste IDs válidos com `GET /v1/audio-effects/catalog`.
- `distance` (double, optional, default: 0) — A distância em que o falante parece estar do microfone, de 0 (próximo, sem alteração) a 1 (distante). Valores mais altos atenuam as frequências graves e agudas e, quando um ambiente é definido, deslocam o equilíbrio da voz seca para a reverberação.
- `environment_id` (string, optional, nullable) — ID de um ambiente de reverberação que insere a voz em um espaço, como `small_room` ou `hall`. Liste IDs válidos com `GET /v1/audio-effects/catalog`. A reverberação é renderizada em estéreo e adiciona uma cauda de até vários segundos após o fim da fala.
- `background_noise_id` (string, optional, nullable) — ID de uma camada de ruído de fundo reproduzida em loop sob a voz, como `cafe` ou `keyboard`. Liste IDs válidos com `GET /v1/audio-effects/catalog`.
- `send_level` (double, optional, default: 1) — Quanto da voz é enviado para a reverberação, de 0 (nada) a 1 (total). Só se aplica quando `environment_id` está definido; 0 desativa a reverberação.
- `pan` (double, optional, default: 0) — Posição estéreo da voz, de -1 (totalmente à esquerda), passando por 0 (centro), até 1 (totalmente à direita). Apenas a voz é panoramizada; a reverberação e o ruído de fundo permanecem centralizados.

### VoiceSegment

- `voice_id` (string, required) — O ID da voz usado neste segmento
- `start_time_seconds` (double, required) — Horário de início deste segmento de voz
- `end_time_seconds` (double, required) — Tempo de término deste segmento de voz
- `character_start_index` (integer, required) — Índice inicial na matriz de caracteres
- `character_end_index` (integer, required) — Índice final na matriz de caracteres (exclusivo)
- `dialogue_input_index` (integer, required) — Linha do diálogo (roteiro) da qual este segmento faz parte.

### 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()
```