Gemini API-kosten optimaliseren

Hoe Gemini-kosten werken

Je betaalt per miljoen tokens, waarbij invoer en uitvoer apart worden gefactureerd. De gratis tier van de Gemini Developer API geeft dagelijkse en minuutlimieten zonder kosten. Boven die gratis limieten betaal je per gebruik, zonder vast abonnement.

De kosten per call zijn opgebouwd uit:

• Input-tokens: alle tekst, afbeeldingen, audio en video die je meestuurt.
• Output-tokens: de gegenereerde tekst van het model (inclusief de redeneer- of thinking-tokens).
• Context cache storage: kosten per uur voor inhoud die je in de cache bewaart.
• Grounding queries: kosten per keer dat Google Search wordt aangeroepen.

Kostenvergelijking modellen

Onderstaande tarieven gelden voor de betaalde tier van de Gemini Developer API en zijn geverifieerd in juni 2026. Prijzen zijn in US-dollar per 1 miljoen tekst-tokens. Controleer de actuele pagina, want Google past tarieven en modellen geregeld aan.

Een paar dingen om op te letten:

• Kies het goedkoopste model dat genoeg kwaliteit levert. Voor de meeste taken volstaat Flash-Lite of een Flash-model; reserveer Pro voor taken die echt complexe redenering vereisen.
• Audio-input kost bij de meeste modellen meer dan tekst of beeld.
• Bij Gemini 2.5 Pro en 3.1 Pro gelden hogere tarieven zodra je prompt boven de 200.000 tokens uitkomt (bij 2.5 Pro stijgt input naar $2,50 en output naar $15,00 per 1M).
• Preview-modellen kunnen van prijs veranderen of uit preview gaan; gebruik ze bewust in productie.

Kosten monitoren in je applicatie

Houd per call het tokenverbruik bij via response.usage_metadata. Zo zie je precies waar je kosten ontstaan.

import os
from dataclasses import dataclass
from google import genai

TARIEVEN = {
    "gemini-3.1-flash-lite": {"input": 0.25 / 1_000_000, "output": 1.50 / 1_000_000},
    "gemini-2.5-pro": {"input": 1.25 / 1_000_000, "output": 10.00 / 1_000_000},
}

@dataclass
class KostenTracker:
    model_naam: str
    totaal_input_tokens: int = 0
    totaal_output_tokens: int = 0
    aantal_calls: int = 0

    def registreer(self, response):
        meta = response.usage_metadata
        self.totaal_input_tokens += meta.prompt_token_count
        self.totaal_output_tokens += meta.candidates_token_count
        self.aantal_calls += 1

    def kosten(self) -> dict:
        tarief = TARIEVEN.get(self.model_naam, {"input": 0, "output": 0})
        input_usd = self.totaal_input_tokens * tarief["input"]
        output_usd = self.totaal_output_tokens * tarief["output"]
        return {
            "input_usd": input_usd,
            "output_usd": output_usd,
            "totaal_usd": input_usd + output_usd,
            "calls": self.aantal_calls,
        }

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
MODEL = "gemini-3.1-flash-lite"
tracker = KostenTracker(MODEL)

for vraag in ["Wat is Python?", "Wat is AI?", "Wat is cloud computing?"]:
    response = client.models.generate_content(model=MODEL, contents=vraag)
    tracker.registreer(response)

kosten = tracker.kosten()
print(f"Totale kosten: ${kosten['totaal_usd']:.6f}")
print(f"Kosten per call: ${kosten['totaal_usd'] / kosten['calls']:.6f}")

Promptoptimalisatie voor lagere kosten

Kortere prompts zijn goedkoper. Vaak kun je flink inkorten zonder kwaliteitsverlies:

prompts = {
    "lang": (
        "Ik wil graag dat je me helpt met een taak. De taak is als volgt: "
        "ik heb een lijst met productnamen en ik wil graag een korte beschrijving "
        "van elk product. Kun je voor het product genaamd 'Bluetooth-hoofdtelefoon' "
        "een beschrijving schrijven? De beschrijving mag niet te lang zijn, "
        "maar moet wel informatief zijn."
    ),
    "kort": "Schrijf een beschrijving (2 zinnen) voor: Bluetooth-hoofdtelefoon",
}

Het lange voorbeeld telt ongeveer 80 input-tokens, het korte ongeveer 15. Bij 10.000 calls per dag op gemini-3.1-flash-lite is dat ruwweg $0,20 versus $0,04 aan input per dag, een besparing van rond de 80 procent. Bewaar vaste instructies bovendien in een system-instruction of cache in plaats van ze in elke prompt te herhalen.

Output-tokens beperken

Output-tokens kosten doorgaans meerdere keren zo veel als input-tokens. Begrens de uitvoer tot wat je use case echt nodig heeft:

from google.genai import types

response = client.models.generate_content(
    model="gemini-3.1-flash-lite",
    contents="Vat dit rapport samen in 3 bullets.",
    config=types.GenerateContentConfig(max_output_tokens=256),
)

Vraag het model expliciet om beknopt te antwoorden en zet max_output_tokens op een realistisch maximum.

Context caching voor herhaalde content

Stuur je telkens dezelfde grote context mee (handleidingen, kennisbankartikelen, een vaste system-context), dan is context caching een grote besparing. Gecachte tokens zijn fors goedkoper dan gewone input-tokens, maar je betaalt wel opslag per uur.

from google.genai import types

cache = client.caches.create(
    model="gemini-3.1-flash-lite",
    config=types.CreateCachedContentConfig(
        contents=[groot_handboek_tekst],
        system_instruction="Je bent een behulpzame assistent voor onze kennisbank.",
        ttl="86400s",
    ),
)

response = client.models.generate_content(
    model="gemini-3.1-flash-lite",
    contents="Wat zegt het handboek over retourbeleid?",
    config=types.GenerateContentConfig(cached_content=cache.name),
)
print(response.text)

Voor gemini-3.1-flash-lite kost een gecacht tekst-token ongeveer $0,025 per 1M tegenover $0,25 per 1M als gewone input, plus $1,00 per 1M tokens per uur opslag. Caching loont zodra je dezelfde grote context vaak genoeg per dag hergebruikt; reken het break-evenpunt door op basis van je eigen aantal calls en de cache-TTL.

Model routing op basis van complexiteit

Stuur eenvoudige verzoeken naar een goedkoop model en alleen de zware naar Pro. Een simpele heuristiek:

COMPLEXE_SIGNALEN = ["analyseer", "redeneer", "vergelijk uitgebreid", "schrijf een uitgebreid"]

def kies_model(prompt: str) -> str:
    woorden = len(prompt.split())
    is_complex = any(signaal in prompt.lower() for signaal in COMPLEXE_SIGNALEN)
    if is_complex or woorden > 500:
        return "gemini-2.5-pro"
    return "gemini-3.1-flash-lite"

def adaptief_genereer(prompt: str) -> str:
    model = kies_model(prompt)
    response = client.models.generate_content(model=model, contents=prompt)
    return response.text

Begin simpel met zo'n routing en verfijn de regels op basis van wat je in je monitoring ziet over kwaliteit en kosten per modeltype.