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

# Strumieniuj dialog

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

Zamienia listę par tekstu i identyfikatora głosu na mowę (dialog) oraz zwraca strumień audio.

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

## 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) — Gdy enable_logging ma wartość false, dla żądania zostanie użyty tryb zerowej retencji. Funkcje historii, w tym łączenie żądań, będą niedostępne dla tego żądania. Z trybu zerowej retencji mogą korzystać tylko klienci Enterprise.

### Body (application/json)

This endpoint expects a Body_Text_to_dialogue__multi_voice__streaming_v1_text_to_dialogue_stream_post.

- `inputs` (list of DialogueInput, required) — Lista danych wejściowych dialogu, z których każda zawiera tekst i identyfikator głosu do zamiany na mowę. Maksymalna liczba unikalnych identyfikatorów głosów to 10. Aby generowanie było niezawodne, łączna liczba znaków we wszystkich wartościach `inputs[].text` nie powinna przekraczać 2000 na żądanie. Dłuższe żądania mogą zakończyć się przedwcześnie w odpowiedziach strumieniowych lub zwrócić błąd walidacji.
- `model_id` (string, optional, default: eleven_v3) — Identyfikator modelu, który zostanie użyty. Możesz sprawdzić dostępne modele za pomocą GET /v1/models. Model musi obsługiwać zamianę tekstu na mowę, co możesz sprawdzić we właściwości can_do_text_to_speech.
- `language_code` (string, optional, nullable) — Kod języka (ISO 639-1) używany do wymuszenia języka modelu i normalizacji tekstu. Jeśli model nie obsługuje podanego kodu języka, zostanie on zignorowany. Ten parametr nie jest obsługiwany przez modele multilingual_v2.
- `settings` (ToDialogueSettingsResponseModel, optional, nullable) — Ustawienia sterujące generowaniem dialogu.
- `previous_text` (string, optional, nullable) — Tekst bezpośrednio poprzedzający tę generację, używany do zapewnienia ciągłości prozodycznej. Można wysłać maksymalnie 100 znaków. Nie jest obsługiwane przez każdy model.
- `future_text` (string, optional, nullable) — Tekst bezpośrednio po tej generacji, używany do zapewnienia modelowi ciągłości prozodycznej. Można wysłać maksymalnie 100 znaków. Nie jest obsługiwany przez każdy model.
- `pronunciation_dictionary_locators` (list of PronunciationDictionaryVersionLocatorRequestModel, optional, nullable) — Lista lokalizatorów słowników wymowy (id, version_id), które zostaną zastosowane do tekstu. Będą stosowane po kolei. W jednym żądaniu możesz podać do 3 lokalizatorów
- `seed` (integer, optional, nullable) — Jeśli podano, nasz system dołoży starań, by generowanie było deterministyczne, więc powtarzane żądania z tym samym seedem i parametrami powinny zwracać ten sam wynik. Determinizm nie jest gwarantowany. Musi być liczbą całkowitą od 0 do 4294967295.
- `apply_text_normalization` (enum, optional, default: auto) — Ten parametr kontroluje normalizację tekstu w trzech trybach: „auto”, „on” i „off”. W trybie „auto” system automatycznie zdecyduje, czy zastosować normalizację tekstu, np. zapisywanie liczb słownie. W trybie „on” normalizacja tekstu będzie zawsze stosowana, a w trybie „off” zostanie pominięta.
  - Allowed values: `auto`, `on`, `off`
