Aller au contenu

Tutoriel Python sur l’API de synthèse vocale (2026) : guide de démarrage rapide avec Audexum

Audexum8 minBy Petar

Découvrez comment appeler une API de synthèse vocale en Python avec la bibliothèque requests. Exemples de code complets pour le choix de la voix, la sortie WAV, la gestion des erreurs et la comparaison des tarifs.

L’intégration de la synthèse vocale dans un projet Python demande moins de 20 lignes de code. Ce guide présente tout : authentification, choix d’une voix, enregistrement du fichier WAV, gestion des erreurs et sélection du forfait adapté à votre utilisation.

Tous les exemples utilisent API TTS Audexum, qui prend en charge 43 voix dans 32 langues et propose une offre gratuite sans carte bancaire.

Prérequis

Vous avez uniquement besoin de la bibliothèque requests . Aucun SDK, aucun framework.

bash
pip install requests

Obtenez une clé API gratuite à l’adresse audexum.com/signup. Les clés respectent le format sk_live_abc123xyz. Le forfait gratuit vous offre 2,000 crédits gratuits + 250 par jour, sans carte bancaire.

Premier appel API

Le point de terminaison accepte un corps JSON contenant text, voice_id, et éventuellement language. Il renvoie un fichier audio WAV brut.

python
import requests

API_KEY = "sk_live_abc123xyz"
API_URL = "https://audexum.com/api/v1/tts"

response = requests.post(
    API_URL,
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "text": "Hello, this is a test of the Audexum text-to-speech API.",
        "voice_id": "en_us_female_01",
    },
)

if response.status_code == 200:
    with open("output.wav", "wb") as f:
        f.write(response.content)
    print("Saved output.wav")
else:
    print(f"Error {response.status_code}: {response.text}")

Exécutez-le et vous obtenez output.wav dans le répertoire actuel. C’est toute l’implémentation fonctionnelle.

Sélection d’une voix

Audexum propose 43 voix en anglais américain, anglais britannique, espagnol, français, allemand, japonais, coréen, arabe, hindi, bulgare, italien, portugais et dans d’autres langues. Répertoriez les voix disponibles avec une requête GET :

python
import requests

API_KEY = "sk_live_abc123xyz"

voices = requests.get(
    "https://audexum.com/api/v1/voices",
    headers={"Authorization": f"Bearer {API_KEY}"},
).json()

for voice in voices:
    print(f"{voice['voice_id']:30s} {voice['language']:10s} {voice['gender']}")

Exemple de résultat :

text
en_us_female_01                en-US      female
en_us_male_01                  en-US      male
en_gb_female_01                en-GB      female
de_female_01                   de         female
ja_female_01                   ja         female

Transmettez la chaîne voice_id directement dans votre requête de synthèse.

Enregistrement du fichier WAV

Le corps de la réponse est un WAV PCM brut : aucune décodification base64 nécessaire. Écrivez-le sur le disque avec les entrées/sorties de fichiers standard :

python
import requests
from pathlib import Path

def synthesize(text: str, voice_id: str, output_path: str, api_key: str) -> Path:
    response = requests.post(
        "https://audexum.com/api/v1/tts",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        },
        json={"text": text, "voice_id": voice_id},
    )
    response.raise_for_status()
    path = Path(output_path)
    path.write_bytes(response.content)
    return path

# Usage
output = synthesize(
    text="Welcome to our application.",
    voice_id="en_us_female_01",
    output_path="welcome.wav",
    api_key="sk_live_abc123xyz",
)
print(f"Audio saved to {output} ({output.stat().st_size} bytes)")

Si vous souhaitez obtenir du MP3 au lieu du WAV, transmettez "format": "mp3" dans le corps JSON.

Gestion des erreurs

Gérez explicitement les limites de débit, les voix invalides et les erreurs d’authentification :

python
import requests
from requests.exceptions import RequestException

