TTS-API-Schlüssel in Python: Einrichtung, Streaming, JSON-Modus

Prüfe, was der Schlüssel öffnet

Wer nach einem tts api key python Beispiel sucht, will Text meist in gesprochene Audio umwandeln. Der Schlüssel dieses Dienstes macht das nicht. Er authentifiziert Anfragen an ein Text-LLM: POST /v1/chat/completions und GET /v1/models, unter Verwendung des Modells uncensored. Es gibt keine Sprachsynthese, kein Audio-Upload und keine Embeddings.

Wenn das zu deinem Projekt passt, zum Beispiel weil du Skripte, Dialoge oder Erzählungen generierst, die du an ein separates Speech-Tool übergibst, findest du hier den restlichen funktionierenden Python-Code. Wenn du Audio-Ausgabe direkt aus der API benötigst, ist dies der falsche Dienst, und es ist besser, das jetzt zu wissen. Die Docs listen die genauen Features auf.

Ein praktischer Weg, Textgenerierung in einem Audioprojekt zu nutzen, ist, sie als Schreibphase zu behandeln. Das Modell entwirft die Narration, formuliert eine Zeile um, damit sie in ein Zeitlimit passt, oder macht aus Notizen einen Dialog mit mehreren Sprechern. Dein Python-Code übergibt den fertigen Text dann an das Speech-Tool deiner Wahl. Getrennte Phasen bedeuten auch, dass du eine davon austauschen kannst, ohne die andere anzufassen, und du zahlst dieser API nur für die Wörter, die sie schreibt.

Um mitzumachen, benötigst du Python 3.9 oder neuer und einen Schlüssel. Melde dich auf der API-Schlüssel-Seite an und sichere dir das One-Click-Testguthaben von $0,50; es gilt 7 Tage und benötigt keine Karte.

Speichere den Schlüssel und installiere das Paket

Schreibe den Schlüssel niemals in eine Datei, die du eincheckst. Lege ihn in einer Umgebungsvariable ab und lese ihn zur Laufzeit aus.

Copy# base URL used below: https://api.ttsapihub.com/v1 , model: uncensored
pip install openai
export API_KEY="paste-your-key-here"

Unter PowerShell ist dies $env:API_KEY = "paste-your-key-here". Für Projekte ist eine .env-Datei üblich, solange .env in .gitignore steht.

Wenn ein Schlüssel in einem Repository landet, behandle ihn als verbraucht: Entferne ihn aus der Historie, wenn du kannst, und fordere einen neuen an. Denke daran, dass Schlüssel das vorausbezahlte Guthaben verbrauchen, daher ist ein geleakter Schlüssel auch ein finanzieller Leak.

Erstelle den Client und führe den ersten Aufruf aus

Das offizielle Paket akzeptiert ein base_url. Alles andere ist die übliche OpenAI-Aufrufstruktur.

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.ttsapihub.com/v1",
    api_key=os.environ["API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You write short narration scripts."},
        {"role": "user", "content": "Draft a 40-word intro for a podcast about night trains."},
    ],
    temperature=0.8,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

Das usage-Objekt zeigt, wie viele Token die Anfrage verbraucht hat, damit du die Kosten berechnen kannst: Input-Token mal $0,15 pro Million, plus Output-Token mal $0,50 pro Million. Wenn die obige Anfrage 60 Input-Token und 80 Output-Token verwendet hat, betragen die Kosten $0,000009 plus $0,00004, also $0,000049. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet.

max_tokens ist optional. Ohne diesen Parameter kann die Antwort den Rest des 100.000-Token-Kontextfensters nutzen. Setze ihn, wenn du eine harte Grenze für Länge und Kosten festlegen möchtest.

Antwort streamen

Streaming gibt Token über Server-Sent Events zurück. Setze stream=True und iteriere.

Copyimport os
from openai import OpenAI

client = OpenAI(base_url="https://api.ttsapihub.com/v1", api_key=os.environ["API_KEY"])

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Describe a rainy station platform in four sentences."}],
    stream=True,
)

parts = []
for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta.content or ""
    parts.append(delta)
    print(delta, end="", flush=True)

text = "".join(parts)

Die Prüfung auf eine leere choices-Liste ist vorhanden, weil das letzte Event eines Streams Nutzdaten und keinen Text enthalten kann. Das Überspringen verhindert einen Indexfehler. Ein operativer Hinweis: Eine gestreamte Anfrage belegt ihren Concurrency-Slot, bis der Stream endet. Wenn du viele Streams in Threads startest und sie nie vollständig ausliest, erreichst du das Concurrency-Limit, auch wenn deine Request-Rate niedrig ist.

Fordere JSON an und rufe Tools auf

JSON-Modus

Setze response_format auf ein JSON-Objekt. Sage dem Modell im Prompt auch, dass du JSON willst; die Einstellung begrenzt das Format, der Prompt die Struktur.

Copyimport json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.ttsapihub.com/v1", api_key=os.environ["API_KEY"])

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"title\": str, \"beats\": [str]}"},
        {"role": "user", "content": "Outline a three-beat radio drama about a lost key."},
    ],
)

data = json.loads(resp.choices[0].message.content)
print(data["title"], len(data["beats"]))

Umschließe json.loads trotzdem mit einem try-Block. Eine Antwort, die max_tokens erreicht, kann mitten in einem Objekt abgeschnitten werden.

Function Calling

Übergib tools und optional tool_choice. Wenn das Modell ein Tool anfordert, führe es selbst aus und sende das Ergebnis als Nachricht mit role: "tool" zurück.

