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

# Streaming da testo a voce

Questa guida illustra tre approcci: generare il parlato come file, trasmettere direttamente la risposta audio in streaming e, facoltativamente, caricare l'audio generato in un bucket AWS S3 per condividerlo tramite un URL firmato.

> **Note**
>
> Questa guida presuppone che tu abbia [configurato la chiave API e l'SDK](/docs/it/eleven-api/quickstart). Completa
> prima la guida rapida, se non l'hai ancora fatto. La sezione facoltativa sul caricamento su S3 richiede anche un account AWS
> con accesso a S3.

> **Tip**
>
> Ti chiedi perché lo streaming funziona in questo modo? [Comprendere lo streaming audio](/docs/it/eleven-api/concepts/audio-streaming) spiega in dettaglio il protocollo, il buffering e i
> compromessi in termini di latenza.

## Converti testo in parlato (file)

Per convertire testo in parlato e salvarlo come file, useremo il metodo `convert` dell'SDK ElevenLabs e lo salveremo localmente come file `.mp3`.

**`Python`**

```python Python

import os
import uuid
from dotenv import load_dotenv
from elevenlabs import VoiceSettings
from elevenlabs.client import ElevenLabs

load_dotenv()

ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
elevenlabs = ElevenLabs(
    api_key=ELEVENLABS_API_KEY,
)


def text_to_speech_file(text: str) -> str:
    # Calling the text_to_speech conversion API with detailed parameters
    response = elevenlabs.text_to_speech.convert(
        voice_id="pNInz6obpgDQGcFmaJgB", # Adam pre-made voice
        output_format="mp3_22050_32",
        text=text,
        model_id="eleven_flash_v2_5", # use the flash model for low latency
        # Optional voice settings that allow you to customize the output
        voice_settings=VoiceSettings(
            stability=0.0,
            similarity_boost=1.0,
            style=0.0,
            use_speaker_boost=True,
            speed=1.0,
        ),
    )

    # uncomment the line below to play the audio back
    # play(response)

    # Generating a unique file name for the output MP3 file
    save_file_path = f"{uuid.uuid4()}.mp3"

    # Writing the audio to a file
    with open(save_file_path, "wb") as f:
        for chunk in response:
            if chunk:
                f.write(chunk)

    print(f"{save_file_path}: A new audio file was saved successfully!")

    # Return the path of the saved audio file
    return save_file_path

```

**`TypeScript`**

```typescript TypeScript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import * as dotenv from "dotenv";
import { createWriteStream } from "fs";
import { v4 as uuid } from "uuid";

dotenv.config();

const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY;

const elevenlabs = new ElevenLabsClient({
  apiKey: ELEVENLABS_API_KEY,
});

export const createAudioFileFromText = async (text: string): Promise<string> => {
  return new Promise<string>(async (resolve, reject) => {
    try {
      const audio = await elevenlabs.textToSpeech.convert("JBFqnCBsd6RMkjVDRZzb", {
        modelId: "eleven_v4",
        text,
        outputFormat: "mp3_44100_128",
        // Optional voice settings that allow you to customize the output
        voiceSettings: {
          stability: 0,
          similarityBoost: 0,
          useSpeakerBoost: true,
          speed: 1.0,
        },
      });

      const fileName = `${uuid()}.mp3`;
      const fileStream = createWriteStream(fileName);

      audio.pipe(fileStream);
      fileStream.on("finish", () => resolve(fileName)); // Resolve with the fileName
      fileStream.on("error", reject);
    } catch (error) {
      reject(error);
    }
  });
};
```

Puoi quindi eseguire questa funzione con:

**`Python`**

```python Python
text_to_speech_file("Hello World")
```

**`TypeScript`**

```typescript TypeScript
await createAudioFileFromText("Hello World");
```

## Converti testo in parlato (streaming)

Se preferisci trasmettere l'audio direttamente in streaming senza salvarlo in un file, puoi usare la nostra funzionalità di streaming.

**`Python`**

```python Python

import os
from typing import IO
from io import BytesIO
from dotenv import load_dotenv
from elevenlabs import VoiceSettings
from elevenlabs.client import ElevenLabs

load_dotenv()

ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
elevenlabs = ElevenLabs(
    api_key=ELEVENLABS_API_KEY,
)


def text_to_speech_stream(text: str) -> IO[bytes]:
    # Perform the text-to-speech conversion
    response = elevenlabs.text_to_speech.stream(
        voice_id="pNInz6obpgDQGcFmaJgB", # Adam pre-made voice
        output_format="mp3_22050_32",
        text=text,
        model_id="eleven_multilingual_v2",
        # Optional voice settings that allow you to customize the output
        voice_settings=VoiceSettings(
            stability=0.0,
            similarity_boost=1.0,
            style=0.0,
            use_speaker_boost=True,
            speed=1.0,
        ),
    )

    # Create a BytesIO object to hold the audio data in memory
    audio_stream = BytesIO()

    # Write each chunk of audio data to the stream
    for chunk in response:
        if chunk:
            audio_stream.write(chunk)

    # Reset stream position to the beginning
    audio_stream.seek(0)

    # Return the stream for further use
    return audio_stream

```

**`TypeScript`**

```typescript TypeScript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import * as dotenv from "dotenv";

dotenv.config();

const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY;

if (!ELEVENLABS_API_KEY) {
  throw new Error("Missing ELEVENLABS_API_KEY in environment variables");
}

const elevenlabs = new ElevenLabsClient({
  apiKey: ELEVENLABS_API_KEY,
});

export const createAudioStreamFromText = async (text: string): Promise<Buffer> => {
  const audioStream = await elevenlabs.textToSpeech.stream("JBFqnCBsd6RMkjVDRZzb", {
    modelId: "eleven_v4",
    text,
    outputFormat: "mp3_44100_128",
    // Optional voice settings that allow you to customize the output
    voiceSettings: {
      stability: 0,
      similarityBoost: 1.0,
      useSpeakerBoost: true,
      speed: 1.0,
    },
  });

  const chunks: Buffer[] = [];
  for await (const chunk of audioStream) {
    chunks.push(chunk);
  }

  const content = Buffer.concat(chunks);
  return content;
};
```

Puoi quindi eseguire questa funzione con:

**`Python`**

```python Python
text_to_speech_stream("This is James")
```

**`TypeScript`**

```typescript TypeScript
await createAudioStreamFromText("This is James");
```

## Extra - Caricamento su AWS S3 e ottenimento di un link di condivisione sicuro

Dopo aver creato i dati audio come file o stream, potresti volerli condividere con i tuoi utenti. Un modo per farlo è caricarli in un bucket AWS S3 e generare un link di condivisione sicuro.

#### Creare le credenziali AWS

Per caricare i dati su S3, dovrai aggiungere l'ID della chiave di accesso AWS, la chiave di accesso segreta e il nome della regione AWS al file `.env`. Segui questi passaggi per trovare le credenziali:

1. Accedi alla console di gestione AWS: vai alla pagina iniziale di AWS e accedi con il tuo account.

![](/docs/_fern-files/elevenlabs.docs.buildwithfern.com/e9f1f1b1950962c3d67ea25a0593ca989d33c9f49b641e22eb3f861fc72735e3/assets/images/cookbooks/aws_console_login.webp)

2. Accedi alla dashboard IAM (Identity and Access Management): puoi trovare IAM in "Security, Identity, & Compliance" nel menu dei servizi. La dashboard IAM gestisce in modo sicuro l'accesso ai tuoi servizi AWS.

![](/docs/_fern-files/elevenlabs.docs.buildwithfern.com/d6fa7e75879e7537693c4edde16d0ac5face78d72b00de50743a754c0681a5e3/assets/images/cookbooks/aws_iam_dashboard.webp)

3. Crea un nuovo utente (se necessario): nella dashboard IAM, seleziona "Users" e poi "Add user". Inserisci un nome utente.

![](/docs/_fern-files/elevenlabs.docs.buildwithfern.com/47b05ffda6925e4e14147aadc296d7c86cbd3340aaa1025083f1e1464b230f51/assets/images/cookbooks/aws_iam_add_user.webp)

4. Imposta le autorizzazioni: collega le policy direttamente all'utente in base al livello di accesso che desideri concedere. Per i caricamenti su S3, puoi usare la policy AmazonS3FullAccess. Tuttavia, è consigliabile applicare il principio del privilegio minimo, ovvero concedere le autorizzazioni minime necessarie per svolgere un'attività. Potresti creare una policy personalizzata che consenta esclusivamente le azioni necessarie sul tuo bucket S3.

![](/docs/_fern-files/elevenlabs.docs.buildwithfern.com/4b88bba4f5bb1509aa087a1ab5cc8068a274b17d8887c563f050b77e8438bb94/assets/images/cookbooks/aws_iam_set_permission.webp)

5. Rivedi e crea l'utente: controlla le impostazioni e crea l'utente. Al momento della creazione, riceverai un ID della chiave di accesso e una chiave di accesso segreta. Assicurati di scaricare e salvare queste credenziali in modo sicuro; la chiave di accesso segreta non potrà più essere recuperata dopo questo passaggio.

![](/docs/_fern-files/elevenlabs.docs.buildwithfern.com/27dcdff3681522cf936ff6bfb81cf216ada1fe401c7c1dbd10e58cead8a48abc/assets/images/cookbooks/aws_access_secret_key.webp)

6. Ottieni il nome della regione AWS: ad es. us-east-1

![](/docs/_fern-files/elevenlabs.docs.buildwithfern.com/016bc11c2f040942b215366c5fc9ac8e01f6261f5ebd44a3456d4b7ba97e9ae8/assets/images/cookbooks/aws_region_name.webp)

Se non hai un bucket AWS S3, dovrai crearne uno nuovo seguendo questi passaggi:

1. Accedi alla dashboard S3: puoi trovare S3 in "Storage" nel menu dei servizi.

![](/docs/_fern-files/elevenlabs.docs.buildwithfern.com/d2455fa92ce6dfa705c3b91144fe22539fae1611848cb8e3cc2dac20e57db4e7/assets/images/cookbooks/aws_s3_dashboard.webp)

2. Crea un nuovo bucket: nella dashboard S3, fai clic sul pulsante "Create bucket".

![](/docs/_fern-files/elevenlabs.docs.buildwithfern.com/3b7d5bdb6559e8511445b41b1bbdeed3f6674791cf23021a30ccb5aa8143be28/assets/images/cookbooks/aws_s3_create_bucket.webp)

3. Inserisci un nome per il bucket e fai clic sul pulsante "Create bucket". Puoi lasciare le altre opzioni del bucket predefinite. Il bucket appena aggiunto apparirà nell'elenco.

![](/docs/_fern-files/elevenlabs.docs.buildwithfern.com/68d23f21bec1e3aa70b18f09c40c9bdace5ff0dd63edc17c6807e7ddac75758d/assets/images/cookbooks/aws_s3_enter_bucket_name.webp)![](/docs/_fern-files/elevenlabs.docs.buildwithfern.com/63f7af93d4a73fab3011853c8393c954400d9f344a5811ec90b86d6c69b2ec16/assets/images/cookbooks/aws_s3_bucket_list.webp)

#### Installare l'SDK AWS e aggiungere le credenziali

Installa `boto3` per interagire con i servizi AWS usando `pip` e `npm`.

**`Python`**

```bash Python
pip install boto3
```

**`TypeScript`**

```bash TypeScript
npm install @aws-sdk/client-s3
npm install @aws-sdk/s3-request-presigner
```

Poi aggiungi le variabili d'ambiente al file `.env` in questo modo:

```
AWS_ACCESS_KEY_ID=your_aws_access_key_id_here
AWS_SECRET_ACCESS_KEY=your_aws_secret_access_key_here
AWS_REGION_NAME=your_aws_region_name_here
AWS_S3_BUCKET_NAME=your_s3_bucket_name_here
```

#### Caricare su AWS S3 e generare l'URL firmato

Aggiungi le seguenti funzioni per caricare lo stream audio su S3 e generare un URL firmato.

**`s3_uploader.py (Python)`**

```python s3_uploader.py (Python)

import os
import boto3
import uuid

AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
AWS_REGION_NAME = os.getenv("AWS_REGION_NAME")
AWS_S3_BUCKET_NAME = os.getenv("AWS_S3_BUCKET_NAME")

session = boto3.Session(
    aws_access_key_id=AWS_ACCESS_KEY_ID,
    aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
    region_name=AWS_REGION_NAME,
)
s3 = session.client("s3")


def generate_presigned_url(s3_file_name: str) -> str:
    signed_url = s3.generate_presigned_url(
        "get_object",
        Params={"Bucket": AWS_S3_BUCKET_NAME, "Key": s3_file_name},
        ExpiresIn=3600,
    )  # URL expires in 1 hour
    return signed_url


def upload_audiostream_to_s3(audio_stream) -> str:
    s3_file_name = f"{uuid.uuid4()}.mp3"  # Generates a unique file name using UUID
    s3.upload_fileobj(audio_stream, AWS_S3_BUCKET_NAME, s3_file_name)

    return s3_file_name

```

**`s3_uploader.ts (TypeScript)`**

```typescript s3_uploader.ts (TypeScript)
import { S3Client, PutObjectCommand, GetObjectCommand } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
import * as dotenv from "dotenv";
import { v4 as uuid } from "uuid";

dotenv.config();

const { AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION_NAME, AWS_S3_BUCKET_NAME } =
  process.env;

if (!AWS_ACCESS_KEY_ID || !AWS_SECRET_ACCESS_KEY || !AWS_REGION_NAME || !AWS_S3_BUCKET_NAME) {
  throw new Error("One or more environment variables are not set. Please check your .env file.");
}

const s3 = new S3Client({
  credentials: {
    accessKeyId: AWS_ACCESS_KEY_ID,
    secretAccessKey: AWS_SECRET_ACCESS_KEY,
  },
  region: AWS_REGION_NAME,
});

export const generatePresignedUrl = async (objectKey: string) => {
  const getObjectParams = {
    Bucket: AWS_S3_BUCKET_NAME,
    Key: objectKey,
    Expires: 3600,
  };
  const command = new GetObjectCommand(getObjectParams);
  const url = await getSignedUrl(s3, command, { expiresIn: 3600 });
  return url;
};

export const uploadAudioStreamToS3 = async (audioStream: Buffer) => {
  const remotePath = `${uuid()}.mp3`;
  await s3.send(
    new PutObjectCommand({
      Bucket: AWS_S3_BUCKET_NAME,
      Key: remotePath,
      Body: audioStream,
      ContentType: "audio/mpeg",
    })
  );
  return remotePath;
};
```

Puoi quindi chiamare la funzione di caricamento con lo stream audio del testo.

**`Python`**

```python Python
s3_file_name = upload_audiostream_to_s3(audio_stream)
```

**`TypeScript`**

```typescript TypeScript
const s3path = await uploadAudioStreamToS3(stream);
```

Dopo aver caricato il file audio su S3, genera un URL firmato per condividere l'accesso al file. Questo URL avrà una durata limitata, ovvero scadrà dopo un certo periodo, rendendolo sicuro per la condivisione temporanea.

Ora puoi generare un URL da un file con:

**`Python`**

```python Python
signed_url = generate_presigned_url(s3_file_name)
print(f"Signed URL to access the file: {signed_url}")
```

**`TypeScript`**

```typescript TypeScript
const presignedUrl = await generatePresignedUrl(s3path);
console.log("Presigned URL:", presignedUrl);
```

Se vuoi usare il file più volte, dovresti salvare il path del file S3 nel database e rigenerare l'URL firmato ogni volta che ne hai bisogno, invece di salvare direttamente l'URL firmato, perché scadrà.

#### Mettere tutto insieme

Per mettere tutto insieme, puoi usare il seguente script:

**`main.py (Python)`**

```python main.py (Python)

import os

from dotenv import load_dotenv

load_dotenv()

from text_to_speech_stream import text_to_speech_stream
from s3_uploader import upload_audiostream_to_s3, generate_presigned_url


def main():
    text = "This is James"

    audio_stream = text_to_speech_stream(text)
    s3_file_name = upload_audiostream_to_s3(audio_stream)
    signed_url = generate_presigned_url(s3_file_name)

    print(f"Signed URL to access the file: {signed_url}")


if __name__ == "__main__":
    main()

```

**`index.ts (Typescript)`**

```typescript index.ts (Typescript)
import "dotenv/config";

import { generatePresignedUrl, uploadAudioStreamToS3 } from "./s3_uploader";
import { createAudioFileFromText } from "./text_to_speech_file";
import { createAudioStreamFromText } from "./text_to_speech_stream";

(async () => {
  // save the audio file to disk
  const fileName = await createAudioFileFromText(
    "Today, the sky is exceptionally clear, and the sun shines brightly."
  );

  console.log("File name:", fileName);

  // OR stream the audio, upload to S3, and get a presigned URL
  const stream = await createAudioStreamFromText(
    "Today, the sky is exceptionally clear, and the sun shines brightly."
  );

  const s3path = await uploadAudioStreamToS3(stream);

  const presignedUrl = await generatePresignedUrl(s3path);

  console.log("Presigned URL:", presignedUrl);
})();
```

## Conclusione

Ora sai come convertire il testo in parlato e generare un URL firmato per condividere il file audio. Questa funzionalità offre molte opportunità per creare e condividere contenuti in modo dinamico.

Ecco alcuni esempi di ciò che potresti creare.

1. **Podcast educativi**: crea contenuti educativi personalizzati a cui gli studenti possono accedere su richiesta. Gli insegnanti possono convertire le proprie lezioni in formato audio, caricarle su S3 e condividere i link con gli studenti per un'esperienza di apprendimento più coinvolgente al di fuori dell'ambiente scolastico tradizionale.

2. **Funzionalità di accessibilità per siti web**: migliora l'accessibilità del sito web offrendo i contenuti testuali in formato audio. Questo può rendere le informazioni sui siti web più accessibili alle persone con disabilità visive o a chi preferisce l'apprendimento uditivo.

3. **Messaggi automatici per l'assistenza clienti**: crea messaggi audio automatici e personalizzati per l'assistenza clienti, come FAQ o aggiornamenti sugli ordini. Questo può offrire un'esperienza cliente più coinvolgente rispetto alle tradizionali email di testo.

4. **Audiolibri e narrazione**: converti libri interi o racconti brevi in formato audio, offrendo al pubblico un nuovo modo di apprezzare la letteratura. Autori ed editori possono diversificare la propria offerta di contenuti e raggiungere chi preferisce ascoltare anziché leggere.

5. **Strumenti per l'apprendimento delle lingue**: sviluppa strumenti per l'apprendimento delle lingue che offrano agli studenti lezioni ed esercizi audio. Questo consente di esercitare in modo mirato la pronuncia e le capacità di ascolto.

## Passaggi successivi

#### [Streaming WebSocket](/docs/it/eleven-api/guides/how-to/websockets/realtime-tts)

Usa WebSocket per trasmettere testo in parlato in tempo reale mentre viene generato da un LLM.

#### [Comprendere la latenza](/docs/it/eleven-api/concepts/latency)

Scopri cosa contribuisce alla latenza e come ridurre al minimo il tempo al primo audio.