Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Facturatie en kostenbeheer

Les 14 van 16 Bijgewerkt op 30 juli 2026 Ontwikkelaar
Op deze pagina
  1. Begrijp waarvoor u betaalt
  2. De valkuil van cumulatieve geschiedenis
  3. Kosten lezen in het antwoord
  4. Optimalisatiestrategieën
  5. Kosten volgen in productie
  6. Kostenwaarschuwingen
  7. Belangrijkste punten

Begrijp waarvoor u betaalt

De Responses API heeft een belangrijk facturatie-detail: bij een gekoppelde conversatie wordt u gefactureerd voor de volledige geschiedenis, zelfs als u deze niet expliciet opnieuw verzendt. Het begrijpen van dit mechanisme is essentieel om uw kosten in productie onder controle te houden.

De valkuil van cumulatieve geschiedenis

Met previous_response_id reconstrueert de server automatisch de volledige context. Dit is handig voor de ontwikkelaar, maar het betekent dat tokens zich opstapelen:

BeurtUw berichtGefactureerde tokens (input)
150 tokens50
230 tokens + geschiedenis beurt 1130
340 tokens + geschiedenis beurten 1–2350
425 tokens + geschiedenis beurten 1–3725

De groei is kwadratisch. Bij de 10e beurt van een conversatie kunnen de input-tokens 10 tot 50 keer hoger zijn dan bij uw initiële bericht.

Kosten lezen in het antwoord

Elk antwoord bevat een usage-object met de exacte kosten:

{
  "usage": {
    "input_tokens": 450,
    "output_tokens": 280,
    "total_tokens": 730,
    "output_tokens_details": {
      "reasoning_tokens": 200
    },
    "cost_in_nano_usd": 1500000
  }
}

cost_in_nano_usd

Het veld cost_in_nano_usd geeft de kosten in nano-dollars:

1.000.000.000 nano-USD = 1 USD

Omrekenen doet u als volgt:

cost_usd = response.usage.cost_in_nano_usd / 1_000_000_000
print(f"Cost of this request: ${cost_usd:.6f}")

Reasoning-tokens

De reasoning_tokens in output_tokens_details worden gefactureerd tegen het tarief voor output-tokens. Bij redeneermodellen kunnen deze 50 tot 80% van de output-tokens uitmaken.

Optimalisatiestrategieën

Beperk de gesprekslengte

In plaats van oneindig te koppelen, vat u periodiek samen:

# Na N beurten: samenvatten en opnieuw starten
if turn_count > 5:
    summary = client.responses.create(
        model="grok-4.20-0309-reasoning",
        input="Summarize this conversation in 3 key points.",
        previous_response_id=last_id
    )
    # Opnieuw starten met de samenvatting als nieuwe context
    new_start = client.responses.create(
        model="grok-4.20-0309-reasoning",
        instructions=f"Previous context: {summary.output[0].content[0].text}",
        input=user_message
    )

Kies het juiste model

Niet alle modellen kosten evenveel. Gebruik voor eenvoudige taken een minder krachtig (en goedkoper) model. Reserveer redeneermodellen voor complexe problemen.

Beheer max_output_tokens

Beperk de output wanneer u geen lange antwoorden nodig hebt:

{
  "model": "grok-4.20-0309-reasoning",
  "input": "Answer in one sentence: what is the capital of Japan?",
  "max_output_tokens": 100
}

Gebruik waar mogelijk store: false

Niet-opgeslagen antwoorden worden niet op de server bewaard. Dit verlaagt de directe kosten niet, maar voorkomt wel het accumuleren van onnodige gegevens.

Kosten volgen in productie

Implementeer systematische tracking:

import json
from datetime import datetime

def log_usage(response, user_id, feature):
    log_entry = {
        "timestamp": datetime.now().isoformat(),
        "user_id": user_id,
        "feature": feature,
        "response_id": response.id,
        "model": response.model,
        "input_tokens": response.usage.input_tokens,
        "output_tokens": response.usage.output_tokens,
        "reasoning_tokens": response.usage.output_tokens_details.reasoning_tokens,
        "cost_nano_usd": response.usage.cost_in_nano_usd,
        "cost_usd": response.usage.cost_in_nano_usd / 1e9
    }
    # Opslaan in uw logsysteem
    save_to_db(log_entry)

Kostenwaarschuwingen

Stel drempelwaarden voor waarschuwingen in:

MAX_COST_PER_REQUEST = 0.05  # 5 USD cent

cost = response.usage.cost_in_nano_usd / 1e9
if cost > MAX_COST_PER_REQUEST:
    alert(f"Expensive request detected: ${cost:.4f} (user: {user_id})")

Belangrijkste punten

  • Bij gekoppelde conversaties wordt bij elke beurt de volledige geschiedenis gefactureerd – kwadratische groei
  • cost_in_nano_usd / 1 miljard = kosten in USD
  • Reasoning-tokens worden gefactureerd maar zijn onzichtbaar in het antwoord
  • Vat lange conversaties samen om de kosten binnen de perken te houden
  • Implementeer systematische kostentracking per gebruiker en per functie