Die meisten Teams zahlen zu viel für AI API-Aufrufe. Nicht, weil sie das falsche Modell gewählt haben, sondern weil sie drei Optimierungen ignorieren, die nur minimale Code-Änderungen erfordern: Prompt Caching, smartes Model Routing und Batch Processing.
Hier ist eine Aufschlüsselung jeder Technik mit realen Zahlen.
Wenn Sie noch entscheiden, ob Ihr aktueller Provider-Mix das Problem ist, lesen Sie zuerst den Preisvergleich. Wenn Ihr größtes Problem Retry-Storms oder Provider-Throttling statt der reinen Ausgaben sind, kombinieren Sie diese Seite mit dem Rate Limiting Guide.
1. Prompt Caching: Der größte Gewinn
Wenn Ihre Anwendung bei jeder Anfrage denselben System-Prompt sendet, zahlen Sie den vollen Preis für Token, die der Provider bereits verarbeitet hat.
Wie es funktioniert
OpenAI speichert Prompts automatisch für Eingaben über 1.024 Token zwischen. Gecachte Token kosten 50 % des Standard-Input-Preises. Sie müssen an Ihrem Code nichts ändern.
Anthropic nutzt explizites Caching über cache_control Breakpoints. Die Schreibkosten sind 25 % höher als beim Standard-Input, aber das Lesen kostet 90 % weniger. Die Cache-TTL beträgt 5 Minuten und verlängert sich bei jedem Treffer.
Bei der neueren Preisgestaltung von OpenAI kann der praktische Rabatt höher ausfallen, als Teams erwarten. GPT-4.1 gecachter Input wird mit einem Viertel des Standard-Inputs berechnet, was bedeutet, dass konsistente Präfixe viel größere Einsparungen ermöglichen, als der alte „Nice-to-have“-Ansatz vermuten ließ.
Die Rechnung
Nehmen wir einen typischen Kundensupport-Bot:
- System-Prompt: 2.000 Token
- User-Message: durchschnittlich 200 Token
- 5.000 Anfragen/Tag mit Claude Sonnet 4.6
Ohne Caching:
Tägliche Input-Kosten = 5.000 × 2.200 Token × $3.00/1M = $33.00
Mit Anthropic Prompt Caching (bei einer angenommenen Cache-Hit-Rate von 95 %):
Cache-Writes: 250 × 2.200 × $3.75/1M = $2.06
Cache-Reads: 4.750 × 2.200 × $0.30/1M = $3.14
User-Token: 5.000 × 200 × $3.00/1M = $3.00
Täglich gesamt = $8.20 (75 % Ersparnis bei den Input-Kosten)
Implementierung
from anthropic import Anthropic
client = Anthropic(
api_key="sk-lemon-xxx",
base_url="https://api.lemondata.cc"
)
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
system=[
{
"type": "text",
"text": "You are a customer support agent for Acme Corp...",
"cache_control": {"type": "ephemeral"} # Dies aktiviert das Caching
}
],
messages=[{"role": "user", "content": user_message}]
)
# Überprüfen Sie die Cache-Performance in den Response-Headern
# cache_creation_input_tokens vs cache_read_input_tokens
Bei OpenAI-Modellen erfolgt das Caching automatisch. Stellen Sie einfach sicher, dass Ihre Prompts 1.024 Token überschreiten und halten Sie das statische Präfix über alle Anfragen hinweg konsistent.
Wo Teams Fehler machen:
- Zeitstempel oder Request-IDs an den Anfang jedes Prompts setzen
- Systemanweisungen bei jedem Aufruf neu anordnen
- Variablen Benutzerkontext vor dem stabilen Präfix einbetten
Wenn sich das Präfix jedes Mal ändert, hilft der Cache nie. Betrachten Sie die Prompt-Struktur als Kostenfaktor, nicht nur als Detail des Prompt Engineering.
2. Smartes Model Routing: Nutzen Sie das richtige Modell für jede Aufgabe
Nicht jede Anfrage benötigt Ihr teuerstes Modell. Eine Klassifizierungsaufgabe, die GPT-4.1 für 2,00 $/1M Input-Token erledigt, funktioniert genauso gut mit GPT-4.1-mini für 0,40 $/1M – eine 5-fache Kostenreduktion.
Die Routing-Strategie
| Aufgabentyp | Empfohlenes Modell | Input-Kosten/1M |
|---|---|---|
| Komplexes Reasoning | Claude Opus 4.6 / GPT-4.1 | $5.00 / $2.00 |
| Allgemeiner Chat | Claude Sonnet 4.6 / GPT-4.1 | $3.00 / $2.00 |
| Klassifizierung, Extraktion | GPT-4.1-mini / Claude Haiku 4.5 | $0.40 / $1.00 |
| Embeddings | text-embedding-3-small | $0.02 |
| Einfache Formatierung | DeepSeek V3 | $0.28 |
Implementierung
from openai import OpenAI
client = OpenAI(
api_key="sk-lemon-xxx",
base_url="https://api.lemondata.cc/v1"
)
def route_request(task_type: str, messages: list) -> str:
"""Wählt das günstigste Modell, das diese Aufgabe gut bewältigt."""
model_map = {
"classification": "gpt-4.1-mini",
"extraction": "gpt-4.1-mini",
"summarization": "gpt-4.1-mini",
"complex_reasoning": "gpt-4.1",
"creative_writing": "claude-sonnet-4-6",
"code_generation": "claude-sonnet-4-6",
}
model = model_map.get(task_type, "gpt-4.1-mini")
response = client.chat.completions.create(
model=model,
messages=messages
)
return response.choices[0].message.content
Reale Einsparungen
Ein Coding-Assistent, der 60 % der Anfragen (Linting, Formatierung, einfache Vervollständigungen) an GPT-4.1-mini und 40 % (Architektur, Debugging) an Claude Sonnet 4.6 leitet:
Vorher (alles Claude Sonnet 4.6):
1.000 Anfr./Tag × 3K Input × $3.00/1M = $9.00/Tag
Nachher (60/40 Split):
600 Anfr. × 3K × $0.40/1M = $0.72/Tag (mini)
400 Anfr. × 3K × $3.00/1M = $3.60/Tag (sonnet)
Gesamt = $4.32/Tag (52 % Ersparnis)
3. Batch Processing: Niedrigere Preise für nicht dringende Aufgaben
OpenAI bietet eine Batch API mit 50 % Rabatt auf Input- und Output-Token an. Der Kompromiss: Ergebnisse werden innerhalb von 24 Stunden geliefert statt in Echtzeit.
Anthropic bietet ebenfalls 50 % Batch-Rabatte auf unterstützte Modelle an. Wenn Ihre Arbeitslast über Nacht, asynchron oder prüfungsorientiert ist, gibt es selten einen guten Grund, Echtzeitpreise zu zahlen.
Gute Kandidaten für Batching:
- Nächtliche Content-Generierung
- Massen-Dokumentenklassifizierung
- Dataset-Labeling
- Geplante Berichterstellung
# Erstellen einer Batch-Datei (JSONL-Format)
import json
requests = []
for i, doc in enumerate(documents):
requests.append({
"custom_id": f"doc-{i}",
"method": "POST",
"url": "/v1/chat/completions",
"body": {
"model": "gpt-4.1-mini",
"messages": [
{"role": "system", "content": "Classify this document..."},
{"role": "user", "content": doc}
]
}
})
# JSONL-Datei schreiben
with open("batch_input.jsonl", "w") as f:
for req in requests:
f.write(json.dumps(req) + "\n")
# Batch einreichen
batch_file = client.files.create(file=open("batch_input.jsonl", "rb"), purpose="batch")
batch = client.batches.create(input_file_id=batch_file.id, endpoint="/v1/chat/completions", completion_window="24h")
Gute Kandidaten für Batching innerhalb eines realen Produkts:
- Nächtliche Jobs zur Inhaltsaktualisierung
- Zusammenfassung von Support-Tickets
- Backfills von Embeddings
- Überprüfungen großer Codebasen oder Dokumente
- Benachrichtigungen mit niedriger Priorität
Schlechte Kandidaten:
- Chat-Antworten
- Interaktive Coding-Unterstützung
- Workflows, bei denen die nächste Benutzeraktion sofort von der Antwort abhängt
4. Bonus: Token-Anzahl reduzieren
Bevor Sie auf API-Ebene optimieren, prüfen Sie, ob Sie mehr Token als nötig senden.
Häufige Verschwendung:
- Weitschweifige System-Prompts, die Anweisungen wiederholen, die das Modell bereits befolgt
- Einbeziehung des vollständigen Konversationsverlaufs, wenn nur die letzten 3-5 Runden wichtig sind
- Senden von rohem HTML/Markdown, wenn einfacher Text ausreichen würde
- Nicht-Verwendung von
max_tokens, um die Output-Länge zu begrenzen
Eine Reduzierung der Prompt-Länge um 30 % führt direkt zu 30 % niedrigeren Input-Kosten.
Der einfachste Weg, Verschwendung zu finden, besteht darin, die Prompt-Länge nach Route oder Feature zu protokollieren. Die meisten Teams haben kein Problem mit der Modell-Preisgestaltung. Sie haben ein Problem damit, dass „derselbe aufgeblähte Prompt 100.000 Mal am Tag gesendet wird“.
5. Kostentransparenz schaffen, bevor Sie blind optimieren
Kostenoptimierung scheitert, wenn Teams nach Intuition optimieren.
Bevor Sie Routing-Regeln ändern, protokollieren Sie:
- Route oder Feature-Name
- Modell
- Input-Token
- Output-Token
- Cache Hit oder Miss
- Retry-Anzahl
- Für den Benutzer sichtbare Latenz
Dadurch können Sie die entscheidenden Fragen beantworten:
- Welche Route ist teuer, weil sie wirklich nützlich ist?
- Welche Route ist teuer, weil der Prompt verschwenderisch ist?
- Welche Route sollte auf Batch umgestellt werden?
- Welche Route sollte auf eine günstigere Modell-Stufe verschoben werden?
Wenn Sie diese vier Fragen nicht beantworten können, wird Ihre „Kostenoptimierung“ die Kosten nur verschieben.
6. Eine sinnvolle Optimierungsreihenfolge
Die effektivste Reihenfolge ist normalerweise:
- Offensichtliche Token-Verschwendung entfernen.
- Caching aktivieren oder korrigieren.
- Günstige Aufgaben von teuren Aufgaben trennen.
- Alles Nicht-Dringende per Batch verarbeiten.
- Erst dann den Provider-Mix neu verhandeln.
Diese Reihenfolge ist wichtig, da die größten Einsparungen oft vor dem Provider-Wechsel erzielt werden. Wenn Sie den Anbieter wechseln, ohne die Prompt-Struktur zu korrigieren, zahlen Sie weiterhin für dieselbe Ineffizienz.
7. Ein konkreter Vorher-Nachher-Rollout
Nehmen wir einen Support-Workflow, der derzeit bei jeder Anfrage Folgendes tut:
- sendet einen 2.000-Token System-Prompt
- ruft ein Premium-Modell für alle Anfragen auf
- wiederholt dieselbe Prompt-Struktur bei temporären Fehlern
- führt nächtliche Zusammenfassungen synchron statt im Batch aus
Die erste Version fühlt sich oft „einfach“ an, weil sie nur einen Codepfad hat. Finanziell gesehen macht sie vier teure Dinge gleichzeitig.
Ein effizienterer Rollout sieht so aus:
- Verschieben Sie den stabilen Richtlinientext an den Anfang des Prompts, damit das Caching tatsächlich greifen kann.
- Routen Sie Klassifizierung, Extraktion und kurze Zusammenfassungen an eine günstigere Modell-Stufe.
- Reservieren Sie das Premium-Modell für Eskalationen, kompliziertes Reasoning oder die finale Antwortsynthese.
- Verschieben Sie nächtliche Zusammenfassungen und Backfills in den Batch.
- Überprüfen Sie wöchentlich die Logs auf Routen, deren Prompt-Struktur sich verändert hat und die Cache-Effizienz beeinträchtigt.
Diese Art von Rollout erfordert kein Rewrite. Er erfordert eine Woche Instrumentierung und die Bereitschaft, Prompts und Routing als produktionsrelevante Oberflächen zu behandeln.
8. Was Sie vermeiden sollten
Der schnellste Weg, eine Kostenoptimierung zu ruinieren, besteht darin, das Falsche zu optimieren.
Vermeiden Sie diese Fallen:
- Provider wechseln, bevor Sie die Prompt-Verschwendung gemessen haben
- Günstige Aufgaben an günstige Modelle routen, ohne die Output-Qualität zu validieren
- Caching für Prompts aktivieren, deren Präfixe sich bei jeder Anfrage ändern
- Benutzerorientierte Aufgaben per Batch verarbeiten, die eigentlich Echtzeit-Antworten benötigen
- Nur auf den Token-Preis schauen und Retry-, Latenz- und Fallback-Overhead ignorieren
Kostenoptimierung ist dann erfolgreich, wenn das Produkt nach den Einsparungen immer noch gut funktioniert. Wenn sich die UX verschlechtert, ist der Gewinn auf dem Papier wertlos.
Alles zusammengefasst
| Technik | Aufwand | Typische Ersparnis |
|---|---|---|
| Prompt Caching | Niedrig (cache_control hinzufügen) | 40-75 % auf Input |
| Model Routing | Mittel (Aufgaben klassifizieren) | 30-50 % insgesamt |
| Batch Processing | Mittel (asynchroner Workflow) | 50 % auf Batch-Jobs |
| Token-Reduzierung | Niedrig (Prompts kürzen) | 10-30 % auf Input |
Diese Techniken ergänzen sich. Ein Team, das alle vier implementiert, kann seine monatliche API-Rechnung realistischerweise von 3.000 $ auf unter 1.000 $ senken, ohne die Output-Qualität zu beeinträchtigen.
Die wichtigste Erkenntnis: Kostenoptimierung bei AI APIs geht nicht darum, günstigere Provider zu finden. Es geht darum, das richtige Modell in der richtigen Preisstufe mit der richtigen Caching-Strategie für jede spezifische Aufgabe einzusetzen.
Wenn Sie bereits mehrere Provider nutzen, spielt auch die operative Seite eine Rolle. Der Migration Guide und der OpenRouter-Vergleich helfen bei der Entscheidung, wann es Zeit ist, das Routing zu zentralisieren, anstatt separate Integrationen weiter zu flicken.
Beginnen Sie noch heute mit der Optimierung: LemonData bietet Ihnen Zugriff auf über 300 Modelle über einen einzigen API-Key, mit Prompt-Caching-Unterstützung für OpenAI- und Anthropic-Modellfamilien und einem zentralen Ort, um die Nutzung über alle hinweg zu vergleichen.