- `previous_request_ids` (list of string, optional, nullable) — Lista request_ids generacji dialogu poprzedzających tę generację. Służy do zapewnienia ciągłości modelu przy dzieleniu dużego zadania na kilka żądań. Możesz wysłać maksymalnie 3 request_ids. Ostatni request_id oznacza audio najbliższe bieżącemu żądaniu. Nie jest obsługiwane przez każdy model.
- `next_request_ids` (list of string, optional, nullable) — Lista request_ids generacji dialogu następujących po tej generacji. Przydatna do zachowania ciągłości podczas ponownego generowania klipu w środku sekwencji. Możesz wysłać maksymalnie 3 request_ids. Pierwszy request_id oznacza audio najbliższe bieżącemu żądaniu. Nie jest obsługiwane przez każdy model.
- `audio_effects` (EffectsSpec-Input, optional, nullable) — Efekty audio zastosowane do wygenerowanego audio. Nieznane identyfikatory zwracają błąd 404, a `param` wskazuje nazwę pola. Pogłos (`environment_id` z `send_level` powyżej 0) i niezerowe `pan` tworzą dźwięk stereo oraz są odrzucane z błędem 400 dla formatów wyjściowych `ulaw_*`, `alaw_*` i `pcm_*`. Efekty nie zmieniają kosztu żądania.
- `use_pvc_as_ivc` (boolean, optional, nullable, deprecated) — Czy używać wersji IVC profesjonalnego głosu. Może to poprawić ekspresję i zmniejszyć opóźnienie.

## Response

### 200

Dane audio przesyłane strumieniowo

- Streaming response of `string`.

## Errors

### 422 Unprocessable Entity Error

Błąd walidacji

- `detail` (list of ValidationError, optional)

## Types

### DialogueInput

- `text` (string, required) — Tekst do przekształcenia w mowę.
- `voice_id` (string, required) — ID głosu, który ma być użyty do generowania.

### ToDialogueSettingsResponseModel

- `stability` (double, optional, nullable, default: 0.5) — Określa stabilność głosu i losowość między kolejnymi generacjami. Niższe wartości zapewniają głosowi szerszy zakres emocji. Wyższe wartości mogą dać monotonny głos z ograniczonymi emocjami.
- `similarity` (double, optional, nullable, default: 0.75) — Określa, jak silnie model jest prowadzony podczas generowania. Wyższe wartości sprawiają, że model ściślej trzyma się głosu, kosztem różnorodności. Nie jest obsługiwane przez wszystkie modele.
- `clone_strength` (double, optional, nullable) — Określa, jak dobrze głos pasuje do próbek profesjonalnego klonu głosu — od 0 (nisko) do 1 (wysoko). W większości przypadków zalecamy wartość 0. Zwiększ ją tylko, jeśli występują problemy z domyślnymi ustawieniami. Dotyczy tylko profesjonalnych klonów głosu dostrojonych do wybranego modelu v4.

### PronunciationDictionaryVersionLocatorRequestModel

- `pronunciation_dictionary_id` (string, required) — ID słownika wymowy.
- `version_id` (string, optional, nullable) — ID wersji słownika wymowy. Jeśli nie podano, użyta zostanie najnowsza wersja.

### EffectsSpec-Input

Efekty audio stosowane do wygenerowanej mowy: preset filtra, odczuwana odległość, środowisko pogłosu, tło szumów i panoramowanie stereo. Pozostaw domyślne wartości wszystkich pól, aby uzyskać nieprzetworzone audio.

- `filter_preset_id` (string, optional, nullable) — ID presetu filtra zmieniającego brzmienie głosu, np. `phone` lub `old_radio`. Listę prawidłowych ID uzyskasz przez `GET /v1/audio-effects/catalog`.
- `distance` (double, optional, default: 0) — Jak daleko od mikrofonu brzmi mówca: od 0 (blisko, bez zmian) do 1 (daleko). Wyższe wartości tłumią niskie i wysokie częstotliwości oraz, gdy ustawiono środowisko, przesuwają balans z głosu bez efektów w stronę pogłosu.
- `environment_id` (string, optional, nullable) — ID środowiska pogłosu umieszczającego głos w przestrzeni, np. `small_room` lub `hall`. Listę prawidłowych ID uzyskasz przez `GET /v1/audio-effects/catalog`. Pogłos jest renderowany stereo i dodaje wybrzmienie trwające do kilku sekund po zakończeniu mowy.
- `background_noise_id` (string, optional, nullable) — ID tła szumów zapętlonego pod głosem, np. `cafe` lub `keyboard`. Listę prawidłowych ID uzyskasz przez `GET /v1/audio-effects/catalog`.
- `send_level` (double, optional, default: 1) — Ile głosu trafia do pogłosu, od 0 (brak) do 1 (całość). Dotyczy tylko sytuacji, gdy ustawiono `environment_id`; 0 wyłącza pogłos.
- `pan` (double, optional, default: 0) — Pozycja głosu w stereo: od -1 (skrajnie po lewej), przez 0 (środek), do 1 (skrajnie po prawej). Przesuwany jest tylko głos; pogłos i szum tła pozostają na środku.

