Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Facturatie en kostenoptimalisatie

Les 9 van 12 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Redeneertokens op uw factuur
  2. Prijzen per model (juli 2026)
  3. Traceer de kosten van elke request
  4. Strategieën voor kostenoptimalisatie
  5. Budgettracking in productie
  6. Belangrijkste punten

Bijgewerkt op 3 november 2026: Eerdere voorbeelden riepen usage.prompt_tokens en usage.completion_tokens aan op Responses API-responses, die input_tokens, output_tokens en hun details (cached_tokens, reasoning_tokens) blootleggen: de code gaf een AttributeError. Kostentracking houdt nu rekening met gecachete input, en het advies om de uitvoerlimiet te verlagen om redeneren te beperken is gecorrigeerd, aangezien deze limiet geen rekening houdt met redeneertokens. Bronnen: Modellen en prijzen · Best practices.

Redeneertokens op uw factuur

Facturatie voor redeneertokens is een cruciaal aspect bij het gebruik van xAI-modellen. Deze tokens worden gefactureerd tegen het tarief voor uitvoertokens—het hoogste tarief—en niet-geoptimaliseerd gebruik kan de kosten snel opdrijven, vooral bij hoge redeneerinspanning op grok-4.5.

Nieuw voor 2026 en belangrijk om te begrijpen: de prijsstelling is getrapt. De prijs per token hangt af van de grootte van de request-context. Onder de 200k prompt-tokens betaalt u het standaardtarief; daarboven verdubbelt het tarief.

Prijzen per model (juli 2026)

Prijs per miljoen tokens.

Model Input < 200k Output < 200k Input ≥ 200k Output ≥ 200k
grok-4.5 $2.00 $6.00 $4.00 $12.00
grok-4.20-0309-reasoning $1.25 $2.50 $2.50 $5.00
grok-4.3 $1.25 $2.50 $2.50 $5.00
grok-build-0.1 $1.00 $2.00 $2.00 $4.00

Redeneertokens worden gefactureerd tegen het tarief in de kolom “Output”. Met grok-4.5 onder de 200k context kost elk miljoen redeneertokens $6,00; met grok-4.20-0309-reasoning $2,50. En als uw prompt de 200k tokens overschrijdt, verdubbelen deze bedragen: $12,00 en $5,00.

Traceer de kosten van elke request

Het usage-object in de response bevat tellers voor tokens; sommige xAI API-responses kunnen ook directe kostenvelden bevatten. Inspecteer het usage-object dat door uw model wordt teruggegeven en raadpleeg de officiële documentatie voor beschikbare velden. Anders is handmatige berekening eenvoudig:

response = client.responses.create(
    model="grok-4.5",
    input="Solve this dynamic programming problem...",
    reasoning={"effort": "high"}
)

# grok-4.5 tarieven onder 200k context tokens (Responses API telt in input/output)
usage = response.usage
input_cost = usage.input_tokens * 2.00 / 1_000_000
output_cost = usage.output_tokens * 6.00 / 1_000_000  # inclusief redeneren
total_cost = input_cost + output_cost

print(f"Input cost: ${input_cost:.6f}")
print(f"Output cost: ${output_cost:.6f}")
print(f"Total cost: ${total_cost:.6f}")

Let op: deze berekening gaat uit van een context onder de 200k tokens. In productie moet uw tracker de toepasselijke tier detecteren (zie hieronder).

Strategieën voor kostenoptimalisatie

1. Stem de inspanning af op de taak

De eerste en meest effectieve optimalisatie is het kiezen van het juiste niveau voor redeneerinspanning op grok-4.5. Lage inspanning kan aanzienlijk minder redeneertokens verbruiken dan hoge inspanning:

# Sorteer requests op complexiteit
if complexity == "simple":
    effort = "low"      # beknopt redeneren
elif complexity == "medium":
    effort = "medium"   # gemiddeld redeneren
else:
    effort = "high"     # diepgaand redeneren

Controleer de exacte waarden die door de parameter worden geaccepteerd op de officiële modellenpagina.

2. Gebruik het juiste model

