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

# Text to Speech streamen

Dieser Leitfaden behandelt drei Ansätze: Sprache als Datei generieren, die Audioantwort direkt streamen und generiertes Audio optional in einen AWS-S3-Bucket hochladen, um es über eine signierte URL zu teilen.

> **Note**
>
> Dieser Leitfaden setzt voraus, dass Sie [Ihren API-Schlüssel und Ihr SDK eingerichtet haben](/docs/de/eleven-api/quickstart). Schließen Sie
> zuerst die Schnellstartanleitung ab, falls Sie dies noch nicht getan haben. Der optionale Abschnitt zum S3-Upload erfordert außerdem ein AWS-Konto
> mit Zugriff auf S3.

> **Tip**
>
> Möchten Sie wissen, warum Streaming so funktioniert? [Audio-Streaming verstehen](/docs/de/eleven-api/concepts/audio-streaming) erklärt das Protokoll, die Pufferung und
> Latenz-Kompromisse im Detail.

## Text in Sprache umwandeln (Datei)

Um Text in Sprache umzuwandeln und als Datei zu speichern, verwenden wir die Methode `convert` des ElevenLabs SDK und speichern sie dann lokal als `.mp3`-Datei.

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

Anschließend können Sie diese Funktion wie folgt ausführen:

**`Python`**

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

**`TypeScript`**

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

## Text in Sprache umwandeln (Streaming)

Wenn Sie das Audio lieber direkt streamen möchten, ohne es in einer Datei zu speichern, können Sie unsere Streaming-Funktion nutzen.

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

Anschließend können Sie diese Funktion wie folgt ausführen:

**`Python`**

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

**`TypeScript`**

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

## Bonus – In AWS S3 hochladen und einen sicheren Freigabelink erhalten

Sobald Ihre Audiodaten als Datei oder Stream erstellt wurden, möchten Sie sie möglicherweise mit Ihren Nutzern teilen. Dazu können Sie sie in einen AWS-S3-Bucket hochladen und einen sicheren Freigabelink generieren.

#### AWS-Anmeldedaten erstellen

Um die Daten in S3 hochzuladen, müssen Sie die ID Ihres AWS-Zugriffsschlüssels, den geheimen Zugriffsschlüssel und den AWS-Regionsnamen zu Ihrer `.env`-Datei hinzufügen. So finden Sie die Anmeldedaten:

1. Melden Sie sich bei Ihrer AWS Management Console an: Öffnen Sie die AWS-Startseite und melden Sie sich mit Ihrem Konto an.

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

2. Öffnen Sie das IAM-Dashboard (Identity and Access Management): Sie finden IAM im Servicemenü unter „Security, Identity, & Compliance“. Das IAM-Dashboard verwaltet den Zugriff auf Ihre AWS-Services sicher.

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

3. Erstellen Sie einen neuen Benutzer, falls nötig: Wählen Sie im IAM-Dashboard „Users“ und dann „Add user“. Geben Sie einen Benutzernamen ein.

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

4. Legen Sie die Berechtigungen fest: Weisen Sie dem Benutzer Richtlinien direkt entsprechend der Zugriffsebene zu, die Sie gewähren möchten. Für S3-Uploads können Sie die Richtlinie AmazonS3FullAccess verwenden. Es empfiehlt sich jedoch, das Prinzip der geringsten Berechtigung anzuwenden und nur die minimal notwendigen Berechtigungen für eine Aufgabe zu vergeben. Sie können eine benutzerdefinierte Richtlinie erstellen, die nur die erforderlichen Aktionen für Ihren S3-Bucket erlaubt.

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

5. Prüfen und erstellen Sie den Benutzer: Prüfen Sie Ihre Einstellungen und erstellen Sie den Benutzer. Nach der Erstellung erhalten Sie eine Zugriffsschlüssel-ID und einen geheimen Zugriffsschlüssel. Laden Sie diese Anmeldedaten herunter und speichern Sie sie sicher. Der geheime Zugriffsschlüssel kann nach diesem Schritt nicht erneut abgerufen werden.

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

6. AWS-Regionsnamen abrufen: z. B. us-east-1

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

Falls Sie keinen AWS-S3-Bucket haben, müssen Sie einen neuen erstellen. Gehen Sie dazu wie folgt vor:

1. Öffnen Sie das S3-Dashboard: Sie finden S3 im Servicemenü unter „Storage“.

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

2. Erstellen Sie einen neuen Bucket: Klicken Sie im S3-Dashboard auf die Schaltfläche „Create bucket“.

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

3. Geben Sie einen Bucket-Namen ein und klicken Sie auf die Schaltfläche „Create bucket“. Die anderen Bucket-Optionen können Sie auf den Standardwerten belassen. Der neu hinzugefügte Bucket erscheint in der Liste.

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

#### AWS SDK installieren und Anmeldedaten hinzufügen

Installieren Sie `boto3`, um mit AWS-Services über `pip` und `npm` zu interagieren.

**`Python`**

```bash Python
pip install boto3
```

**`TypeScript`**

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

Fügen Sie anschließend die Umgebungsvariablen wie folgt zur `.env`-Datei hinzu:

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

#### In AWS S3 hochladen und die signierte URL generieren

Fügen Sie die folgenden Funktionen hinzu, um den Audiostream in S3 hochzuladen und eine signierte URL zu generieren.

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

Sie können die Upload-Funktion anschließend mit dem Audiostream aus dem Text aufrufen.

**`Python`**

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

**`TypeScript`**

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

Generieren Sie nach dem Hochladen der Audiodatei in S3 eine signierte URL, um Zugriff auf die Datei zu gewähren. Diese URL ist zeitlich begrenzt. Sie läuft nach einem bestimmten Zeitraum ab und eignet sich daher für die sichere, temporäre Freigabe.

Sie können jetzt eine URL aus einer Datei generieren:

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

Wenn Sie die Datei mehrfach verwenden möchten, sollten Sie den S3-Dateipfad in Ihrer Datenbank speichern und die signierte URL bei Bedarf jeweils neu generieren, statt die signierte URL direkt zu speichern, da sie abläuft.

#### Alles zusammenführen

Um alles zusammenzuführen, können Sie das folgende Skript verwenden:

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

## Fazit

Sie wissen jetzt, wie Sie Text in Sprache umwandeln und eine signierte URL generieren, um die Audiodatei zu teilen. Diese Funktion eröffnet zahlreiche Möglichkeiten, Inhalte dynamisch zu erstellen und zu teilen.

Hier sind einige Beispiele, was Sie damit entwickeln könnten.

1. **Bildungs-Podcasts**: Erstellen Sie personalisierte Bildungsinhalte, auf die Schüler bei Bedarf zugreifen können. Lehrkräfte können ihre Unterrichtsinhalte in ein Audioformat umwandeln, in S3 hochladen und die Links mit Schülern teilen, um auch außerhalb des traditionellen Klassenzimmers ein ansprechenderes Lernerlebnis zu schaffen.

2. **Barrierefreiheitsfunktionen für Websites**: Verbessern Sie die Barrierefreiheit von Websites, indem Sie Textinhalte im Audioformat anbieten. So werden Informationen auf Websites für Menschen mit Sehbehinderungen oder für Personen, die auditives Lernen bevorzugen, besser zugänglich.

3. **Automatisierte Kundensupport-Nachrichten**: Erstellen Sie automatisierte und personalisierte Audionachrichten für den Kundensupport, beispielsweise FAQs oder Bestellupdates. Dies kann im Vergleich zu herkömmlichen Text-E-Mails ein ansprechenderes Kundenerlebnis bieten.

4. **Hörbücher und Erzählungen**: Wandeln Sie ganze Bücher oder Kurzgeschichten in ein Audioformat um und bieten Sie Ihrem Publikum eine neue Möglichkeit, Literatur zu genießen. Autoren und Verlage können ihr Inhaltsangebot diversifizieren und Zielgruppen erreichen, die lieber zuhören als lesen.

5. **Tools zum Sprachenlernen**: Entwickeln Sie Lernhilfen für Sprachen, die Lernenden Audiolektionen und Übungen bieten. So können sie Aussprache und Hörverständnis gezielt üben.

## Nächste Schritte

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

Nutzen Sie WebSockets, um Text in Sprache in Echtzeit zu streamen, während er von einem LLM generiert wird.

#### [Latenz verstehen](/docs/de/eleven-api/concepts/latency)

Erfahren Sie, was zur Latenz beiträgt und wie Sie die Zeit bis zum ersten Audio minimieren.