Speech to Text API-Integration: Entwicklerleitfaden

Eine Speech to Text API ermöglicht es Entwicklern, Spracherkennung und Transkription direkt in ihre Anwendungen zu integrieren. Bevor Sie die STT API anbinden, müssen Sie jedoch einige Architekturentscheidungen treffen.

Welchen Transkriptionsmodus werden Sie nutzen? Wie gehen Sie mit langen Audiodateien um? Wie stellen Sie sicher, dass Produktnamen oder Eigennamen korrekt geschrieben werden? Etwas Planung im Voraus hilft, eine skalierbare Speech to Text API-Integration in Ihren Entwickleranwendungen zu schaffen.

Dieser Leitfaden enthält alles, was Sie für eine ElevenLabs Speech to Text API-Integration benötigen, inklusive klarer Codebeispiele, die Sie direkt in die Produktion übernehmen können. Als Referenz sollten Sie das ElevenLabs Speech to Text Quickstart und den API-Leitfaden in einem separaten Fenster geöffnet haben.

Zusammenfassung

• Es gibt zwei Speech to Text Modi bei ElevenLabs: Batch (für vorab aufgezeichnete Audios) und Echtzeit (für Live-Audiostreams via WebSocket).
• Scribe v2 übernimmt Batch-Transkriptionen in über 90 Sprachen mit Sprechertrennung, Keyterm-Prompting, Entitätenerkennung, Zeitstempeln auf Wortebene und Multichannel-Unterstützung.
• Scribe v2 Echtzeit verarbeitet Live-Streams mit ca. 150 ms Latenz und liefert Teilergebnisse während des Sprechens sowie finale Transkripte nach Abschluss eines Sprachsegments.
• Für Dateien über 8 Minuten teilt Scribe v2 diese automatisch in Segmente und transkribiert parallel. Für lange Jobs nutzen Sie Webhooks statt auf die synchrone Antwort zu warten.
• Keyterm-Prompting steuert das Modell gezielt auf bestimmte Begriffe – zuverlässiger als Keyword-Listen für Produktnamen, Fachbegriffe oder ungewöhnliche Eigennamen.

Speech to Text API-Integration: Batch vs. Echtzeit

Jede ElevenLabs STT API-Integration beginnt mit einer Architekturentscheidung: Batch oder Echtzeit. Beide liefern ein leistungsfähiges STT-Modell, aber Ihre Wahl beeinflusst, welche Funktionen Sie nutzen können und wie hoch die Latenz ist.

So unterscheiden sich die beiden Modi:

• Batch (Scribe v2): Nimmt eine komplette Audio- oder Videodatei, transkribiert sie und liefert das vollständige Transkript in einer Antwort. Unterstützt bis zu 1.000 Keyterms, bis zu 32 Sprecher für Diarisierung, Entitätenerkennung, Multichannel-Modus und Webhooks für asynchrone Zustellung. Dateien bis 3 GB und 10 Stunden werden im Standardmodus unterstützt.
• Echtzeit (Scribe v2 Realtime): Akzeptiert einen Live-Audiostream über WebSocket und liefert Teilergebnisse und finale Transkripte mit ca. 150 ms Latenz. Unterstützt bis zu 50 Keyterms und Zeitstempel auf Wortebene. Ideal für Sprachassistenten, Live-Untertitel oder Anwendungen, bei denen Nutzer sprechen und eine direkte Antwort erwarten.

Schauen wir uns die Unterschiede genauer an.

Als Faustregel gilt: Nutzen Sie Batch, wenn das Audio vor der Transkription vollständig vorliegt, und Echtzeit, wenn Sie Audio während der Aufnahme transkribieren.

Wann Scribe v2 oder Scribe v2 Realtime wählen

Batch und Echtzeit decken unterschiedliche Anwendungsfälle ab. Die falsche Wahl führt später oft zu Mehraufwand.

So wählen Sie das passende Modell für Ihren Anwendungsfall:

• Scribe v2 ist die richtige Wahl, wenn das Audio vor der Verarbeitung vollständig ist – z. B. für Meeting-Aufzeichnungen, Podcast-Transkriptionen, Mediendateien oder alles, was Sie offline verarbeiten. Unterstützt das volle Funktionsspektrum inklusive Diarisierung, Entitätenerkennung und bis zu 1.000 Keyterms.
• Scribe v2 Realtime ist für Live-Audio gebaut. Es akzeptiert einen WebSocket-Stream und liefert Transkripte, sobald das Audio ankommt – ideal für Sprachassistenten oder Szenarien, in denen Ihre Anwendung reagieren muss, bevor der Nutzer fertig gesprochen hat.