Copyimport json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.ttsapihub.com/v1", api_key=os.environ["API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "word_count",
        "description": "Count the words in a text",
        "parameters": {
            "type": "object",
            "properties": {"text": {"type": "string"}},
            "required": ["text"],
        },
    },
}]

messages = [{"role": "user", "content": "How many words are in: the quick brown fox?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = len(args["text"].split())
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": str(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

Führe ein Gespräch und behalte den Token-Budget im Blick

Die API ist zustandslos. Für ein Chat-Gedächtnis speicherst du die Nachrichtenliste im Programm und sendest sie bei jedem Aufruf. Eine kleine Klasse kapselt dies und begrenzt die Historie, um Kosten zu kontrollieren.

Copyimport os
from openai import OpenAI

client = OpenAI(base_url="https://api.ttsapihub.com/v1", api_key=os.environ["API_KEY"])

history = [{"role": "system", "content": "You are a dialogue writer. Keep replies under 120 words."}]

def say(user_text, keep_last=12):
    history.append({"role": "user", "content": user_text})
    # keep the system message plus the most recent turns
    trimmed = [history[0]] + history[1:][-keep_last:]
    resp = client.chat.completions.create(model="uncensored", messages=trimmed, max_tokens=250)
    reply = resp.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply, resp.usage.total_tokens

print(say("Open a scene in a ticket office at closing time.")[0])

Das Beschneiden ist wichtiger für das Geld als für das Fenster. Das Modell akzeptiert bis zu 100.000 Token insgesamt, aber wenn jede Runde 30.000 Token Historie erneut sendet, kostet jede Anfrage allein im Input $0,0045 (30.000 mal $0,15 pro Million). Fünfzig solcher Runden summieren sich auf $0,225, bevor ein einzelner Output-Token gezählt wird. Die letzten Dutzend Runden zu behalten oder ältere in eine kurze Zusammenfassung zu fassen, hält die Qualität meist und senkt die Rechnung scharf.

Concurrency ist der andere Punkt, den du einplanen solltest. Wenn dein Programm mehrere Nutzer gleichzeitig bedient, bewahrt dich ein Semaphor, das auf das Limit deines Schlüssels ausgelegt ist (8 für einen Vollschlüssel, 2 für einen Trial-Schlüssel), davor, den concurrency-Fehler auszulösen. Anfragen über dem Limit warten in deiner eigenen Warteschlange, statt zu scheitern, was freundlicher ist als ein Retry bei 429.

Tests sind ebenfalls wichtig. Schreibe ein kleines Skript, das die API mit einem festen seed, einer niedrigen Temperatur und einem kurzen max_tokens aufruft, und führe es aus, wenn du Prompts oder Einstellungen änderst. Ein Seed und eine niedrige Temperatur machen die Ausgabe wiederholbarer, sodass du zwei Prompt-Versionen ohne Störfaktoren vergleichen kannst. Halte diese Tests klein; ein Test, der einen Bruchteil eines Cents kostet, kann bei jedem Commit ausgeführt werden, ohne dass die Kosten ins Gewicht fallen.

Logge schließlich die Request-ID jeder Antwort. Bei Problemen ist dies der schnellste Weg, Support auf die genaue Anfrage zu verweisen.

Limits, Fehler und Kontostand behandeln

Ein Vollschlüssel erlaubt 8 gleichzeitige Anfragen und 300 Anfragen pro Minute. Der Trial-Schlüssel erlaubt 2 und 60. Das Überschreiten des ersten gibt HTTP 429 mit dem Fehlercode concurrency zurück, und das Überschreiten des zweiten gibt 429 mit rate_limited zurück. Temporäre Überlastung gibt ebenfalls 429 mit einem Retry-After: 5-Header zurück.

Das OpenAI-Paket wiederholt einige Fehler automatisch, und du kannst dies mit max_retries erhöhen. Füge für einen Batch-Job auch eine eigene Begrenzung für parallele Arbeit hinzu, damit du unter dem Concurrency-Limit bleibst, anstatt dich auf Wiederholungen zu verlassen.

Copyimport os
from openai import OpenAI, RateLimitError

client = OpenAI(base_url="https://api.ttsapihub.com/v1", api_key=os.environ["API_KEY"], max_retries=3)

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "One sentence about trains."}],
    max_tokens=60,
)
print("balance:", raw.headers.get("X-Balance-USD"))
print("request id:", raw.headers.get("X-Request-Id"))
print(raw.parse().choices[0].message.content)

Die Antwort-Header X-Request-Id und X-Balance-USD sind nützlich in Logs. Nenne die Request-ID, wenn du den Support kontaktierst. Die Kosten findest du auf der Preisseite: $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token, mit Aufladungen von $20 bis $500 und Boni von 5 %, 10 % und 15 % bei $50, $100 und $200. Akzeptiert werden Karte (Visa, Mastercard, Apple Pay, Google Pay) und Krypto (USDT auf TRC20, USDC auf Base). Prompts werden nicht zum Training verwendet. Das Modell ist für die rechtmäßige Nutzung durch Erwachsene gedacht, und sexuelle Inhalte mit Minderjährigen sind jederzeit untersagt.

Weitere Anleitungen

• Kostenlose API für SillyTavern: Testguthaben und Einrichtung
• TTS API Base URL: Was es ist und was du eingeben musst
• Elevenlabs API-Checkliste: Unzensierte TTS-Pipeline