### ValidationError

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

### ValidationErrorLocItems

- string
- integer

## Examples

**Request**

```json
{
  "inputs": [
    {
      "text": "[giggling] Knock knock",
      "voice_id": "JBFqnCBsd6RMkjVDRZzb"
    },
    {
      "text": "[curious] Who is there?",
      "voice_id": "Aw4FAjKCGjjNkVhN1Xmq"
    }
  ]
}
```

**SDK Code**

```python
import requests

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

payload = { "inputs": [
        {
            "text": "[giggling] Knock knock",
            "voice_id": "JBFqnCBsd6RMkjVDRZzb"
        },
        {
            "text": "[curious] Who is there?",
            "voice_id": "Aw4FAjKCGjjNkVhN1Xmq"
        }
    ] }
headers = {
    "xi-api-key": "xi-api-key",
    "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';
const options = {
  method: 'POST',
  headers: {'xi-api-key': 'xi-api-key', 'Content-Type': 'application/json'},
  body: '{"inputs":[{"text":"[giggling] Knock knock","voice_id":"JBFqnCBsd6RMkjVDRZzb"},{"text":"[curious] Who is there?","voice_id":"Aw4FAjKCGjjNkVhN1Xmq"}]}'
};

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"

	payload := strings.NewReader("{\n  \"inputs\": [\n    {\n      \"text\": \"[giggling] Knock knock\",\n      \"voice_id\": \"JBFqnCBsd6RMkjVDRZzb\"\n    },\n    {\n      \"text\": \"[curious] Who is there?\",\n      \"voice_id\": \"Aw4FAjKCGjjNkVhN1Xmq\"\n    }\n  ]\n}")

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

	req.Header.Add("xi-api-key", "xi-api-key")
	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")

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

request = Net::HTTP::Post.new(url)
request["xi-api-key"] = 'xi-api-key'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"inputs\": [\n    {\n      \"text\": \"[giggling] Knock knock\",\n      \"voice_id\": \"JBFqnCBsd6RMkjVDRZzb\"\n    },\n    {\n      \"text\": \"[curious] Who is there?\",\n      \"voice_id\": \"Aw4FAjKCGjjNkVhN1Xmq\"\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")
  .header("xi-api-key", "xi-api-key")
  .header("Content-Type", "application/json")
  .body("{\n  \"inputs\": [\n    {\n      \"text\": \"[giggling] Knock knock\",\n      \"voice_id\": \"JBFqnCBsd6RMkjVDRZzb\"\n    },\n    {\n      \"text\": \"[curious] Who is there?\",\n      \"voice_id\": \"Aw4FAjKCGjjNkVhN1Xmq\"\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', [
  'body' => '{
  "inputs": [
    {
      "text": "[giggling] Knock knock",
      "voice_id": "JBFqnCBsd6RMkjVDRZzb"
    },
    {
      "text": "[curious] Who is there?",
      "voice_id": "Aw4FAjKCGjjNkVhN1Xmq"
    }
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'xi-api-key' => 'xi-api-key',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/text-to-dialogue/stream");
var request = new RestRequest(Method.POST);
request.AddHeader("xi-api-key", "xi-api-key");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"inputs\": [\n    {\n      \"text\": \"[giggling] Knock knock\",\n      \"voice_id\": \"JBFqnCBsd6RMkjVDRZzb\"\n    },\n    {\n      \"text\": \"[curious] Who is there?\",\n      \"voice_id\": \"Aw4FAjKCGjjNkVhN1Xmq\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "xi-api-key": "xi-api-key",
  "Content-Type": "application/json"
]
let parameters = ["inputs": [
    [
      "text": "[giggling] Knock knock",
      "voice_id": "JBFqnCBsd6RMkjVDRZzb"
    ],
    [
      "text": "[curious] Who is there?",
      "voice_id": "Aw4FAjKCGjjNkVhN1Xmq"
    ]
  ]] 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")! 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()
```