Comment Utiliser l'API Fish Audio S2: Guide Complet avec Apidog

L'API Fish Audio S2 est une API REST de synthèse vocale de niveau production, basée sur un modèle de 4 milliards de paramètres entraîné sur 10 millions d'heures d'audio. Elle prend en charge le clonage de voix, le streaming et plus de 50 langues. Pour explorer, documenter et valider chaque point d'accès de l'API Fish Audio S2 de façon rapide et fiable, Apidog offre un workflow optimal : testez visuellement les balises d'émotion, le streaming, les charges utiles de clonage vocal et les réponses audio binaires, sans avoir à produire de code dès le départ.

Essayez Apidog dès aujourd'hui

Introduction

La synthèse vocale par IA a franchi un cap : les nouveaux modèles TTS ne sonnent plus de façon robotique. Ils chuchotent, rient et modulent leur intonation dans une même phrase. Fish Audio S2 est à la pointe de cette révolution : 4 milliards de paramètres, 10 millions d'heures d'audio multilingue, et un rendu vocal indiscernable de l'humain.

Pour automatiser des podcasts, créer des assistants vocaux ou réaliser du doublage en temps réel, intégrer cette API nécessite une approche structurée. Vous devez maîtriser l'authentification, la gestion des références audio, le streaming, et surtout les tests unitaires pour garantir la robustesse de l'intégration.

💡Avant votre premier appel à l'API Fish Audio S2, téléchargez Apidog gratuitement. Testez visuellement les balises d'émotion, le streaming, le clonage vocal et les réponses audio binaires sans code. Simulez, validez et écoutez en ligne pour garantir une intégration TTS opérationnelle du premier coup.

Qu'est-ce que l'API Fish Audio S2 ?

L'API Fish Audio S2 expose Fish Speech S2-Pro (TTS open source, architecture Dual-Autoregressive) via HTTP. La génération sémantique (4B paramètres, AR lente) et la génération des codebooks résiduels (400M paramètres, AR rapide) sont séparées, permettant une synthèse haute qualité avec un facteur temps réel de 0,195 sur GPU NVIDIA H200.

Fonctionnalités majeures :

Fonctionnalité	Détail
Langues	~50 (anglais, chinois, japonais, coréen, arabe, français, allemand, etc.)
Clonage vocal	Audio de référence 10-30s, aucun fine tuning requis
Contrôle des émotions	Balises naturelles : [laugh], [whispers], [super happy]
Multi-locuteurs	Prise en charge du token <|speaker:i|>
Streaming	Audio par blocs avec "streaming": true
Formats de sortie	WAV, MP3, PCM
Authentification	Token Bearer (Authorization: Bearer YOUR_API_KEY)

Après déploiement local, l'URL de base est http://127.0.0.1:8080 et tous les endpoints sont sous /v1/.

Démarrer avec l'API Fish Audio S2 et Apidog

Prérequis

Assurez-vous d'avoir :

• Un serveur Fish Speech S2-Pro déployé
• Un client API pouvant gérer les réponses audio binaires

Lancez le serveur API Fish Audio S2 :

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

--compile active torch.compile (latence réduite ×10). --half active le FP16 (moins de mémoire GPU).

Vérifiez le serveur :

curl http://127.0.0.1:8080/v1/health
# {"status":"ok"}

Configurer l'API Fish Audio S2 dans Apidog

Téléchargez Apidog gratuitement, créez un projet HTTP, ajoutez l'URL http://127.0.0.1:8080 dans Environnements, puis définissez l'en-tête global :

Authorization: Bearer YOUR_API_KEY

Ce header s'appliquera à toutes les requêtes, ce qui facilite la gestion de plusieurs environnements (dev, staging, prod) sans duplication d'en-tête.

Effectuer votre première requête API Fish Audio S2 dans Apidog

Tester le endpoint de synthèse vocale

Endpoint principal : POST /v1/tts. Dans Apidog, créez une requête POST avec ce body JSON :

{
  "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
}

Schéma complet des paramètres :

Paramètre	Type	Défaut	Description
text	string	requis	Texte à synthétiser
format	string	"wav"	Format de sortie : wav, mp3, pcm
chunk_length	int	200	Taille du bloc (100–300)
seed	int	null	Graine pour reproductibilité
streaming	bool	false	Streaming en temps réel
max_new_tokens	int	1024	Tokens max à générer
temperature	float	0.8	Aléatoire d'échantillonnage (0.1–1.0)
top_p	float	0.8	Seuil d'échantillonnage (0.1–1.0)
repetition_penalty	float	1.1	Pénalise les répétitions (0.9–2.0)
ref_cache	string	"off"	Cache l'encodage de référence

