WebSocket Text to Speech e Text to Dialogue

ElevenLabs offre due famiglie di prodotti WebSocket per lo streaming del parlato sintetizzato. Ogni famiglia include una variante a stream singolo e una variante multi-contesto che multiplexa diversi stream indipendenti su un’unica connessione. Risolvono problemi diversi, accettano formati di messaggio diversi e sono pensati per modelli diversi.

Quale WebSocket devo usare?

Usa il WebSocket Text to Speech (TTS) quando trasmetti in streaming testo semplice per una voce per connessione (la voce è fissa nell’URL) e vuoi usare modelli non v3 come Flash o Multilingual v2, SSML opzionale, pianificazioni dei chunk o la variante multi-contesto per gestire le interruzioni in stile agente.

Usa il WebSocket Text to Dialogue (TTD) quando ti serve il comportamento di dialogo di Eleven v3: resa espressiva, **voice_id per chunk **, confini di turno (new_turn) e lo stesso buffering orientato al dialogo usato dal server per v3.

Usa il WebSocket TTD multi-contesto quando ti serve lo stesso comportamento di dialogo di Eleven v3 e diversi stream simultanei o intercalati su un’unica connessione, ad esempio per un agente conversazionale che deve interrompere e riavviare il dialogo senza aprire ogni volta un nuovo socket.

Per il dialogo batch o in streaming HTTP (richiesta completa in un’unica chiamata), usa invece Crea dialogo o Trasmetti dialogo in streaming anziché un WebSocket.

Confronto

	WebSocket Text to Speech	WebSocket Text to Dialogue
Riferimento API	Input stream TTS	WebSocket TTD
URL	`wss://api.elevenlabs.io/v1/text-to-speech/{voice_id}/stream-input`	`wss://api.elevenlabs.io/v1/text-to-dialogue/stream-input`
Selezione della voce	Un `voice_id` nel path; tutto il testo trasmesso in streaming usa quella voce	Il primo messaggio registra una o più `voices` per ID; ogni voce `inputs[]` indica un `voice_id`
Modelli	Flash, Multilingual v2 e altri modelli TTS supportati. No `eleven_v3` o `eleven_v4` su questo endpoint.	`model_id` deve iniziare con `eleven_v3` o `eleven_v4` (ad esempio `eleven_v4` o `eleven_v4_turbo`)
Primo messaggio del client	Inizializza con uno spazio e `voice_settings` / `generation_config` opzionali (consulta la guida TTS in tempo reale)	Deve includere `voices` (e le credenziali, se non sono già state inviate tramite header o query)
Testo successivo	Invia una stringa `text` (in genere con spazio finale); `flush`, `try_trigger_generation` e altri parametri sono opzionali	Invia `inputs`: oggetti `{ text, voice_id, new_turn? }`; `flush`, `close_socket`, `keep_alive` opzionali
Buffering / pianificazione	Pianificazione della lunghezza dei chunk e relativi controlli del WebSocket TTS	Il server mantiene il buffer finché non è presente abbastanza testo (circa 40 caratteri e 8 parole) prima di emettere l’audio, a meno che tu non usi `flush`
Più speaker su un socket	Usa il WebSocket multi-contesto per più contesti TTS paralleli, non per la semantica del dialogo con più speaker	Fino a 10 voci registrate per `eleven_v4`; `eleven_v4_turbo` consente una sola voce registrata. Per stream di dialogo paralleli, usa il WebSocket TTD multi-contesto
Inattività	`inactivity_timeout` configurabile (query del WebSocket TTS)	20 s fissi tra i messaggi del client, a meno che tu non invii `keep_alive`
Concorrenza	Solo il tempo di generazione attivo conta ai fini del limite di concorrenza del tuo piano; un socket aperto inattivo non conta	Ogni connessione aperta occupa una sessione di dialogo da un pool separato per tutta la sua durata; la generazione sulla connessione non consuma la concorrenza standard
Allineamento	`sync_alignment` opzionale (denominazione dei campi TTS nel riferimento API)	`sync_alignment` opzionale; il JSON usa campi in snake_case nelle risposte (ad esempio `is_final`, `char_start_times_ms`)

Quando il WebSocket TTS è la scelta migliore

Hai già integrato Flash o Multilingual v2 per latenza o copertura linguistica.
Vuoi una voce narrante per connessione e un semplice protocollo con testo per frame.
Ti serve l’orchestrazione multi-contesto per interruzioni e enunciati paralleli (guida multi-contesto).

