DEV Community

Cover image for Fish Audio S2 API nutzen: Vollständige Anleitung mit Apidog
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

Fish Audio S2 API nutzen: Vollständige Anleitung mit Apidog

Fish Audio S2 API

Die Fish Audio S2 API ist eine fortschrittliche Text-to-Speech REST API, die auf einem 4-Milliarden-Parameter-Modell basiert und mit 10 Millionen Stunden Audiomaterial trainiert wurde. Sie unterstützt Stimmklonierung, Streaming und mehr als 50 Sprachen. Wenn Sie Anfragen senden, Referenzen verwalten oder Unit-Tests ausführen möchten, ist Apidog der schnellste Weg, um jeden Endpunkt der API effizient zu testen, zu dokumentieren und zu validieren.

Teste Apidog noch heute

Einführung

KI-generierte Stimmen sind inzwischen so realistisch, dass sie Lachen, Flüstern und Tonfallwechsel imitieren können. Die Fish Audio S2 API nutzt ein 4-Milliarden-Parameter-Modell, das auf über 10 Millionen Stunden mehrsprachigem Audiomaterial trainiert wurde. Damit erzeugt sie Sprache, die sich kaum von echten menschlichen Aufnahmen unterscheiden lässt.

Egal, ob Sie ein Podcast-Automatisierungstool, einen Sprachassistenten oder eine Echtzeit-Synchronisation entwickeln: Für die Integration der Fish Audio S2 API müssen Sie Authentifizierung, Referenzmanagement, Streaming und Unit-Tests verstehen, um Ausfälle in der Produktion zu vermeiden.

💡 Tipp: Bevor Sie Ihren ersten Fish Audio S2 API-Aufruf tätigen, laden Sie Apidog kostenlos herunter. Testen Sie Emotions-Tags, Streaming-Chunks, Stimmklonierungs-Payloads und binäre Audio-Antworten visuell in Sekunden – kein Code notwendig. Mocken, validieren und hören Sie direkt, damit Ihre TTS-Integration sofort funktioniert.

Was ist die Fish Audio S2 API?

Die Fish Audio S2 API ist die HTTP-Schnittstelle zu Fish Speech S2-Pro, einem Open-Source-TTS-System auf Dual-Autoregressiver Architektur. Das Modell trennt semantische Generierung (4 Mrd. Parameter) und Rest-Codebook-Generierung (400 Mio. Parameter), was hochwertige Synthese mit einem Echtzeitfaktor von 0,195 auf einer NVIDIA H200 ermöglicht.

Kernfunktionen:

Funktion Details
Sprachen ~50 (Englisch, Chinesisch, Japanisch, Koreanisch, Arabisch, Französisch, Deutsch, u.v.m.)
Stimmklonierung 10–30 Sekunden Referenz-Audio, kein Fine-Tuning notwendig
Inline-Emotionskontrolle Tags wie [laugh], [whispers], [super happy] im Text möglich
Mehrere Sprecher Native `<\
Streaming Echtzeit-Chunk-Audio über {% raw %}"streaming": true
Ausgabeformate WAV, MP3, PCM
Authentifizierung Bearer-Token (Authorization: Bearer YOUR_API_KEY)

Die Basis-URL nach lokaler Bereitstellung lautet http://127.0.0.1:8080. Alle Endpunkte liegen unter /v1/.

Erste Schritte mit der Fish Audio S2 API und Apidog

Voraussetzungen für die Fish Audio S2 API

Sie benötigen:

  1. Einen laufenden Fish Speech S2-Pro-Server
  2. Einen API-Client, der binäre Audio-Antworten verarbeiten kann

Server starten:

python tools/api_server.py \
  --llama-checkpoint-path checkpoints/s2-pro \
  --decoder-checkpoint-path checkpoints/s2-pro/codec.pth \
  --listen 0.0.0.0:8080 \
  --compile \
  --half \
  --api-key YOUR_API_KEY \
  --workers 4
Enter fullscreen mode Exit fullscreen mode
  • --compile aktiviert torch.compile für 10x geringere Inferenzlatenz.
  • --half aktiviert FP16 und spart GPU-Speicher.

Health-Check:

curl http://127.0.0.1:8080/v1/health
# {"status":"ok"}
Enter fullscreen mode Exit fullscreen mode

Einrichtung der Fish Audio S2 API in Apidog

  1. Laden Sie Apidog kostenlos herunter und erstellen Sie ein neues HTTP-Projekt.
  2. Basis-URL http://127.0.0.1:8080 unter Umgebungen hinzufügen.
  3. Globalen Header setzen: 
   Authorization: Bearer YOUR_API_KEY
Enter fullscreen mode Exit fullscreen mode

Der Token wird automatisch auf alle Anfragen angewendet – das spart Zeit, besonders bei mehreren Umgebungen (Entwicklung, Staging, Produktion).

Ihre erste Fish Audio S2 API-Anfrage in Apidog

Testen des TTS-Endpunkts

Hauptendpunkt: POST /v1/tts. In Apidog neue Anfrage anlegen (POST), JSON-Body verwenden:

{
  "text": "Hello! This is a test of the Fish Audio S2 API.",
  "format": "wav",
  "streaming": false,
  "temperature": 0.8,
  "top_p": 0.8,
  "repetition_penalty": 1.1,
  "max_new_tokens": 1024
}
Enter fullscreen mode Exit fullscreen mode

Parameterübersicht:

Parameter Typ Standard Beschreibung
text String erforderlich Zu synthetisierender Text
format String "wav" Audioformat: wav, mp3, pcm
chunk_length Integer 200 Chunk-Größe (100–300)
seed Integer null Seed für reproduzierbare Ausgabe
streaming Boolean false Echtzeit-Chunking
max_new_tokens Integer 1024 Maximale Tokenanzahl
temperature Float 0.8 Sampling-Zufälligkeit (0.1–1.0)
top_p Float 0.8 Nucleus-Sampling-Schwelle (0.1–1.0)
repetition_penalty Float 1.1 Wiederholungsbestrafung (0.9–2.0)
use_memory_cache String "off" Referenzkodierung im Speicher cachen

In Apidog:

Auf Senden klicken. Die API liefert rohe Audio-Bytes zurück. Apidog rendert automatisch einen Inline-Audioplayer – Sie können die generierte Sprache direkt abspielen.

Stimmklonierung mit der Fish Audio S2 API

Referenz-Audio hochladen

Die Zero-Shot-Stimmklonierung läuft über das Feld references in der Anfrage. Sie übergeben einen base64-kodierten Audioclip plus Transkript.

Referenz hochladen:

{
  "id": "my-voice-clone",
  "text": "This is the reference transcription matching the audio.",
  "audio": "<base64-encoded-wav-bytes>"
}
Enter fullscreen mode Exit fullscreen mode

In Apidog:

  • Bodytyp Binary für direkte Dateiübertragung, oder
  • Form Data für Datei- und Textfelder.

Antwort:

{
  "success": true,
  "message": "Reference added successfully",
  "reference_id": "my-voice-clone"
}
Enter fullscreen mode Exit fullscreen mode

In TTS-Anfrage referenzieren:

{
  "text": "This sentence will be spoken in the cloned voice.",
  "reference_id": "my-voice-clone",
  "format": "mp3"
}
Enter fullscreen mode Exit fullscreen mode

Im Referenzmanagement-Panel von Apidog können Sie Anfragen als Vorlagen speichern und reference_id schnell austauschen – ideal für das Testen mehrerer Stimmen.

Wie Sie Fish Audio S2 API Integrationen mit Unit-Tests testen

Warum Unit-Tests für die Fish Audio S2 API?

Fehlermodi wie gelöschte Referenz-IDs, ungültige Parameter oder falsches Audioformat bleiben ohne automatisierte Tests oft unentdeckt. Unit-Tests erkennen diese Fehler zuverlässig, bevor sie Nutzer beeinträchtigen.

Unit-Tests mit Python

Beispiel für eine pytest-Test-Suite mit httpx:

import pytest
import httpx
import base64

BASE_URL = "http://127.0.0.1:8080"
API_KEY = "YOUR_API_KEY"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}


class TestFishAudioS2API:
    def test_health_check(self):
        response = httpx.get(f"{BASE_URL}/v1/health", headers=HEADERS)
        assert response.status_code == 200
        assert response.json()["status"] == "ok"

    def test_tts_basic_request(self):
        payload = {
            "text": "Unit test: verifying Fish Audio S2 API TTS output.",
            "format": "wav",
            "seed": 42,
        }
        response = httpx.post(
            f"{BASE_URL}/v1/tts",
            json=payload,
            headers=HEADERS,
            timeout=60,
        )
        assert response.status_code == 200
        assert response.headers["content-type"] == "audio/wav"
        assert len(response.content) > 1000

    def test_tts_invalid_temperature_raises_error(self):
        payload = {"text": "test", "temperature": 99.0}
        response = httpx.post(
            f"{BASE_URL}/v1/tts",
            json=payload,
            headers=HEADERS,
            timeout=30,
        )
        assert response.status_code == 422

    def test_reference_add_and_list(self):
        with open("test_reference.wav", "rb") as f:
            audio_b64 = base64.b64encode(f.read()).decode()

        add_response = httpx.post(
            f"{BASE_URL}/v1/references/add",
            json={
                "id": "unit-test-voice",
                "text": "This is a unit test reference audio.",
                "audio": audio_b64,
            },
            headers=HEADERS,
        )
        assert add_response.json()["success"] is True

        list_response = httpx.get(
            f"{BASE_URL}/v1/references/list", headers=HEADERS
        )
        assert "unit-test-voice" in list_response.json()["reference_ids"]

        httpx.request(
            "DELETE",
            f"{BASE_URL}/v1/references/delete",
            json={"reference_id": "unit-test-voice"},
            headers=HEADERS,
        )
Enter fullscreen mode Exit fullscreen mode

Ausführen mit:

pytest test_fish_audio_s2_api.py -v
Enter fullscreen mode Exit fullscreen mode

Unit-Tests mit Apidog ausführen

Nutzen Sie die Test-Szenarien-Funktion von Apidog für automatisierte Tests ohne lokale Python-Umgebung:

  1. Fish Audio S2 API-Sammlung öffnen
  2. Test-Szenarien → Neues Szenario
  3. Anfragen hinzufügen: Health-Check → TTS → Referenz hinzufügen → Referenzliste
  4. Im Tab Assertions für die TTS-Anfrage:
    • Statuscode = 200
    • Header content-type enthält audio
    • Antwortzeit < 30000ms
  5. Ausführen klicken – Apidog zeigt Bestanden/Fehlgeschlagen-Berichte mit Antwortzeiten und Diffs. Berichte können exportiert oder als CI-Trigger eingeplant werden – Apidog wird so Ihr Test-Runner, ganz ohne Test-Framework-Boilerplate.

Erweiterte Funktionen der Fish Audio S2 API

Audio-Streaming

Für Echtzeitanwendungen aktivieren Sie "streaming": true im Anfrage-Body:

import httpx

with httpx.stream(
    "POST",
    "http://127.0.0.1:8080/v1/tts",
    json={
        "text": "Streaming audio from the Fish Audio S2 API in real time.",
        "format": "wav",
        "streaming": True,
    },
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    timeout=None,
) as response:
    with open("streamed_output.wav", "wb") as audio_file:
        for chunk in response.iter_bytes(chunk_size=4096):
            audio_file.write(chunk)
Enter fullscreen mode Exit fullscreen mode

Die API beginnt nach ca. 100 ms mit der Rückgabe von Audio-Bytes – ideal für Live-Sprachanwendungen.

Inline-Emotionskontrolle

Emotionale Tags direkt im text-Feld einbetten:

{
  "text": "[whispers] The secret is hidden here. [super happy] I found it!",
  "format": "wav"
}
Enter fullscreen mode Exit fullscreen mode

Das Modell erkennt Tags wie [laugh], [cough], [pitch up], [professional broadcast tone], [whisper in small voice] als Prosodie-Steuerung.

Fazit

Die Fish Audio S2 API ist eine produktionsreife TTS-Engine mit REST-Interface. Sie unterstützt alles von Basissynthese bis Zero-Shot-Stimmklonierung und Echtzeit-Streaming. Für eine robuste Integration:

  • Setzen Sie geeignete Sampling-Parameter (temperature, top_p, repetition_penalty)
  • Managen Sie den Lebenszyklus von Referenz-Audio
  • Halten Sie eine Unit-Test-Suite aktuell

Apidog beschleunigt Ihre Entwicklung messbar: Senden Sie Ihre erste Anfrage in <2 Minuten, hören Sie Audio inline, generieren Sie Client-Code und führen Sie automatisierte Endpoint-Tests ohne Test-Framework-Konfiguration aus.

Teilen Sie die API-Spezifikation oder Dokumentation direkt mit Ihrem Team – Apidog hält alles synchron.

Laden Sie Apidog kostenlos herunter und importieren Sie die Fish Audio S2 API-Sammlung, um sofort mit dem Testen zu starten.

Häufig gestellte Fragen

Was ist die Fish Audio S2 API?

Die Fish Audio S2 API ist die REST-Schnittstelle zu Fish Speech S2-Pro, einem 4-Milliarden-Parameter-TTS-Modell mit 10 Millionen Stunden Training. Sie unterstützt Stimmklonierung, Streaming, Emotionskontrolle und über 50 Sprachen via /v1/-Endpunkte.

Wie authentifiziere ich mich bei der Fish Audio S2 API?

Senden Sie im Header jeder Anfrage: Authorization: Bearer YOUR_API_KEY. Den API-Schlüssel setzen Sie beim Serverstart mit --api-key. Apidog speichert den Token auf Umgebungsebene für alle Anfragen.

Kann ich Integrationen ohne Code mit Unit-Tests abdecken?

Ja. Mit den Test-Szenarien von Apidog können Sie Unit-Tests für jeden Endpunkt visuell erstellen und ausführen. Definieren Sie Assertions (Statuscode, Antwortzeit, Header) und lassen Sie Apidog die Tests lokal oder CI-gesteuert laufen – ohne Framework-Setup.

Welche Audioformate unterstützt die API?

WAV, MP3 und PCM. Das gewünschte Format wird im Feld "format" im TTS-Request angegeben (Standard: WAV).

Wie funktioniert Stimmklonierung?

Laden Sie einen 10-30 Sekunden langen Referenz-Clip samt Transkript via POST /v1/references/add hoch. Geben Sie dann die Referenz-ID im Feld "reference_id" bei jedem TTS-Request mit. Kein Fine-Tuning oder Modelltraining nötig.

Was ist der Echtzeitfaktor der API?

Auf einer NVIDIA H200 liegt der Real-Time Factor (RTF) bei 0,195 mit aktiviertem Streaming – das entspricht ~5 Sekunden Audio pro Sekunde Rechenzeit. Die Latenz bis zum ersten Audio beträgt ca. 100 ms.

Wie prüfe ich API-Antworten in Apidog?

Bei binären Audio-Antworten rendert Apidog automatisch einen Inline-Player. Sie können sofort reinhören, Header prüfen und Assertions hinzufügen – alles direkt im Apidog-Panel.

Top comments (0)