Cliquez sur Envoyer. Apidog détecte la réponse audio/wav et offre un lecteur audio intégré pour écouter la synthèse instantanément, sans développement client.

Clonage vocal avec l'API Fish Audio S2

Télécharger une référence audio

Le clonage vocal "zero-shot" exploite le champ references dans la requête TTS. Procédez ainsi :

1. Ajoutez une référence via POST /v1/references/add :

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

Dans Apidog, sélectionnez le corps Binaire pour le fichier audio ou Données de formulaire pour tout transmettre d'un coup.

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

1. Appelez ensuite le TTS avec reference_id :

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

Stockez ces requêtes dans Collections (panneau Références d'Apidog) pour réutiliser ou interchanger les voix clonées rapidement lors de vos tests.

Test automatisé des intégrations

Pourquoi automatiser les tests unitaires

Sans tests automatisés, des défaillances invisibles (ID de référence manquant, mauvais paramètre temperature, gestion incorrecte du streaming, format audio non supporté, etc.) peuvent passer en production. Les tests unitaires détectent ces régressions à temps.

Exemple de tests unitaires Python

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,
        )

Lancez les tests :

pytest test_fish_audio_s2_api.py -v

Automatiser les tests avec Apidog

Utilisez la fonction Scénarios de test d'Apidog pour automatiser ces vérifications, même sans Python local :

1. Ouvrez la collection API Fish Audio S2
2. Ajoutez un Nouveau scénario dans Scénarios de test
3. Enchaînez : contrôle de santé → TTS → ajout référence → liste références
4. Ajoutez des assertions sur la requête TTS : statut 200, content-type contient audio, temps de réponse < 30 000 ms
5. Exécutez la séquence et visualisez le rapport de test

Apidog génère un rapport détaillé, exportable ou programmable pour CI/CD, sans configurer de framework de test.

Fonctionnalités avancées

Streaming audio en temps réel

Pour le streaming, envoyez "streaming": true dans la requête :

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)

L'API commence à streamer l'audio en ~100 ms, idéal pour des cas d'usage vocal en direct.

Contrôle d'émotions inline

Passez des balises d'émotion dans text :

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

Aucune configuration spéciale : le modèle interprète les balises entre crochets ([laugh], [cough], [pitch up], [professional broadcast tone], etc.) comme des instructions de prosodie.

Conclusion

L'API Fish Audio S2 fournit un moteur TTS de niveau production via REST. Elle couvre la synthèse, le clonage vocal, le streaming en temps réel : tout ce dont un développeur a besoin pour la génération vocale. Pour une intégration fiable : ajustez les bons paramètres d'échantillonnage, maîtrisez le cycle de vie des références, et automatisez les tests unitaires.

Apidog facilite la prise en main : envoyez votre première requête en 2 minutes, écoutez les réponses audio directement, exportez du code client, et exécutez vos tests unitaires en un clic. La documentation générée maintient votre équipe et vos parties prenantes alignées.

Téléchargez Apidog gratuitement et importez la collection Fish Audio S2 pour démarrer vos tests immédiatement.

FAQ

Qu'est-ce que l'API Fish Audio S2 ? C'est l'interface REST de Fish Speech S2-Pro, modèle TTS 4 Md de paramètres, 10 M d'heures d'audio. Clonage vocal, streaming, contrôle des émotions, 50+ langues via HTTP sous /v1/.

Comment s'authentifier ? Envoyez Authorization: Bearer YOUR_API_KEY dans chaque requête. La clé est définie au lancement serveur (--api-key). Apidog permet d'appliquer ce token globalement à toutes les requêtes.

Peut-on tester sans coder ? Oui. Les Scénarios de test d'Apidog permettent de créer et exécuter des tests unitaires visuellement : assertions sur statut, temps, headers, le tout sans framework ni code.

Quels formats audio ? WAV, MP3, PCM. À préciser via "format". WAV est le défaut.

Comment fonctionne le clonage vocal ? Envoyez un audio de référence (10-30 s) + transcription à /v1/references/add, puis référencez l'ID dans vos requêtes TTS ("reference_id"). Aucun fine-tuning requis.

Quel est le facteur temps réel ? Sur NVIDIA H200, RTF = 0,195 avec streaming (≈5 s d'audio générées par seconde de calcul). Premier audio en ~100 ms.

Comment tester les réponses dans Apidog ? Lorsqu'une réponse audio binaire est reçue, Apidog affiche un lecteur audio intégré. Pas besoin de télécharger le fichier : écoutez-le directement, vérifiez les headers et ajoutez des assertions depuis l'interface.