Vai al contenuto

Tutorial Python per l’API di sintesi vocale (2026): guida introduttiva ad Audexum

Audexum8 minBy Petar

Scopri come chiamare un’API di sintesi vocale in Python usando la libreria requests. Esempi di codice completi per la scelta della voce, l’output WAV, la gestione degli errori e il confronto dei prezzi.

L’integrazione della sintesi vocale in un progetto Python richiede meno di 20 righe di codice. Questa guida spiega tutto: autenticazione, scelta della voce, salvataggio dell’output WAV, gestione degli errori e selezione del piano più adatto al tuo utilizzo.

Tutti gli esempi usano API TTS di Audexum, che supporta 43 voci in 32 lingue e offre un piano gratuito senza necessità di carta di credito.

Prerequisiti

Ti serve solo la libreria requests . Nessun SDK, nessun framework.

bash
pip install requests

Ottieni una chiave API gratuita su audexum.com/signup. Le chiavi seguono il formato sk_live_abc123xyz. Il piano gratuito ti offre 2.000 crediti gratuiti + 250 al giorno senza richiedere una carta di credito.

Prima chiamata API

L’endpoint accetta un corpo JSON con text, voice_id, e, a scelta, con language. Restituisce audio WAV grezzo.

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

Esegui il codice e otterrai output.wav nella directory corrente. Questa è un’implementazione completa e funzionante.

Scelta della voce

Audexum offre 43 voci in inglese americano, inglese britannico, spagnolo, francese, tedesco, giapponese, coreano, arabo, hindi, bulgaro, italiano, portoghese e altre lingue. Elenca le voci disponibili con una richiesta 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']}")

Esempio di output:

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

Passa la stringa voice_id direttamente nella richiesta di sintesi.

Salvataggio del file WAV

Il corpo della risposta è un WAV PCM grezzo: non è necessario decodificare il base64. Scrivilo su disco con le normali operazioni I/O sui file:

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

Se ti serve MP3 invece di WAV, passa "format": "mp3" nel corpo JSON.

Gestione degli errori

Gestisci esplicitamente i limiti di frequenza, le voci non valide e gli errori di autenticazione:

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

Riferimento dei codici di stato

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

Elaborazione batch

Per l’elaborazione batch di più stringhe, mantieni un piccolo ritardo tra le richieste per non superare il limite di frequenza:

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

Confronto dei prezzi

Prima di scegliere un piano, ecco come si confrontano le principali API TTS in base al prezzo per carattere:

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

Gli abbonati ai piani Audexum ottengono tariffe effettive da €9,93/1M (Business) a €24,17/1M (Pro). L’opzione PAYG a €28/1M crediti è utile per progetti con un volume imprevedibile, mentre i pacchetti di crediti una tantum non scadono mai.

Riepilogo dei piani

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

Prossimi passi

L’implementazione Python completa richiede meno di 30 righe. Il piano gratuito è sufficiente per sviluppare e testare un’integrazione completa prima di spendere qualsiasi somma.

Ottieni la tua chiave API su audexum.com/signup e consulta la Riferimento API per l’elenco completo dei parametri, inclusi i controlli di velocità, intonazione e formato di output.


Di Petar, fondatore di Audexum. Gestire un SaaS TTS autofinanziato dà opinioni molto nette sul design delle API.

Got any questions left?

Condividi feedback

Questo articolo ti è stato utile?

Articolo successivoAPI multilingue di sintesi vocale: 33 lingue con un unico endpoint REST (2026)

Inizia gratis. Nessuna carta.

2,000 crediti per iniziare, 250 in più ogni giorno.