Free Tier, API-Preise, typische Abrechnungsfallen und ab wann sich der ROI wirklich rechnet
SerieGoogle AI / Gemini im Freelancer-Alltag
Teil 14 von 16
Google AI klingt nach Free Tier und günstigen API-Preisen – stimmt auch, bis zu einem Punkt. Dieser Artikel schlüsselt die tatsächlichen Kostenmodelle auf: was kostenlos ist, wo die Limits greifen, welche typischen Fehler zu unerwarteten Abrechnungen führen, und ab wann sich der ROI gegenüber einer manuellen Lösung wirklich rechnet. Kein Hype, kein Kleingedrucktes übersehen – nur ein ehrlicher Blick auf das, was es kostet.
Das Preismodell verstehen
Die Abrechnungseinheit bei allen großen KI-APIs ist das Token. Ein Token entspricht grob 0,75 englischen Wörtern oder etwa 3 bis 4 Zeichen. Ein Satz hat typischerweise 20 bis 30 Tokens, eine Seite Fließtext etwa 400 bis 600 Tokens.
Entscheidend ist die Unterscheidung zwischen Input-Tokens (alles, was du an das Modell schickst: Prompt, Kontext, Dokumente) und Output-Tokens (alles, was das Modell zurückliefert). Output-Tokens sind immer teurer als Input-Tokens – bei Gemini 2.5 Pro je nach Kontextgröße etwa vier bis acht Mal so teuer.
Was kostet ein typischer API-Call? Ein mittelgroßer Prompt von 500 Tokens mit einer Antwort von 300 Tokens kostet bei Gemini 2.5 Flash unter einem halben Cent. Wer aber ein 50.000-Token-Dokument analysiert und dabei einen langen System-Prompt vorausschickt, landet bei 20 bis 50 Cent – pro Aufruf. Bei 200 solchen Aufrufen pro Monat sind das 40 bis 100 Euro, nur für diesen einen Workflow.
Die Preisunterschiede zwischen den Modellen sind erheblich:
| Modell | Input (pro 1M Tokens) | Output (pro 1M Tokens) | Kontextfenster |
|---|---|---|---|
| Gemini 2.5 Flash | ~0,15 $ | ~0,60 $ | 1M Token |
| Gemini 2.5 Pro (bis 200K) | ~1,25 $ | ~10,00 $ | 1M Token |
| Gemini 2.5 Pro (über 200K) | ~2,50 $ | ~15,00 $ | 1M Token |
Free Tier: Was wirklich kostenlos ist
Google AI Studio bietet einen kostenlosen Zugang zur Gemini API. Die Rate Limits des Free Tiers (Stand Anfang 2026):
| Limit | Gemini 2.5 Flash | Gemini 2.5 Pro |
|---|---|---|
| Anfragen pro Minute (RPM) | 15 | 5 |
| Anfragen pro Tag (RPD) | 1.500 | 25 |
| Tokens pro Minute (TPM) | 1 Mio. | 250.000 |
Für erste Tests, für die Entwicklung von Prompts und für Prototypen reicht das vollständig. Für produktive Workflows, die regelmäßig mehr als einige Dutzend Anfragen täglich absetzen, wird es eng – spätestens bei 25 Pro-Anfragen täglich ist Schluss.
Was beim Free Tier passiert: Google nutzt die über den kostenlosen Zugang eingereichten Daten für das Modelltraining. Das steht in den Nutzungsbedingungen. Für öffentliche Informationen oder persönliche Texte mag das irrelevant sein – für Kundendaten, vertrauliche Geschäftsinformationen oder personenbezogene Daten nach DSGVO ist der Free Tier nicht geeignet.
Die vier häufigsten Abrechnungsfallen
Falle 1: Großer Kontext ohne Caching
Gemini 2.5 Pro unterstützt bis zu einer Million Tokens Kontext. Das ist nützlich – und teuer, wenn man es falsch nutzt. Wer ein 200-seitiges Dokument bei jedem einzelnen API-Call neu mitschickt, zahlt für dieses Dokument bei jedem Call Input-Kosten von rund 25 bis 50 Cent. Bei 50 Anfragen am Tag sind das 12 bis 25 Euro täglich – nur für das wiederholte Einlesen desselben Dokuments.
Die Lösung heißt Context Caching: Inhalte, die sich nicht verändern (Systemanweisungen, Dokumente, Wissensbasis), können gecacht werden. Gecachte Tokens kosten etwa ein Viertel der normalen Input-Preise und werden pro Stunde Speicherhaltung berechnet. Bei vielen Anfragen gegen denselben Kontext ist das ein erheblicher Kostenunterschied.
Falle 2: Kein Rate Limiting im eigenen Code
Wer die Gemini API in ein Skript einbaut und vergisst, Limits zu setzen, riskiert unkontrollierten API-Verbrauch. Ein einfacher Loop über 10.000 Datensätze ohne Throttling kann innerhalb von Minuten ein dreistelliges Budget verbrennen – und das, obwohl die Anfragen technisch erfolgreich verarbeitet werden.
import time
def call_gemini_with_rate_limit(model, prompt: str, calls_per_minute: int = 10):
"""API-Call mit eingebautem Rate Limiting."""
min_wait = 60 / calls_per_minute
start = time.time()
response = model.generate_content(prompt)
elapsed = time.time() - start
if elapsed < min_wait:
time.sleep(min_wait - elapsed)
return responseFalle 3: Flash und Pro verwechseln
Gemini 2.5 Flash kostet im Output etwa ein Sechzehntel von Gemini 2.5 Pro. Wer im Produktionscode versehentlich gemini-2.5-pro statt gemini-2.5-flash einträgt, zahlt das Vielfache. Das passiert häufiger als man denkt – besonders wenn der Modellname aus einem Testskript übernommen wird, das für Pro geschrieben war.
Faustregel: Entwickeln und testen mit Flash. Auf Pro wechseln, wenn die Qualität von Flash für den konkreten Use Case nicht ausreicht.
Falle 4: Testläufe gegen die Produktions-API
Wer beim Entwickeln direkt gegen die bezahlte API testet statt AI Studio Free Tier zu verwenden, zahlt für jeden missglückten Versuch. Bei 50 Iterationen eines neuen Prompts mit großem Kontext summiert sich das schnell auf zweistellige Beträge.
Der richtige Workflow: zuerst in AI Studio testen (Free Tier, Limits beachten), dann in den Code übertragen und dort zunächst mit kleinen Datenmengen verifizieren.
Budget-Kontrolle einbauen
Google Cloud Budget Alerts
In der Google Cloud Console unter „Billing” → „Budgets & alerts” lässt sich ein monatliches Budget festlegen. Ab einem bestimmten Verbrauchsprozentsatz (zum Beispiel 50 % und 90 %) wird automatisch eine E-Mail verschickt. Kein Code notwendig, fünf Minuten Einrichtungsaufwand, verhindert böse Überraschungen.
Token-Counting vor dem API-Call
Die Gemini API bietet count_tokens() – eine Methode, die ohne Modellaufruf und damit kostenlos die Tokenzahl berechnet.
import google.generativeai as genai
genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel("gemini-2.5-pro")
def check_token_budget(prompt: str, max_input_tokens: int = 10000) -> bool:
"""Gibt True zurück, wenn der Aufruf im Tokenbudget liegt."""
count = model.count_tokens(prompt)
total = count.total_tokens
print(f"Geschätzte Input-Tokens: {total}")
if total > max_input_tokens:
print(f"WARNUNG: {total} Tokens überschreiten Budget von {max_input_tokens}")
return False
return True
# Vor dem eigentlichen Aufruf prüfen
prompt = "Dein Prompt hier..."
if check_token_budget(prompt):
response = model.generate_content(prompt)ROI-Kalkulation: Wann lohnt sich die API?
Zahlen helfen hier mehr als Theorie. Beispiel: 100 Produktbeschreibungen für einen E-Commerce-Kunden.
Manuelle Variante:
- Zeit pro Beschreibung: ca. 10 Minuten (Recherche, Schreiben, Prüfen)
- Gesamtaufwand: 100 × 10 Minuten = ca. 17 Stunden
- Stundensatz 80 €: 1.360 €
Mit Gemini API:
- Einmaliger Setup-Aufwand (Prompt entwickeln, Skript schreiben, testen): ca. 2 Stunden = 160 €
- API-Kosten: 100 Calls, je ca. 800 Input-Tokens + 300 Output-Tokens mit Gemini 2.5 Flash: ca. 1,50 €
- Nachbearbeitung und Qualitätsprüfung: ca. 1 Stunde = 80 €
- Gesamt: ca. 242 €
Das klingt eindeutig – und ist es auch, wenn die Bedingungen stimmen.
Wann die Rechnung aufgeht:
- Der Prompt ist stabil und liefert konsistent verwertbare Ergebnisse
- Die Nachbearbeitung bleibt überschaubar (unter 30 % manueller Anteil)
- Die Aufgabe ist repetitiv und lässt sich mit einem Template abbilden
- Die Menge ist groß genug, um den Setup-Aufwand zu amortisieren (ab ca. 20 bis 30 Einheiten)
Wann sie es nicht tut:
- Jede Beschreibung erfordert individuelle Recherche, die das Modell nicht leisten kann
- Die Qualitätsanforderungen sind so hoch, dass fast jede Ausgabe überarbeitet werden muss
- Bei kleinen einmaligen Mengen unter 15 bis 20 Einheiten ist der Setup-Aufwand nicht amortisiert
Qualitätskosten einrechnen: Wer 30 % aller Outputs überarbeitet – je 5 Minuten – hat bei 100 Beschreibungen zusätzlich 2,5 Stunden = 200 € eingeplant. Der API-Ansatz ist dann immer noch deutlich günstiger, aber der Unterschied schrumpft. Bei 80 % Überarbeitungsquote ist der Vorteil weg.
Vergleich: Gemini API vs. OpenAI vs. Anthropic (Kosten)
Für eine realistische Einschätzung: ungefähre Preise der relevanten Modelle, Stand Frühjahr 2026 (US-Dollar pro Million Tokens, gerundet):
| Modell | Anbieter | Input | Output | Kontextfenster |
|---|---|---|---|---|
| Gemini 2.5 Flash | ~0,15 $ | ~0,60 $ | 1M Token | |
| Gemini 2.5 Pro | ~1,25 $ | ~10,00 $ | 1M Token | |
| GPT-4o mini | OpenAI | ~0,15 $ | ~0,60 $ | 128K Token |
| GPT-4o | OpenAI | ~2,50 $ | ~10,00 $ | 128K Token |
| Claude 3.5 Haiku | Anthropic | ~0,80 $ | ~4,00 $ | 200K Token |
| Claude 3.7 Sonnet | Anthropic | ~3,00 $ | ~15,00 $ | 200K Token |
| Mistral Small | Mistral | ~0,10 $ | ~0,30 $ | 128K Token |
| Mistral Large | Mistral | ~2,00 $ | ~6,00 $ | 128K Token |
Drei Beobachtungen:
Im günstigen Segment liegen Gemini 2.5 Flash, GPT-4o mini und Mistral Small eng beieinander. Für Volumenaufgaben mit vertretbarer Qualität ist das die erste Wahl.
Beim Kontextfenster hat Gemini 2.5 Pro einen klaren Vorteil: eine Million Tokens zu einem wettbewerbsfähigen Preis, solange der Kontext unter 200.000 Tokens bleibt. Für Dokumentenanalyse und Codebase-Auswertung ist das relevant.
Bei den Spitzenmodellen liegen GPT-4o, Claude Sonnet und Gemini 2.5 Pro preislich nah beieinander. Hier sollte nicht der Preis die Entscheidung treffen, sondern die Fähigkeiten im konkreten Anwendungsfall – genau das betrachtet der nächste Artikel.
Die eigentliche Kostenformel
Viele Kalkulationen bleiben zu abstrakt, weil nur der Preis pro Million Tokens genannt wird. Für die Praxis ist eine einfachere Formel hilfreicher:
Gesamtkosten = API-Kosten + Setup-Zeit + Review-Zeit + Fehlerkosten
Die API-Kosten selbst sind oft der kleinste Block. Teurer wird es an anderer Stelle:
- wenn Prompts instabil sind und mehrfach nachgebessert werden müssen
- wenn 30 Prozent der Ergebnisse manuell überarbeitet werden
- wenn Fehlklassifikationen später operative Arbeit verursachen
- wenn lange Kontexte bei jedem Aufruf unnötig mitgeschickt werden
Deshalb lohnt sich nicht nur das Optimieren des Modells, sondern auch das Kürzen des Kontexts, das Vereinfachen des Outputs und das saubere Trennen von einmaligem Setup und laufender Nutzung.
Die wichtigste Einsicht ist oft ernüchternd: Nicht der API-Preis entscheidet über Wirtschaftlichkeit, sondern wie viel menschliche Arbeit nach dem Modell noch übrig bleibt.
Einordnung
Kosten sind eine Seite. Die andere ist die Frage, welches Modell für welche Aufgabe sinnvoller ist – und wo andere Anbieter Gemini klar übertreffen. Das betrachtet der nächste Artikel dieser Serie: ein realistischer Vergleich von Gemini, ChatGPT, Claude und Mistral anhand konkreter Freelancer-Szenarien – ohne Benchmarks aus dem Labor und ohne falsche Loyalitäten.