> 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. # Streama dialog i realtid Text to Dialogue WebSocket (`/v1/text-to-dialogue/stream-input`) håller en enda anslutning öppen medan du skickar dialograder och tar emot base64-kodade ljudsegment. Den är endast avsedd för dialogmodellerna **Eleven v3** och **Eleven v4** (`model_id` måste börja med `eleven_v3` eller `eleven_v4`). > **Note** > > Den här guiden handlar om WebSocket för **Text to Dialogue**. För **Flash**, **Multilingual v2** eller andra > TTS-modeller som inte är v3 använder du [Realtime TTS WebSocket](/docs/sv/eleven-api/guides/how-to/websockets/realtime-tts). För en jämförelse sida vid sida av > båda protokollen, se [Text to Speech- och Text to Dialogue- WebSockets](/docs/sv/eleven-api/guides/how-to/websockets/tts-vs-ttd-websockets). ## Krav * Ett ElevenLabs-konto med en API-nyckel ([autentisering](/docs/sv/api-reference/authentication)). * API-nyckeln måste ha behörighet för `Text to Speech`. * Python eller Node.js installerat på din dator. ## Konfiguration **`Python`** ```python Python pip install python-dotenv websockets ``` **`TypeScript`** ```typescript TypeScript npm install dotenv ws npm install @types/dotenv @types/ws --save-dev ``` Skapa en `.env`-fil: **`.env`** ```bash .env ELEVENLABS_API_KEY=your_elevenlabs_api_key_here ``` Välj ett **röst-ID** från [Voice Library](https://elevenlabs.io/voice-library). Exemplen nedan använder `eleven_v4_turbo`, som tillåter **en** registrerad röst per anslutning. ## Öppna WebSocket-anslutningen Anslut till `wss://api.elevenlabs.io/v1/text-to-dialogue/stream-input` med frågeparametrar som `model_id` och `output_format`. Du kan skicka API-nyckeln i headern `xi-api-key` eller i det första JSON-meddelandet (visas här i brödtexten för ett enhetligt mönster mellan språk). **`text-to-dialogue-websocket.py`** ```python text-to-dialogue-websocket.py import asyncio import base64 import json import os from dotenv import load_dotenv import websockets load_dotenv() ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY") VOICE_ID = "21m00Tcm4TlvDq8ikWAM" MODEL_ID = "eleven_v4_turbo" URI = ( "wss://api.elevenlabs.io/v1/text-to-dialogue/stream-input" f"?model_id={MODEL_ID}&output_format=mp3_44100_128" ) ``` **`text-to-dialogue-websocket.ts`** ```typescript text-to-dialogue-websocket.ts import * as dotenv from "dotenv"; import * as fs from "node:fs"; import WebSocket from "ws"; dotenv.config(); const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY; const voiceId = "21m00Tcm4TlvDq8ikWAM"; const modelId = "eleven_v4_turbo"; const uri = `wss://api.elevenlabs.io/v1/text-to-dialogue/stream-input?model_id=${modelId}&output_format=mp3_44100_128`; const websocket = new WebSocket(uri); const outputDir = "./output"; try { fs.accessSync(outputDir, fs.constants.R_OK | fs.constants.W_OK); } catch { fs.mkdirSync(outputDir); } const writeStream = fs.createWriteStream(`${outputDir}/dialogue-ws.mp3`, { flags: "a" }); ``` ## Registrera röster och streama text Skicka ett **första meddelande** som innehåller `voices` (obligatoriskt) och `xi_api_key` om du inte har angett headern `xi-api-key`. Skicka sedan en eller flera ramar med `inputs`: varje objekt har `text`, `voice_id` och valfritt `new_turn`. Servern buffrar text tills den har tillräckligt med kontext (cirka **40 tecken** och **8 ord**) och skickar sedan `audio`-segment. Svarsfälten använder **snake\_case** (till exempel `is_final`). **`text-to-dialogue-websocket.py`** ```python text-to-dialogue-websocket.py async def stream_dialogue(): async with websockets.connect(URI) as websocket: await websocket.send( json.dumps( { "voices": [VOICE_ID], "xi_api_key": ELEVENLABS_API_KEY, } ) ) line = ( "This is a longer line of dialogue used to exceed the minimum buffer so the model " "starts generating streamed audio for the registered voice. " ) await websocket.send( json.dumps( { "inputs": [ {"text": line, "voice_id": VOICE_ID, "new_turn": False}, ], } ) ) await websocket.send(json.dumps({"close_socket": True})) os.makedirs("output", exist_ok=True) out_path = "output/dialogue-ws.mp3" with open(out_path, "wb") as audio_file: while True: raw = await websocket.recv() msg = json.loads(raw) if msg.get("error"): raise RuntimeError(msg) if msg.get("audio"): audio_file.write(base64.b64decode(msg["audio"])) if msg.get("is_final"): break print(f"Wrote {out_path}") asyncio.run(stream_dialogue()) ``` **`text-to-dialogue-websocket.ts`** ```typescript text-to-dialogue-websocket.ts websocket.on("open", () => { websocket.send( JSON.stringify({ voices: [voiceId], xi_api_key: ELEVENLABS_API_KEY, }) ); const line = "This is a longer line of dialogue used to exceed the minimum buffer so the model starts generating streamed audio for the registered voice. "; websocket.send( JSON.stringify({ inputs: [{ text: line, voice_id: voiceId, new_turn: false }], }) ); websocket.send(JSON.stringify({ close_socket: true })); }); websocket.on("message", (data) => { const msg = JSON.parse(data.toString()); if (msg.error) { console.error(msg); return; } if (msg.audio) { writeToLocal(msg.audio, writeStream); } }); function writeToLocal(base64str: string, stream: fs.WriteStream) { stream.write(Buffer.from(base64str, "base64")); } websocket.on("close", () => { writeStream.end(); }); ``` `close_socket` tömmer all buffrad text, skickar återstående ljud och sedan en sista ram med `is_final: true` innan anslutningen stängs. Om du vill **hålla anslutningen öppen** mellan rader utelämnar du `close_socket` tills sessionen avslutas. Använd `flush` för att framtvinga ljud för kortare buffertar utan att stänga anslutningen. ## Kör skriptet **`Python`** ```python Python python text-to-dialogue-websocket.py ``` **`TypeScript`** ```typescript TypeScript npx tsx text-to-dialogue-websocket.ts ``` Du bör få en MP3-fil under `output/` (med filnamnet från exemplet ovan). ## Anmärkningar om beteende ### Buffring Till skillnad från TTS WebSocket `chunk_length_schedule` använder dialogstreaming ett **fast tröskelvärde på servern** (antal tecken och ord) före det första partiella ljudet. Om du skickar korta rader och hör fördröjningar kan du samla lite mer text per `inputs`-ram eller skicka `flush: true` för att framtvinga generering utan att stänga socketen. ### Turordningar och röster Ange `new_turn: true` när en talare avslutar en tur så att prosodin återställs korrekt. Att ändra `voice_id` mellan `inputs`-poster startar också en ny tur. Med `eleven_v4_turbo` registrerar du **exakt en** röst i `voices`; `eleven_v4` har stöd för upp till **10** registrerade röster. ### Inaktivitet Om servern inte tar emot något **klientmeddelande på 20 sekunder** avslutas anslutningen. Skicka `{"keep_alive": true}` för att återställa timern utan att syntetisera ljud. ### Samtidighet Varje öppen anslutning håller en dialogs-session så länge den är öppen och hämtas från en dedikerad pool som är separat från din plans vanliga samtidighetsgräns. Ljud som genereras via anslutningen räknas inte mot standardgränsen för samtidighet. Se [samtidighet för Text to Dialogue](/docs/sv/overview/models#text-to-dialogue-concurrency). ### Justering Lägg till `sync_alignment=true` i frågesträngen för att ta emot `alignment`-objekt (tidsmatriser i snake\_case) i segment när de är tillgängliga. Se [API-referensen](/docs/sv/api-reference/text-to-dialogue/ttd-websocket). ## Nästa steg #### [TTS- och TTD-WebSockets](/docs/sv/eleven-api/guides/how-to/websockets/tts-vs-ttd-websockets) Välj rätt WebSocket och jämför meddelandestrukturer. #### [Text to Dialogue WebSocket (API)](/docs/sv/api-reference/text-to-dialogue/ttd-websocket) Frågeparametrar, meddelandescheman och exempel. #### [Streama dialog (HTTP)](/docs/sv/api-reference/text-to-dialogue/stream) När hela begärans text är tillgänglig utan en WebSocket. #### [Realtime TTS WebSocket](/docs/sv/eleven-api/guides/how-to/websockets/realtime-tts) Streaming med en röst, utan v3, via WebSockets.