Ein weiterer Faktor: Die Genauigkeit variiert je nach Sprache. Prüfen Sie die Wortfehlerrate, bevor Sie sich auf eine Sprachkombination festlegen. Scribe v2 veröffentlicht Wortfehlerraten (WER) für alle unterstützten Sprachen.

Sehr hohe Genauigkeit (≤5% WER) gilt für die wichtigsten europäischen Sprachen, Japanisch, Indonesisch, Vietnamesisch und weitere. Hohe Genauigkeit (5-10% WER) gilt für Hindi, Bengali, Mandarin, Koreanisch, Georgisch und andere. Details finden Sie in der Sprachunterstützungs-Dokumentation.

Einrichtung der ElevenLabs Speech to Text API

Ein funktionierender Client erfordert nur zwei Schritte: Zuerst installieren Sie das SDK. Dann speichern Sie Ihre Zugangsdaten sicher.

So gehen Sie vor, bevor Sie Ihre erste Transkriptionsanfrage stellen.

Installieren Sie das SDK und speichern Sie Ihren API-Schlüssel als Secret, z. B. in einer .env-Datei oder im Secrets Manager Ihrer Plattform. Niemals den API-Schlüssel direkt im Code hinterlegen.

Python

pip install elevenlabs
pip install python-dotenv

TypeScript

npm install @elevenlabs/elevenlabs-js

Erstellen Sie eine .env-Datei:

ELEVENLABS_API_KEY=<your_api_key_here>

Initialisieren Sie den Client:

Python

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

load_dotenv()

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

TypeScript

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

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

Ihre erste Batch-Transkription mit der ElevenLabs STT API

Nachdem Sie den Client initialisiert haben, können Sie Ihre erste Datei senden.

Die Batch-API nimmt eine Datei, transkribiert sie und liefert das vollständige Ergebnis synchron zurück. Das Beispiel unten transkribiert eine entfernte Audiodatei mit aktivierter Sprechertrennung und Audio-Event-Tagging.

Python

# example.py
import os
from dotenv import load_dotenv
from io import BytesIO
import requests
from elevenlabs.client import ElevenLabs

load_dotenv()

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

audio_url = (
    "https://storage.googleapis.com/eleven-public-cdn/audio/marketing/nicole.mp3"
)
response = requests.get(audio_url)
audio_data = BytesIO(response.content)

transcription = elevenlabs.speech_to_text.convert(
    file=audio_data,
    model_id="scribe_v2",          # Model to use
    tag_audio_events=True,          # Tag audio events like laughter, applause, etc.
    language_code="eng",            # Language of the audio file. If set to None, the model will detect the language automatically.
    diarize=True,                   # Whether to annotate who is speaking
)

print(transcription)

So führen Sie es aus:

python example.py

Das Response-Objekt enthält den vollständigen Transkripttext, Einträge auf Wortebene mit Zeitstempeln und Sprecher-IDs sowie erkannte Audioereignisse.

Jeder Worteintrag enthält ein type-Feld mit einem von drei Werten:

• Wort: Für transkribierte Wörter im Audio.
• Abstand: Leerzeichen zwischen Wörtern in Sprachen, die Leerzeichen verwenden. Dieser Typ ist für einige Sprachen wie Japanisch, Kantonesisch und Birmanisch nicht relevant.
• audio_event: Tag für nichtsprachliche Geräusche wie Lachen oder Husten.

So sieht die Struktur der Antwort aus:

{
  "language_code": "en",
  "language_probability": 1,
  "text": "With a soft and whispery American accent, I'm the ideal choice for creating ASMR content, meditative guides, or adding an intimate feel to your narrative projects.",
  "words": [
    {
      "text": "With",
      "start": 0.119,
      "end": 0.259,
      "type": "word",
      "speaker_id": "speaker_0"
    },
    {
      "text": " ",
      "start": 0.239,
      "end": 0.299,
      "type": "spacing",
      "speaker_id": "speaker_0"
    },
    {
      "text": "a",
      "start": 0.279,
      "end": 0.359,
      "type": "word",
      "speaker_id": "speaker_0"
    }
  ]
}

Das Feld language_probability zeigt, wie sicher das Modell bei der Spracherkennung ist (Skala 0,00 bis 1,00).

