Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Kostenvelden in antwoorden

Les 8 van 14 Bijgewerkt op 29 juli 2026 Gevorderd
Op deze pagina
  1. Kosten in realtime volgen
  2. Het usage-object
  3. Twee schalen voor dezelfde kosten
  4. Bouw een kostentracker
  5. Analyseer het cachetarief
  6. Belangrijkste punten

Kosten in realtime volgen

Elk Grok API-antwoord bevat de details van de zojuist gemaakte kosten. Veel teams ontdekken deze informatie te laat, wanneer de maandelijkse factuur arriveert, terwijl deze per verzoek beschikbaar is. Door dit vanaf het begin van de integratie te benutten, signaleert u afwijkingen binnen een uur nadat ze optreden: een systeemprompt die na een deployment in omvang is verdubbeld, een slecht gekalibreerde retry-lus die dezelfde calls herhaalt, of context die een factureringsdrempel overschrijdt. Zonder deze tracking blijven deze incidenten onzichtbaar tot de afschrijving.

Het usage-object

Elk antwoord bevat een usage-object met details over tokenverbruik en bijbehorende kosten:

{
  "usage": {
    "prompt_tokens": 1250,
    "completion_tokens": 340,
    "total_tokens": 1590,
    "cached_tokens": 800,
    "cost_in_usd_ticks": 5000000000,
    "cost_in_nano_usd": 500000000
  }
}

De vier telvelden lezen als volgt.

VeldBetekenis
prompt_tokensaantal inputtokens (uw volledige prompt)
completion_tokensaantal outputtokens (het antwoord van het model)
total_tokenssom van input- en outputtokens
cached_tokensinputtokens geserveerd vanuit de cache

Eén detail voorkomt een veelgemaakte fout: cached_tokens is inbegrepen in prompt_tokens, niet erbij opgeteld. In het bovenstaande voorbeeld gingen 1.250 tokens het model in, kwamen 800 uit de cache en werden slechts 450 tegen het volledige tarief gefactureerd. Als uw aggregator beide velden optelt, telt u het gecachete deel dubbel en blaast u uw volumestatistieken kunstmatig op.

Twee schalen voor dezelfde kosten

De kosten per verzoek worden verstrekt in twee gehele eenheden. Deze keuze is niet willekeurig: het uitdrukken van fracties van een cent in drijvende-kommagetallen introduceert afrondingsfouten die zichtbaar worden bij het aggregeren van miljoenen calls. Gehele getallen vermijden dit probleem volledig.

Het veld cost_in_usd_ticks telt in “ticks”, met 10 miljard ticks per dollar. De waarde 5.000.000.000 in het voorbeeld komt daarom overeen met $0,50, en één miljoen ticks is gelijk aan $0,0001. De conversie past in één regel:

cost_usd = cost_in_usd_ticks / 10_000_000_000

Het veld cost_in_nano_usd telt in nano-dollars, met één miljard nano-dollars per dollar. De 500.000.000 in het voorbeeld vertegenwoordigt hetzelfde bedrag, $0,50, en duizend nano-dollars is gelijk aan $0,000001. De conversie volgt dezelfde logica:

cost_usd = cost_in_nano_usd / 1_000_000_000

Beide velden beschrijven hetzelfde bedrag op verschillende schalen. cost_in_nano_usd is intuïtiever om mee te werken, terwijl cost_in_usd_ticks iets hogere precisie biedt. Kies er één en houd deze consequent aan throughout uw meetketen: beide mengen in dezelfde aggregatie is de beste manier om inconsistente totalen te krijgen.

Bouw een kostentracker

In productie volstaat een enkele accumulator om deze velden om te zetten in een dashboard. De onderstaande klasse registreert elk usage-object en exposeert de cumulatieve kosten samen met het cachetarief:

class CostTracker:
    def __init__(self):
        self.total_nano_usd = 0
        self.requests = 0
        self.input_tokens = 0
        self.output_tokens = 0
        self.cached_tokens = 0

    def record(self, usage):
        self.total_nano_usd += usage.get("cost_in_nano_usd", 0)
        self.requests += 1
        self.input_tokens += usage.get("prompt_tokens", 0)
        self.output_tokens += usage.get("completion_tokens", 0)
        self.cached_tokens += usage.get("cached_tokens", 0)

    @property
    def total_cost_usd(self):
        return self.total_nano_usd / 1_000_000_000

    @property
    def cache_rate(self):
        if self.input_tokens == 0:
            return 0
        return self.cached_tokens / self.input_tokens

Koppel vervolgens drempels aan total_cost_usd. Een eerste drempel op 80% van het dagbudget activeert een informatieve alert voor het technische team; een tweede op 95% wordt een kritieke alert die een menselijke beslissing vereist; bij 100% stopt de applicatie automatisch niet-kritieke verzoeken—batchjobs, pre-computaties, uitgestelde verrijkingen—en staat alleen direct gebruikersverkeer toe. Deze geleidelijke degradatie is beter dan een plotselinge servicestop op een piekdag.

Analyseer het cachetarief

De eigenschap cache_rate verdient een eigen dashboard, omdat deze direct de kwaliteit van uw promptstructuur weerspiegelt.

CachetariefInterpretatie
0 tot 20%geen effectieve cache, herzie promptstructuur
20 tot 50%gedeeltelijke cache, controleer stabiliteit van uw systeemprompts
50 tot 80%goed tarief voor conversaties
80% en hogeruitstekend, typisch voor lange, stabiele prompts

Een tarief dat van de ene op de andere week scherp daalt, is bijna altijd een teken van een deployment die een variabele aan het begin van de prompt heeft geïntroduceerd. De volgende les behandelt het mechanisme; onthoud voor nu dat dit cijfer een regressie-indicator is die even waardevol is als een foutpercentage.

Prijzen per 5 augustus 2026 — prijzen evolueren regelmatig: controleer voor elke budgetberekening de huidige tarievenlijst op de officiële xAI-modellen en prijzenpagina.

Belangrijkste punten

  • Elk API-antwoord bevat een usage-object met tokendetails en kosten
  • cost_in_usd_ticks: 10 miljard ticks = $1 USD
  • cost_in_nano_usd: 1 miljard nano-USD = $1 USD
  • Het veld cached_tokens meet cache-efficiëntie
  • Bouw een kostentracker in productie met budgetalerts