Facturatie en kostenoptimalisatie
Op deze pagina
Bijgewerkt op 3 november 2026: Eerdere voorbeelden riepen
usage.prompt_tokensenusage.completion_tokensaan op Responses API-responses, dieinput_tokens,output_tokensen hun details (cached_tokens,reasoning_tokens) blootleggen: de code gaf eenAttributeError. 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