STT API Echtzeit-Integration

Echtzeit-STT API-Integration folgt einem etwas anderen Muster. Statt einer Anfrage und einer Antwort öffnen Sie eine WebSocket-Verbindung und lesen Transkripte, sobald sie eintreffen.

Die Echtzeit-API nutzt WebSocket, um einen Live-Audiostream zu empfangen und Transkripte zu liefern, sobald das Audio ankommt. Es gibt zwei Transkripttypen:

• Partielle Transkripte: Zwischenergebnisse, die sich während der Verarbeitung aktualisieren. Diese können sich noch ändern.
• Finale Transkripte: Abgeschlossene Ergebnisse für ein beendetes Sprachsegment. Diese ändern sich nicht mehr. Sie können auch Zeitstempel auf Wortebene enthalten, wenn Sie die Option "include timestamps" aktivieren.

Die Client-Implementierung nutzt ein Einmal-Token statt Ihres API-Schlüssels. Dieses temporäre Token läuft nach 15 Minuten ab und wird serverseitig generiert, sodass Ihr API-Schlüssel nie im Browser sichtbar ist.

Schritt 1: Einmal-Token generieren (Server-seitig)

// Node.js server
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

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

app.get("/scribe-token", yourAuthMiddleware, async (req, res) => {
  const token = await elevenlabs.tokens.singleUse.create("realtime_scribe");

  res.json(token);
});

Schritt 2: Verbinden und transkribieren (Client-seitig, React)

import { useScribe } from "@elevenlabs/react";

function MyComponent() {
  const scribe = useScribe({
    modelId: "scribe_v2_realtime",
    onPartialTranscript: (data) => {
      console.log("Partial:", data.text);
    },
    onCommittedTranscript: (data) => {
      console.log("Committed:", data.text);
    },
    onCommittedTranscriptWithTimestamps: (data) => {
      console.log("Committed with timestamps:", data.text);
      console.log("Timestamps:", data.words);
    },
  });

  const handleStart = async () => {
    // Fetch a single use token from the server
    const token = await fetchTokenFromServer();

    await scribe.connect({
      token,
      microphone: {
        echoCancellation: true,
        noiseSuppression: true,
      },
    });
  };

  return (
    <div>
      <button onClick={handleStart} disabled={scribe.isConnected}>
        Start Recording
      </button>
      <button onClick={scribe.disconnect} disabled={!scribe.isConnected}>
        Stop
      </button>

      {scribe.partialTranscript && <p>Live: {scribe.partialTranscript}</p>}

      <div>
        {scribe.committedTranscripts.map((t) => (
          <p key={t.id}>{t.text}</p>
        ))}
      </div>
    </div>
  );
}

Der useScribe-Hook verwaltet den Lebenszyklus der WebSocket-Verbindung, den Mikrofonzugriff und den Transkriptstatus. partialTranscript enthält den aktuellen Text; committedTranscripts ist das wachsende Array abgeschlossener Segmente.

Für serverseitiges Streaming (Transkription von einer URL oder einem Dateistream statt Mikrofon) siehe den Leitfaden für serverseitiges Streaming.

Parallelisierung und Skalierung langer Dateien

Lange Dateien benötigen ein anderes Skalierungsmodell als die meisten APIs. Das sollten Sie vor dem Aufbau berücksichtigen.

Die Parallelisierung bei Batch-Transkriptionen funktioniert anders als bei den meisten APIs. Statt die Anzahl gleichzeitiger Anfragen zu begrenzen, parallelisiert Scribe v2 lange Dateien automatisch intern.

Dateien über 8 Minuten werden in Segmente aufgeteilt und gleichzeitig transkribiert. Die Anzahl der parallelen Segmente wird wie folgt berechnet:

Concurrency = min(4, round_up(audio_duration_secs / 480))

Konkret:

• Eine 15-minütige Datei nutzt eine Parallelität von 2
• Eine 120-minütige Datei nutzt eine Parallelität von 4 (Maximum)

Dateien bis zu 10 Stunden und 3 GB werden im Standardmodus unterstützt. Hinweis: Im Multichannel-Modus ist die maximale Dauer geringer – siehe Abschnitt Multichannel-Transkription.

Die STT API unterstützt die gängigsten Audio- und Videoformate:

• Audio: AAC, AIFF, OGG, MP3, OPUS, WAV, FLAC, M4A, WebM.
• Video: MP4, AVI, MKV, MOV, WMV, FLV, WebM, MPEG, 3GPP.

Sie können eine Videodatei direkt übergeben und erhalten ein Transkript der Audiospur – ohne Vorverarbeitung.

Keyterm-Prompting

Generische Modelle transkribieren Markennamen und Fachbegriffe oft falsch. Keyterm-Prompting behebt das.

Keyterm-Prompting steuert das Modell gezielt auf bestimmte Wörter oder Phrasen. Ideal, wenn Ihr Audio Produktnamen, Fachbegriffe oder ungewöhnliche Eigennamen enthält.

Ein Vorteil von Keyterm-Prompting ist die Nutzung des Kontexts, wodurch es zuverlässiger ist als einfache Keyword-Listen. Geben Sie z. B. "ElevenLabs" als Keyterm an, transkribiert das Modell den Firmennamen korrekt, wenn er genannt wird. Ohne dies kann es passieren, dass "I've worked at eleven labs for a year" falsch transkribiert wird.

Ohne Keyterm-Prompting:

I work at eleven labs.

Mit keyterms=["ElevenLabs"]:

I work at ElevenLabs.

Batch unterstützt bis zu 1.000 Keyterms (je 50 Zeichen). Echtzeit unterstützt bis zu 50 Keyterms (je 20 Zeichen).

Batch-Transkription mit Keyterms

Python

import os
from dotenv import load_dotenv
from io import BytesIO
import requests
from elevenlabs.client import ElevenLabs

load_dotenv()

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

audio_url = (
    "https://storage.googleapis.com/eleven-public-cdn/documentation_assets/audio/stt-keyterm-prompting.mp3"
)
response = requests.get(audio_url)
audio_data = BytesIO(response.content)

transcription = elevenlabs.speech_to_text.convert(
    file=audio_data,
    model_id="scribe_v2",
    # Keyterms to prompt the model with.
    # Up to 1,000 keyterms can be provided, with a maximum length of 50 characters each
    keyterms=["ElevenLabs"],
)

print(transcription)

Echtzeit-Streaming mit Keyterms

Übergeben Sie Keyterms beim Verbinden mit dem Echtzeit-WebSocket:

Python

connection = await elevenlabs.speech_to_text.realtime.connect(RealtimeUrlOptions(
    model_id="scribe_v2_realtime",
    keyterms=["ElevenLabs"],
))

Oder übergeben Sie sie direkt als Query-Parameter in der WebSocket-URL:

wss://api.elevenlabs.io/v1/speech-to-text/realtime?model_id=scribe_v2_realtime&keyterms=ElevenLabs&keyterms=AnotherTerm

Keyterm-Prompting verursacht zusätzliche Kosten. Siehe die API-Preisseite für Details.

Erweiterte Funktionen

Neben dem Kernablauf der STT API gibt es weitere Funktionen, die das Endergebnis verbessern. Hier einige erweiterte Features für Ihre Speech to Text API:

• Sprechertrennung zur Identifikation der Sprechenden
• No-verbatim-Modus für bereinigte Transkripte
• Entitätenerkennung zur Markierung sensibler Daten
• Multichannel-Transkription zur Trennung von Audiokanälen

Schauen wir uns diese Funktionen genauer an.

Sprechertrennung

Aktivieren Sie diarize=True in Ihrer Batch-Anfrage, um zu markieren, wer spricht. Scribe v2 unterstützt bis zu 32 Sprecher. Jedes Wort im Ergebnis enthält ein speaker_id-Feld (z. B. speaker_0, speaker_1), mit dem Sie Transkriptsegmente nach Sprecher trennen können.

Diarisierung ist nützlich für Meeting-Transkripte, Interviews oder jede Mehrsprecher-Aufnahme, bei der die Zuordnung zu den richtigen Sprechern wichtig ist.

No-verbatim-Modus

Bei no_verbatim=True entfernt das Modell Füllwörter, Versprecher und Unflüssigkeiten aus dem Transkript. "Erm, M-maybe we should, uh, go with option A" wird zu "Maybe we should go with option A."

Das sorgt für klarere Ergebnisse bei Untertiteln, Zusammenfassungen oder überall dort, wo Lesbarkeit wichtiger ist als jede gesprochene Silbe. Verfügbar für Batch (scribe_v2) und Echtzeit (scribe_v2_realtime).

Entitätenerkennung und Schwärzung