Consulta Generare audio in tempo reale per una guida completa al WebSocket TTS.

Quando il WebSocket TTD è la scelta migliore

Usi il dialogo di Eleven v4 (tag espressivi, ritmo conversazionale, battute con più speaker).
Trasmetti in streaming dialoghi scritti o generati da LLM in cui la voce parlante può cambiare a ogni battuta senza aprire una nuova connessione.
Vuoi input incrementali in formato WebSocket con generazione di dialogo solo v4 sul server.

Per una guida pratica, usa Text to Dialogue in tempo reale. I dettagli del protocollo sono nel riferimento API.

WebSocket multi-contesto

Entrambi i prodotti offrono una variante multi-contesto che multiplexa diversi stream indipendenti su un’unica connessione WebSocket. Ogni contesto è identificato da un context_id scelto dal client, gestisce il proprio buffer di testo ed emette chunk audio contrassegnati con quel context_id. I contesti TTS condividono il voice_id dall’URL della connessione, mentre i contesti TTD registrano le proprie voci e impostazioni. Usa questo formato quando ti serve una generazione simultanea o intercalata con gestione delle interruzioni, ad esempio per un agente vocale che deve annullare un enunciato in corso e avviarne uno nuovo senza chiudere la connessione.

	WebSocket TTS multi-contesto	WebSocket TTD multi-contesto
Riferimento API	Input multi-stream TTS	Input multi-stream TTD
URL	`wss://api.elevenlabs.io/v1/text-to-speech/{voice_id}/multi-stream-input`	`wss://api.elevenlabs.io/v1/text-to-dialogue/multi-stream-input`
Modelli	Flash, Multilingual v2 e altri modelli TTS supportati. No `eleven_v3` o `eleven_v4`.	`model_id` deve iniziare con `eleven_v3` (ad esempio `eleven_v3` o `eleven_v3_conversational`). `eleven_v4` non è supportato su questo endpoint.
Contesti	Più contesti TTS paralleli su una connessione	Fino a 5 contesti simultanei per connessione
Voci per contesto	Un `voice_id` fisso nell’URL per ogni contesto	Registrate nel primo messaggio per un `context_id`: 1 per `eleven_v3_conversational`, fino a 10 per `eleven_v3`
Instradamento per messaggio	Ogni messaggio include `context_id`	Ogni messaggio include `context_id` (fa eccezione un messaggio che contiene solo `close_socket`)
Messaggi di controllo	`flush`, `close_context`, `close_socket`, `keep_alive` per contesto	`flush`, `close_context`, `close_socket`, `keep_alive` per contesto
Inattività	`inactivity_timeout` configurabile per contesto	20 s fissi per contesto, a meno che tu non invii `keep_alive` per quel contesto
Autenticazione	A livello di connessione (header, query o primo messaggio)	A livello di connessione (header, query o primo messaggio), non per contesto

Quando il WebSocket TTD multi-contesto è la scelta migliore

Ti serve il comportamento di dialogo di Eleven v3 (resa espressiva, voice_id per chunk, confini di turno) e stream simultanei o intercalati su un’unica connessione.
Stai creando un agente conversazionale che deve interrompere e riavviare il dialogo senza aprire ogni volta un nuovo socket.
Vuoi distribuire diverse sessioni di dialogo v3 indipendenti, ad esempio scene o speaker paralleli, su un’unica connessione autenticata.

Per il WebSocket TTD a stream singolo, consulta Text to Dialogue in tempo reale. Per il WebSocket TTS multi-contesto, consulta la guida al WebSocket multi-contesto. I dettagli del protocollo per l’endpoint TTD multi-contesto sono nel riferimento API.

Guide correlate

Text to Dialogue in tempo reale

Connettiti, registra le voci, trasmetti inputs in streaming e salva l’audio dal WebSocket TTD.

WebSocket TTS in tempo reale

Connessione e messaggistica passo dopo passo per il WebSocket TTS standard.

WebSocket multi-contesto

Più contesti TTS su un’unica connessione per i workflow degli agenti.

WebSocket TTD multi-contesto (API)

Parametri di query, schemi dei messaggi ed esempi per stream di dialogo v3 paralleli.

Guida rapida a Text to Dialogue

Esempi di richieste HTTP per dialoghi con più voci.

Funzionalità Text to Dialogue

Panoramica della generazione di dialoghi orientata al prodotto.