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

# Synthèse vocale en streaming

Ce guide présente trois approches : générer la parole sous forme de fichier, diffuser directement la réponse audio en streaming et, si vous le souhaitez, importer l’audio généré dans un bucket AWS S3 pour le partager via une URL signée.

> **Note**
>
> Ce guide suppose que vous avez [configuré votre clé API et votre SDK](/docs/fr/eleven-api/quickstart). Suivez d’abord
> le guide de démarrage rapide si ce n’est pas déjà fait. La section facultative consacrée à l’importation vers S3 nécessite également un compte AWS
> avec accès à S3.

> **Tip**
>
> Vous vous demandez pourquoi le streaming fonctionne ainsi ? [Comprendre le streaming audio](/docs/fr/eleven-api/concepts/audio-streaming) explique en détail le protocole, la mise en mémoire tampon et les
> compromis en matière de latence.

## Convertir du texte en parole (fichier)

Pour convertir du texte en parole et l’enregistrer dans un fichier, nous utiliserons la méthode `convert` du SDK ElevenLabs, puis l’enregistrerons localement au format `.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 { writeFile } from "node:fs/promises";
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> => {
  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`;
  await writeFile(fileName, Buffer.from(await new Response(audio).arrayBuffer()));
  return fileName;
};
```

Vous pouvez ensuite exécuter cette fonction avec :

**`Python`**

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

**`TypeScript`**

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

## Convertir du texte en parole (streaming)

Si vous préférez diffuser l’audio directement en streaming sans l’enregistrer dans un fichier, vous pouvez utiliser notre fonctionnalité de 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;
};
```

Vous pouvez ensuite exécuter cette fonction avec :

**`Python`**

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

**`TypeScript`**

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

## Bonus : importation vers AWS S3 et obtention d’un lien de partage sécurisé

Une fois vos données audio créées sous forme de fichier ou de flux, vous souhaiterez peut-être les partager avec vos utilisateurs. Vous pouvez notamment les importer dans un bucket AWS S3 et générer un lien de partage sécurisé.

#### Créer vos identifiants AWS

Pour importer les données vers S3, vous devez ajouter votre ID de clé d’accès AWS, votre clé d’accès secrète et le nom de votre région AWS à votre fichier `.env`. Suivez ces étapes pour obtenir vos identifiants :

1. Connectez-vous à votre console de gestion AWS : accédez à la page d’accueil AWS et connectez-vous à votre compte.

![](/docs/_fern-img/e9f1f1b1950962c3d67ea25a0593ca989d33c9f49b641e22eb3f861fc72735e3.webp)

2. Accédez au Dashboard IAM (Identity and Access Management) : vous trouverez IAM sous « Security, Identity, & Compliance » dans le menu des services. Le Dashboard IAM gère de manière sécurisée l’accès à vos services AWS.

![](/docs/_fern-img/d6fa7e75879e7537693c4edde16d0ac5face78d72b00de50743a754c0681a5e3.webp)

3. Créez un nouvel utilisateur, si nécessaire : dans le Dashboard IAM, sélectionnez « Users », puis « Add user ». Saisissez un nom d’utilisateur.

![](/docs/_fern-img/47b05ffda6925e4e14147aadc296d7c86cbd3340aaa1025083f1e1464b230f51.webp)

4. Définissez les autorisations : associez directement des politiques à l’utilisateur selon le niveau d’accès que vous souhaitez accorder. Pour les importations vers S3, vous pouvez utiliser la politique AmazonS3FullAccess. Il est toutefois recommandé d’appliquer le principe du moindre privilège, c’est-à-dire d’accorder uniquement les autorisations minimales nécessaires à l’exécution d’une tâche. Vous pouvez créer une politique personnalisée qui autorise uniquement les actions requises sur votre bucket S3.

![](/docs/_fern-img/4b88bba4f5bb1509aa087a1ab5cc8068a274b17d8887c563f050b77e8438bb94.webp)

5. Vérifiez et créez l’utilisateur : vérifiez vos paramètres et créez l’utilisateur. Une fois créé, vous recevrez un ID de clé d’accès et une clé d’accès secrète. Téléchargez et enregistrez ces identifiants de manière sécurisée : la clé d’accès secrète ne pourra plus être récupérée après cette étape.

![](/docs/_fern-img/27dcdff3681522cf936ff6bfb81cf216ada1fe401c7c1dbd10e58cead8a48abc.webp)

6. Obtenez le nom de la région AWS : par exemple, us-east-1

