Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Omkostningsfelter i svar

Lektion 8 af 14 Opdateret 29. juli 2026 Avanceret
På denne side
  1. Følg omkostninger i realtid
  2. usage-objektet
  3. To skalaer for den samme omkostning
  4. Byg en omkostningstracker
  5. Analyser cache-raten
  6. Vigtige pointer

Følg omkostninger i realtid

Hvert svar fra Grok API’en indeholder detaljer om, hvad det lige har kostet. Mange teams opdager disse oplysninger for sent, når den månedlige regning ankommer, selvom de er tilgængelige for hver enkelt anmodning. Ved at udnytte dem helt fra starten af integrationen, kan du spotte afvigelser inden for en time efter, de opstår: et system-prompt, der er fordoblet i størrelse efter en deployment, en dårligt kalibreret genforsøgsløkke, der afspiller de samme kald, eller en kontekst, der krydser en faktureringstærskel. Uden denne sporing forbliver disse hændelser usynlige, indtil regningen kommer.

usage-objektet

Hvert svar inkluderer et usage-objekt, der detaljerer tokenforbrug og tilhørende omkostninger:

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

De fire tællefelter læses som følger.

FeltBetydning
prompt_tokensantal input-tokens (dit fulde prompt)
completion_tokensantal output-tokens (modellens svar)
total_tokenssummen af input- og output-tokens
cached_tokensinput-tokens leveret fra cache

Én detalje forhindrer en almindelig fejl: cached_tokens er inkluderet i prompt_tokens, ikke lagt til det. I eksemplet ovenfor gik 1.250 tokens ind i modellen, 800 kom fra cachen, og kun 450 blev faktureret til fuld takst. Hvis din aggregator lægger begge felter sammen, vil den dobbelttælle den cachede del og kunstigt oppuste dine volumestatistikker.

To skalaer for den samme omkostning

Anmodningsomkostningen leveres i to heltalsenheder. Dette valg er ikke vilkårligt: at udtrykke brøkdele af en cent i flydende tal introducerer afrundingsfejl, der bliver synlige, når man aggregerer millioner af kald. Heltal undgår dette problem fuldstændigt.

Feltet cost_in_usd_ticks tæller i “ticks”, hvor der er 10 milliarder ticks per dollar. Værdien 5.000.000.000 i eksemplet svarer derfor til $0,50, og én million ticks svarer til $0,0001. Konverteringen passer på én linje:

cost_usd = cost_in_usd_ticks / 10_000_000_000

Feltet cost_in_nano_usd tæller i nano-dollar, hvor der er én milliard nano-dollar per dollar. De 500.000.000 i eksemplet repræsenterer det samme beløb, $0,50, og tusind nano-dollar svarer til $0,000001. Konverteringen følger den samme logik:

cost_usd = cost_in_nano_usd / 1_000_000_000

Begge felter beskriver det samme beløb på forskellige skalaer. cost_in_nano_usd er mere intuitivt at håndtere, mens cost_in_usd_ticks tilbyder lidt højere præcision. Vælg ét og hold fast i det gennem hele din målekæde: at blande begge i samme aggregat er den sikreste måde at få inkonsistente totaler på.

Byg en omkostningstracker

I produktion er en enkelt akkumulator nok til at omdanne disse felter til et dashboard. Klassen nedenfor registrerer hvert usage-objekt og eksponerer de kumulerede omkostninger sammen med cache-raten:

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

Tilføj derefter tærskler til total_cost_usd. En første tærskel ved 80 % af det daglige budget udløser en informationsalert til det tekniske team; en anden ved 95 % bliver en kritisk alert, der kræver menneskelig beslutning; ved 10 % skærer applikationen automatisk ikke-kritiske anmodninger fra – batchjobs, forberegninger, udsatte berigelser – og tillader kun direkte brugertrafik. Denne gradvise nedtrapning er bedre end et pludseligt service-stop på en travl dag.

Analyser cache-raten

Egenskaben cache_rate fortjener sit eget dashboard, da den direkte afspejler kvaliteten af din prompt-struktur.

Cache-rateFortolkning
0 til 20 %ingen effektiv cache, gennemgå prompt-struktur
20 til 50 %delvis cache, tjek stabiliteten af dine system-prompts
50 til 80 %god rate for samtaler
80 % og deroverfremragende, typisk for lange, stabile prompts

En rate, der falder kraftigt fra den ene uge til den næste, er næsten altid et tegn på en deployment, der har introduceret en variabel i starten af promptet. Den næste lektion detaljerer mekanismen; husk indtil videre, at dette tal er en regressionsindikator, der er lige så værdifuld som en fejlrate.

Priser pr. 5. august 2026 — priserne ændrer sig regelmæssigt: før enhver budgetberegning skal du tjekke den aktuelle pristakst på den officielle side for xAI-modeller og priser.

Vigtige pointer

  • Hvert API-svar indeholder et usage-objekt med tokendetaljer og omkostninger
  • cost_in_usd_ticks: 10 milliarder ticks = $1 USD
  • cost_in_nano_usd: 1 milliard nano-USD = $1 USD
  • Feltet cached_tokens måler cache-effektivitet
  • Byg en omkostningstracker i produktion med budgetalerts