Scribe v2 kann Entitäten im Transkript erkennen und mit genauen Zeitstempeln versehen. Kategorien sind u. a. PII (Namen, Kreditkartennummern, Sozialversicherungsnummern), PHI (medizinische Daten) und PCI (Zahlungskartendaten). Die vollständige Liste finden Sie in der Dokumentation zur Entitätenerkennung.

Das ist besonders für Compliance-Anwendungen nützlich, um sensible Informationen vor Speicherung oder Anzeige automatisch zu schwärzen.

Entitätenerkennung verursacht zusätzliche Kosten von $0,070 (pro Stunde) auf den Grundpreis der Transkription. Siehe die API-Preisseite für Details.

Multichannel-Transkription

Bei use_multi_channel=True wird jeder Audiokanal unabhängig transkribiert und erhält eine speaker_id entsprechend der Kanalnummer. Bis zu 5 Kanäle werden unterstützt. Die maximale Dateidauer im Multichannel-Modus beträgt 1 Stunde.

Multichannel ist sinnvoll, wenn Sie pro Sprecher einen eigenen Audiotrack haben – z. B. bei Telefonaufzeichnungen. Das sorgt für eine genauere Sprecherzuordnung als Diarisierung bei einer gemischten Mono-Datei.

Asynchrone Zustellung mit Webhooks

Polling ist bei geringem Volumen in Ordnung, skaliert aber nicht bei langen Dateien oder großen Pipelines. Webhooks lösen dieses Problem, indem sie das Ergebnis an Sie senden.

Bei langen Dateien oder hohem Volumen ist das Warten auf die synchrone Antwort nicht praktikabel. Mit Webhooks können Sie eine Transkriptionsanfrage stellen und das Ergebnis erhalten, sobald die Verarbeitung abgeschlossen ist – ohne Polling.

Webhook einrichten

Im ElevenLabs-Dashboard gehen Sie zu Entwickler > Webhooks, klicken Sie auf Webhook erstellen und konfigurieren Sie:

• Name: Vergeben Sie einen beschreibenden und einprägsamen Namen für Ihren Webhook.
• Callback-URL: Fügen Sie dem Webhook eine öffentlich erreichbare HTTPS-URL hinzu.
• Webhook-Authentifizierungsmethode: Wählen Sie HMAC oder OAuth (optional, aber aus Sicherheitsgründen empfohlen).
• Ereignisse: Wählen Sie "Transcription completed" aus.

Transkriptionsanfrage mit Webhook-Zustellung absenden

Python

from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs

load_dotenv()

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

def transcribe_with_webhook(audio_file):
    try:
        result = elevenlabs.speech_to_text.convert(
            file=audio_file,
            model_id="scribe_v2",
            webhook=True,
        )
        print(f"Transcription started: {result.request_id}")
        return result
    except Exception as e:
        print(f"Error starting transcription: {e}")
        raise e

Bei webhook=True gibt die Anfrage sofort eine Antwort zurück, ohne das Transkript. Das fertige Transkript wird per POST an Ihren Endpoint gesendet, sobald die Verarbeitung abgeschlossen ist.

Implementierung Ihres Webhook-Endpoints

import { ElevenLabsClient } from '@elevenlabs/elevenlabs-js';
import 'dotenv/config';
import express from 'express';

const elevenlabs = new ElevenLabsClient();
const app = express();
app.use(express.json());

const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET;