def safe_synthesize(text: str, voice_id: str, api_key: str) -> bytes | None:
    try:
        response = requests.post(
            "https://audexum.com/api/v1/tts",
            headers={
                "Authorization": f"Bearer {api_key}",
                "Content-Type": "application/json",
            },
            json={"text": text, "voice_id": voice_id},
            timeout=30,
        )

        if response.status_code == 401:
            raise ValueError("Invalid API key. Check your sk_live_ token.")

        if response.status_code == 402:
            raise RuntimeError("Character quota exceeded. Upgrade your plan or wait for reset.")

        if response.status_code == 422:
            raise ValueError(f"Invalid request: {response.json().get('detail')}")

        response.raise_for_status()
        return response.content

    except RequestException as e:
        print(f"Network error: {e}")
        return None

Référence des codes de statut

CodeMeaningAction
200SuccessWrite response body to file
401Bad API keyCheck the Authorization header
402Quota exceededUpgrade plan or wait for monthly reset
422Bad request bodyCheck voice_id and text fields
429Rate limitedRetry with exponential backoff
500Server errorRetry once, then contact support

Traitement par lot

Pour traiter des lots de chaînes, restez sous la limite de débit en insérant un court délai entre les requêtes :

python
import time
import requests
from pathlib import Path

def batch_synthesize(items: list[dict], api_key: str, delay: float = 0.2):
    """
    items: [{"text": "...", "voice_id": "...", "output": "file.wav"}, ...]
    """
    results = []
    for item in items:
        response = requests.post(
            "https://audexum.com/api/v1/tts",
            headers={"Authorization": f"Bearer {api_key}"},
            json={"text": item["text"], "voice_id": item["voice_id"]},
        )
        if response.ok:
            Path(item["output"]).write_bytes(response.content)
            results.append({"file": item["output"], "status": "ok"})
        else:
            results.append({"file": item["output"], "status": response.status_code})
        time.sleep(delay)
    return results

Comparaison des tarifs

Avant de choisir un forfait, voici comment les principales API TTS se comparent en termes de prix par caractère :

ProviderFree TierPaid EntryCost per 1M charsCard Required for Free
Audexum2K to start€29 / 1.2M~€28.00 (PAYG)No
ElevenLabs10K credits/mo$6 / 30K~$165–$200Yes (some plans)
OpenAI TTSNonePay-as-you-go~$15Yes
Google Cloud TTS4M standard + 1M WaveNet/moPay-as-you-go$4 standard / $16 WaveNetYes

Les abonnés aux forfaits Audexum bénéficient de tarifs effectifs de €9.93/1M (Business) à €24.17/1M (Pro). L’option à l’usage, à €28/1M crédits, convient aux projets dont le volume est imprévisible, et les packs de crédits à usage unique n’expirent jamais.

Résumé des forfaits

PlanCredits/moPriceBest For
Free2,000 + 250/day€0Prototypes, testing
Pro1,200,000€29Production apps
Scale4,000,000€49High-volume pipelines
Credit packs250,000 to 3,500,000, never expirefrom €7Bursty or unpredictable load

Prochaines étapes

L’implémentation Python complète tient en moins de 30 lignes. L’offre gratuite suffit pour développer et tester une intégration complète avant de dépenser le moindre centime.

Obtenez votre clé API à l’adresse audexum.com/signup et consultez Référence de l’API pour obtenir la liste complète des paramètres, notamment les réglages de vitesse, de hauteur et de format de sortie.


Par Petar, fondateur d’Audexum. Exploiter un SaaS TTS autofinancé donne de solides convictions sur la conception des API.

Got any questions left?

Partager votre avis

Cet article vous a-t-il été utile ?

Article suivantAPI multilingue de synthèse vocale : 33 langues avec un seul endpoint REST (2026)

Commencez gratuitement. Sans carte bancaire.

2,000 crédits pour commencer, 250 par jour.