Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Fakturering och kostnadsoptimering

Lektion 9 av 12 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Resonemangstokens på din faktura
  2. Prissättning per modell (juli 2026)
  3. Spåra kostnaden för varje begäran
  4. Strategier för kostnadsoptimering
  5. Budgetuppföljning i produktion
  6. Viktiga punkter

Uppdaterat 3 november 2026: Tidigare exempel hämtade usage.prompt_tokens och usage.completion_tokens från Responses API-svar, vilka exponerar input_tokens, output_tokens och deras detaljer (cached_tokens, reasoning_tokens): koden gav ett AttributeError. Kostnadsuppföljningen tar nu hänsyn till cachat indata, och rådet att sänka utgränsen för att begränsa resonemang har korrigerats, då denna gräns inte inkluderar resonemangstokens. Källor: Modeller och prissättning · Bästa praxis.

Resonemangstokens på din faktura

Fakturering av resonemangstokens är en kritisk aspekt av att använda xAI-modeller. Dessa tokens debiteras till utdatataxen – den högsta taxan – och ooptimerad användning kan snabbt driva upp kostnaderna, särskilt vid högt resonemangsarbete på grok-4.5.

Nytt för 2026 och viktigt att förstå: prissättningen är trappad. Priset per token beror på begärandets kontextstorlek. Under 200 000 prompt-tokens betalar du standardtaxan; över den gränsen fördubblas taxan.

Prissättning per modell (juli 2026)

Pris per miljon tokens.

Modell Indata < 200k Utdata < 200k Indata ≥ 200k Utdata ≥ 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

Resonemangstokens debiteras enligt taxan i kolumnen “Utdata”. Med grok-4.5 under 200 000 kontexttokens kostar varje miljon resonemangstokens $6,00; med grok-4.20-0309-reasoning kostar de $2,50. Om din prompt överstiger 200 000 tokens fördubblas dessa belopp: till $12,00 respektive $5,00.

Spåra kostnaden för varje begäran

Objektet usage i svaret innehåller tokenräknare; vissa xAI API-svar kan också inkludera direkta kostnadsfält. Inspektera usage-objektet som returneras av din modell och kontrollera den officiella dokumentationen för tillgängliga fält. Annars är manuell beräkning enkel:

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

# grok-4.5-taxor under 200k kontexttokens (Responses API räknar i indata/utdata)
usage = response.usage
input_cost = usage.input_tokens * 2.00 / 1_000_000
output_cost = usage.output_tokens * 6.00 / 1_000_000  # inkluderar resonemang
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}")

Varning: denna beräkning förutsätter en kontext under 200 000 tokens. I produktion måste din spårare upptäcka vilket trappsteg som gäller (se nedan).

Strategier för kostnadsoptimering

1. Anpassa arbetsinsatsen till uppgiften

Den första och mest effektiva optimeringen är att välja rätt nivå för resonemangsarbete på grok-4.5. Låg insats kan konsumera betydligt färre resonemangstokens än hög insats:

# Sortera begäranden efter komplexitet
if complexity == "simple":
    effort = "low"      # kortfattat resonemang
elif complexity == "medium":
    effort = "medium"   # mellanliggande resonemang
else:
    effort = "high"     # djupt resonemang

Kontrollera de exakta värden som parametern accepterar på den officiella modellsidan.

2. Använd rätt modell

För vanliga resonemangsuppgifter kostar grok-4.20-0309-reasoning $2,50/M utdata, vilket är mindre än hälften av grok-4.5:s $6,00/M. Spara flaggskeppsmodellen för uppgifter som verkligen kräver den. För kod är grok-build-0.1 vid $2,00/M utdata ännu mer ekonomiskt.

3. Håll dig under tröskeln på 200k tokens

Pristrappan är en direkt hävstång: en begäran med 250 000 kontexttokens kostar dubbelt så mycket per token som en begäran med 150 000. Innan du skickar en massiv kontext, fråga dig själv om det inte skulle vara både billigare och effektivare att dela upp den i flera mindre begäranden (eller en mellanliggande sammanfattning).

4. Utnyttja prompt-cachning

xAI erbjuder reducerad prissättning för indatatokens som redan finns i cachen: upprepade prompt-prefix (systeminstruktioner, delad kontext) kostar mindre när de återanvänds från en begäran till nästa. Under 200 000 tokens kostar cachad indata $0,30 per miljon istället för $2,00 med grok-4.5, och $0,20 istället för $1,25 med grok-4.20-0309-reasoning (sidan Modeller och prissättning, november 2026). Strukturera dina prompts med stabila delar i början; den del som serveras från cachen visas i usage.input_tokens_details.cached_tokens.

5. Dimensionera utgränsen

Utgränsen (max_output_tokens i Responses API, max_completion_tokens i Chat Completions) begränsar endast det synliga svaret: resonemangstokens räknas inte mot denna gräns. Att sänka den minskar därför inte resonemanget; det riskerar endast att klippa av svaret. xAI:s bästa praxis rekommenderar att du sätter den högre än det längsta förväntade svaret, eller lämnar dess standardvärde på 128 000 tokens. För att minska resonemanget, sänk insatsen på modeller som accepterar det, eller välj en billigare modell.

Budgetuppföljning i produktion

class CostTracker:
    # Taxor per MTok: (indata, cachad indata, utdata) per kontextnivå
    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-svar
        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  # inkluderar resonemang
        )
        self.total_cost += cost
        self.request_count += 1
        return cost

Priser från och med 5 augusti 2026 — priser ändras regelbundet: innan någon budgetberäkning, verifiera den aktuella prislistan på den officiella xAI-sidan för modeller och prissättning.

Viktiga punkter

  • Resonemangstokens debiteras till taxan för utdatatokens
  • Prissättningen 2026 är trappad: över 200 000 kontexttokens fördubblas priset per token
  • grok-4.5 kostar $2/$6 per MTok under 200k ($4/$12 över); grok-4.20-0309-reasoning kostar $1,25/$2,50 ($2,50/$5 över)
  • De tre huvudsakliga hävstängerna: anpassa resonemangsinsatsen, välj rätt modell, håll dig under 200k-nivån
  • Spåra dina kostnader begäran för begäran, med hänsyn till gällande trappsteg