app.post('/webhook/speech-to-text', (req, res) => {
  try {
    const signature = req.headers['elevenlabs-signature'];
    const payload = JSON.stringify(req.body);
    let event;

    try {
      // Verify the webhook signature.
      event = await elevenlabs.webhooks.constructEvent(payload, signature, WEBHOOK_SECRET);
    } catch (error) {
      return res.status(401).json({ error: 'Invalid signature' });
    }

    if (event.type === 'speech_to_text.completed') {
      const { requestId, status, text, language_code } = event.data;

      console.log(`Transcription ${requestId} completed`);
      console.log(`Language: ${language_code}`);
      console.log(`Text: ${text}`);

      processTranscription(requestId, text, language_code);
    } else if (status === 'failed') {
      console.error(`Transcription ${requestId} failed`);
      handleTranscriptionError(requestId);
    }

    res.status(200).json({ received: true });
  } catch (error) {
    console.error('Webhook error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

app.listen(3000, () => {
  console.log('Webhook server listening on port 3000');
});

Struktur des Webhook-Payloads

Ihr Endpoint erhält einen POST mit folgendem Aufbau:

{
  "type": "speech_to_text_transcription",
  "data": {
    "request_id": "some-request-id-123",
    "webhook_metadata": {},
    "transcription": {
      "language_code": "en",
      "language_probability": 0.98,
      "text": "Hello world!",
      "words": [
        {
          "text": "Hello",
          "start": 0.0,
          "end": 0.5,
          "type": "word",
          "speaker_id": "speaker_1"
        }
      ]
    }
  }
}

Best Practices für Webhook-Sicherheit

Beim Arbeiten mit Webhooks gibt es einige Sicherheitsmaßnahmen, um eine korrekte Zustellung und Verarbeitung zu gewährleisten.

• Webhook-Signaturen verifizieren: Verifizieren Sie immer die Webhook-Signatur mit elevenlabs.webhooks.constructEvent(), um sicherzustellen, dass sie von ElevenLabs stammt.
• HTTPS-Endpoints verwenden: Webhook-URLs müssen HTTPS nutzen, um Daten während der Übertragung zu schützen.
• Den passenden HTTP-Statuscode zurückgeben: Geben Sie 200-299 bei erfolgreicher Verarbeitung zurück, 400-499 bei Client-Fehlern (werden nicht erneut gesendet) und 500-599 bei Server-Fehlern (werden erneut gesendet).
• Tunneling-Tool für lokale Entwicklung nutzen: Für lokale Entwicklung nutzen Sie ein Tunneling-Tool wie ngrok, um Ihren lokalen Server öffentlich per HTTPS erreichbar zu machen.

Mit diesen Maßnahmen können Sie Webhooks sicher einsetzen.

Wichtige Punkte für Ihre Speech to Text API-Integration

Eine produktive Speech to Text API-Integration hängt von wenigen Entscheidungen ab.

Wenn Sie diese richtig treffen, läuft alles Weitere reibungslos:

• Modus passend zum Anwendungsfall wählen: Nutzen Sie Batch (scribe_v2), wenn das Audio vor der Verarbeitung vollständig ist. Nutzen Sie Echtzeit (scribe_v2_realtime), wenn Sie während der Aufnahme transkribieren müssen, z. B. für Agents, Sprachassistenten oder Live-Untertitel.
• Keyterms für spezielle Begriffe nutzen: Übergeben Sie Produktnamen, Fachbegriffe oder ungewöhnliche Eigennamen als Keyterms. Das Modell nutzt Kontext, um sie korrekt anzuwenden, ohne zu übersteuern.
• API übernimmt lange Dateien: Dateien über 8 Minuten werden automatisch parallelisiert – Sie müssen sie nicht selbst aufteilen. Dateien bis 10 Stunden und 3 GB werden im Standardmodus unterstützt.
• Webhooks für asynchrone Verarbeitung nutzen: Bei langen Jobs oder hohem Volumen können Sie mit webhook=True Anfragen absenden und weitermachen. Prüfen Sie die Signatur jeder eingehenden Webhook-Nachricht.
• No-verbatim-Modus für saubere Ergebnisse aktivieren: Für Untertitel, Zusammenfassungen oder nachgelagerte NLP-Verarbeitung entfernt no_verbatim=True automatisch Füllwörter und Unflüssigkeiten.
• Multichannel-Modus für getrennte Audiotracks nutzen: Wenn Ihre Aufnahme pro Sprecher einen eigenen Kanal hat (z. B. Callcenter-Aufzeichnungen, Interviews), liefert Multichannel-Transkription eine genauere Sprecherzuordnung als Diarisierung bei einer gemischten Datei. Beachten Sie das 1-Stunden-Limit in diesem Modus.

Für weitere Informationen sehen Sie sich die vollständige API-Referenz als Ausgangspunkt an.

Bauen Sie Ihre Speech to Text-Integration mit ElevenAPI

Nach diesem Leitfaden kennen Sie alle Muster für eine produktive Speech to Text API-Integration. Mit Batch- und Echtzeit-Transkription sowie erweiterten Funktionen wie Keyterm-Prompting und asynchroner Zustellung sind Sie bereit, Ihre App mit STT zu starten.

Starten Sie, indem Sie mehr über die Speech to Text API erfahren oder sich registrieren, um Ihren ersten Call mit ElevenAPI zu machen.

FAQs zur STT API-Integration