Voor veelvoorkomende redeneertaken kost grok-4.20-0309-reasoning bij $2,50/M output minder dan de helft van grok-4.5 bij $6,00/M. Reserveer het vlaggenschipmodel voor taken die dit echt vereisen. Voor code is grok-build-0.1 bij $2,00/M output nog zuiniger.

3. Blijf onder de 200k token-tier

De prijstier is een directe hefboom: een request met 250k context-tokens kost per token tweemaal zoveel als een request met 150k. Vraag uzelf voordat u een enorme context verstuurt af of het opsplitsen in meerdere kleinere requests (of een tussenliggende samenvatting) niet zowel goedkoper als effectiever zou zijn.

4. Maak gebruik van prompt-caching

xAI biedt verlaagde prijzen voor input-tokens die al in de cache zitten: herhaalde prompt-prefixen (systeeminstructies, gedeelde context) kosten minder wanneer ze van de ene request naar de andere worden hergebruikt. Onder de 200k tokens kost gecachete input $0,30 per miljoen in plaats van $2,00 met grok-4.5, en $0,20 in plaats van $1,25 met grok-4.20-0309-reasoning (pagina Modellen en prijzen, november 2026). Structureer uw prompts met stabiele delen aan het begin; het deel dat door de cache wordt bediend, verschijnt in usage.input_tokens_details.cached_tokens.

5. Bepaal de grootte van de uitvoerlimiet

De uitvoerlimiet (max_output_tokens in de Responses API, max_completion_tokens in Chat Completions) beperkt alleen de zichtbare response: redeneertokens tellen hier niet voor mee. Het verlagen ervan vermindert daarom het redeneren niet; het riskeert alleen dat de response wordt afgekapt. xAI best practices raden aan deze hoger in te stellen dan de langste verwachte response, of de standaardwaarde van 128.000 tokens aan te houden. Om het redeneren te verminderen, verlaagt u de inspanning op modellen die dit accepteren, of kiest u een goedkoper model.

Budgettracking in productie

class CostTracker:
    # Tarieven per MTok: (input, gecachete input, output) per context-tier
    RATES = {
        "grok-4.5": {"low": (2.00, 0.30, 6.00), "high": (4.00, 0.60, 12.00)},
        "grok-4.20-0309-reasoning": {"low": (1.25, 0.20, 2.50), "high": (2.50, 0.40, 5.00)},
        "grok-build-0.1": {"low": (1.00, 0.20, 2.00), "high": (2.00, 0.40, 4.00)},
    }
    TIER_THRESHOLD = 200_000  # prompt tokens

    def __init__(self):
        self.total_cost = 0
        self.request_count = 0

    def track(self, response, model="grok-4.5"):
        usage = response.usage  # Responses API response
        details = usage.input_tokens_details
        cached = details.cached_tokens if details else 0
        tier = "high" if usage.input_tokens >= self.TIER_THRESHOLD else "low"
        rate_in, rate_cached, rate_out = self.RATES[model][tier]
        cost = (
            (usage.input_tokens - cached) * rate_in / 1e6
            + cached * rate_cached / 1e6
            + usage.output_tokens * rate_out / 1e6  # inclusief redeneren
        )
        self.total_cost += cost
        self.request_count += 1
        return cost

Prijzen per 5 augustus 2026 — prijzen wijzigen regelmatig: controleer voor elke budgetberekening het huidige tarievenoverzicht op de officiële xAI-pagina voor modellen en prijzen.

Belangrijkste punten

  • Redeneertokens worden gefactureerd tegen het tarief voor uitvoertokens
  • De prijsstelling van 2026 is getrapt: boven de 200k context-tokens verdubbelt de prijs per token
  • grok-4.5 kost $2/$6 per MTok onder de 200k ($4/$12 daarboven); grok-4.20-0309-reasoning kost $1,25/$2,50 ($2,50/$5 daarboven)
  • De drie belangrijkste hefbomen: stem de redeneerinspanning af, kies het juiste model, blijf onder de 200k-tier
  • Traceer uw kosten request per request, rekening houdend met de toepasselijke tier