![](/docs/_fern-img/016bc11c2f040942b215366c5fc9ac8e01f6261f5ebd44a3456d4b7ba97e9ae8.webp)

Si vous n’avez pas de bucket AWS S3, vous devez en créer un en suivant ces étapes :

1. Accédez au Dashboard S3 : vous trouverez S3 sous « Storage » dans le menu des services.

![](/docs/_fern-img/d2455fa92ce6dfa705c3b91144fe22539fae1611848cb8e3cc2dac20e57db4e7.webp)

2. Créez un bucket : dans le Dashboard S3, cliquez sur le bouton « Create bucket ».

![](/docs/_fern-img/3b7d5bdb6559e8511445b41b1bbdeed3f6674791cf23021a30ccb5aa8143be28.webp)

3. Saisissez un nom de bucket et cliquez sur le bouton « Create bucket ». Vous pouvez conserver les valeurs par défaut pour les autres options du bucket. Le nouveau bucket apparaîtra dans la liste.

![](/docs/_fern-img/68d23f21bec1e3aa70b18f09c40c9bdace5ff0dd63edc17c6807e7ddac75758d.webp)![](/docs/_fern-img/63f7af93d4a73fab3011853c8393c954400d9f344a5811ec90b86d6c69b2ec16.webp)

#### Installer le SDK AWS et ajouter les identifiants

Installez `boto3` pour interagir avec les services AWS à l’aide de `pip` et de `npm`.

**`Python`**

```bash Python
pip install boto3
```

**`TypeScript`**

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

Ajoutez ensuite les variables d’environnement au fichier `.env` comme suit :

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

#### Importer vers AWS S3 et générer l’URL signée

Ajoutez les fonctions suivantes pour importer le flux audio vers S3 et générer une URL signée.

**`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;
};
```

Vous pouvez ensuite appeler la fonction d’importation avec le flux audio généré à partir du texte.

**`Python`**

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

**`TypeScript`**

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

Après avoir importé le fichier audio vers S3, générez une URL signée pour partager l’accès au fichier. Cette URL est limitée dans le temps : elle expire après une certaine période, ce qui la rend sécurisée pour un partage temporaire.

Vous pouvez maintenant générer une URL à partir d’un fichier avec :

**`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);
```

Si vous souhaitez utiliser le fichier plusieurs fois, enregistrez son chemin S3 dans votre base de données, puis régénérez l’URL signée à chaque utilisation, plutôt que d’enregistrer directement l’URL signée, car elle expirera.

#### Tout réunir

Pour tout réunir, vous pouvez utiliser le script suivant :

**`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);
})();
```

## Conclusion

Vous savez désormais convertir du texte en parole et générer une URL signée pour partager le fichier audio. Cette fonctionnalité offre de nombreuses possibilités pour créer et partager du contenu de manière dynamique.

Voici quelques exemples de ce que vous pourriez concevoir avec cette fonctionnalité.

1. **Podcasts éducatifs** : créez du contenu éducatif personnalisé auquel les étudiants peuvent accéder à la demande. Les enseignants peuvent convertir leurs cours au format audio, les importer vers S3 et partager les liens avec leurs étudiants pour proposer une expérience d’apprentissage plus engageante en dehors du cadre scolaire traditionnel.

2. **Fonctionnalités d’accessibilité pour les sites web** : améliorez l’accessibilité d’un site web en proposant le contenu textuel au format audio. Les informations présentes sur les sites web deviennent ainsi plus accessibles aux personnes malvoyantes ou à celles qui préfèrent l’apprentissage auditif.

3. **Messages automatisés de support client** : produisez des messages audio automatisés et personnalisés pour le support client, tels que des FAQ ou des mises à jour de commande. Ils offrent une expérience client plus engageante que les emails textuels traditionnels.

4. **Livres audio et narration** : convertissez des livres entiers ou de courtes histoires au format audio, afin d’offrir au public une nouvelle façon de profiter de la littérature. Les auteurs et éditeurs peuvent diversifier leur offre de contenu et toucher les publics qui préfèrent écouter plutôt que lire.

5. **Outils d’apprentissage des langues** : développez des outils d’apprentissage des langues qui proposent aux apprenants des leçons et exercices audio. Ils permettent de s’entraîner de manière ciblée à la prononciation et à la compréhension orale.

## Étapes suivantes

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

Utilisez les WebSockets pour diffuser du texte en parole en temps réel à mesure qu’il est généré par un LLM.

#### [Comprendre la latence](/docs/fr/eleven-api/concepts/latency)

Découvrez les facteurs qui contribuent à la latence et comment réduire le délai avant le premier audio.