Facturare și optimizarea costurilor
Pe această pagină
Actualizat la 3 noiembrie 2026: Exemplele anterioare accesau
usage.prompt_tokensșiusage.completion_tokenspe răspunsurile API-ului Responses, care expuninput_tokens,output_tokensși detaliile acestora (cached_tokens,reasoning_tokens): codul genera o eroareAttributeError. Urmărirea costurilor ține acum cont de intrarea stocată în cache, iar sfatul de a reduce limita de ieșire pentru a limita raționamentul este corectat, deoarece această limită nu include raționamentul. Surse: Modele și prețuri · Cele mai bune practici.
Tokenii de raționament pe factura dumneavoastră
Facturarea tokenilor de raționament este un aspect critic al utilizării modelelor xAI. Acești tokeni sunt facturați la tariful pentru tokeni de ieșire — cel mai ridicat tarif — iar o utilizare neoptimizată poate duce rapid la creșterea costurilor, în special cu un efort de raționament ridicat pe grok-4.5.
Noutate pentru 2026 și important de înțeles: prețurile sunt structurate pe niveluri. Prețul per token depinde de dimensiunea contextului cererii. Sub 200k tokeni de prompt, plătiți tariful standard; peste această valoare, tariful se dublează.
Prețuri pe model (iulie 2026)
Preț per milion de tokeni.
| Model | Intrare < 200k | Ieșire < 200k | Intrare ≥ 200k | Ieșire ≥ 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 |
Tokenii de raționament sunt facturați la tariful din coloana „Ieșire“. Cu grok-4.5 sub un context de 200k, fiecare milion de tokeni de raționament costă 6,00 USD; cu grok-4.20-0309-reasoning, 2,50 USD. Iar dacă promptul dumneavoastră depășește 200k tokeni, aceste sume se dublează: 12,00 USD și respectiv 5,00 USD.
Urmărirea costului fiecărei cereri
Obiectul usage din răspuns conține contoare de tokeni; unele răspunsuri ale API-ului xAI pot include, de asemenea, câmpuri directe de cost. Inspectați obiectul usage returnat de modelul dumneavoastră și verificați documentația oficială pentru câmpurile disponibile. În caz contrar, calculul manual este simplu:
response = client.responses.create(
model="grok-4.5",
input="Solve this dynamic programming problem...",
reasoning={"effort": "high"}
)
# Tarife grok-4.5 sub 200k tokeni de context (API-ul Responses numără în intrare/ieșire)
usage = response.usage
input_cost = usage.input_tokens * 2.00 / 1_000_000
output_cost = usage.output_tokens * 6.00 / 1_000_000 # include raționamentul
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}")
Atenție: acest calcul presupune un context sub 200k tokeni. În producție, instrumentul de urmărire trebuie să detecteze nivelul aplicabil (vezi mai jos).
Strategii de optimizare a costurilor
1. Adaptați efortul la sarcină
Prima și cea mai eficientă optimizare este alegerea nivelului corect de efort de raționament pe grok-4.5. Un efort scăzut poate consuma semnificativ mai puțini tokeni de raționament decât un efort ridicat:
# Sortați cererile după complexitate
if complexity == "simple":
effort = "low" # raționament scurt
elif complexity == "medium":
effort = "medium" # raționament intermediar
else:
effort = "high" # raționament profund
Verificați valorile exacte acceptate de parametru pe pagina oficială a modelelor.
2. Utilizați modelul potrivit
Pentru sarcini comune de raționament, grok-4.20-0309-reasoning la 2,50 USD/M pentru ieșire costă mai puțin de jumătate din grok-4.5 la 6,00 USD/M. Rezervați modelul principal pentru sarcinile care îl necesită cu adevărat. Pentru cod, grok-build-0.1 la 2,00 USD/M pentru ieșire este și mai economic.
3. Rămâneți sub nivelul de 200k tokeni
Nivelul de preț este o pârghie directă: o cerere cu 250k tokeni de context costă de două ori mai mult per token decât o cerere cu 150k. Înainte de a trimite un context masiv, întrebați-vă dacă divizarea acestuia în mai multe cereri mai mici (sau un rezumat intermediar) nu ar fi atât mai ieftină, cât și mai eficientă.
4. Valorificați stocarea în cache a prompturilor
xAI oferă prețuri reduse pentru tokenii de intrare deja stocați în cache: prefixurile de prompt repetate (instrucțiuni de sistem, context partajat) costă mai puțin atunci când sunt reutilizate de la o cerere la alta. Sub 200k tokeni, intrarea stocată în cache costă 0,30 USD per milion în loc de 2,00 USD cu grok-4.5, și 0,20 USD în loc de 1,25 USD cu grok-4.20-0309-reasoning (pagina Modele și prețuri, noiembrie 2026). Structurați prompturile cu părți stabile la început; porțiunea servită din cache apare în usage.input_tokens_details.cached_tokens.
5. Dimensionați limita de ieșire
Limita de ieșire (max_output_tokens în API-ul Responses, max_completion_tokens în Chat Completions) limitează doar răspunsul vizibil: tokenii de raționament nu se iau în calcul pentru aceasta. Prin urmare, reducerea acesteia nu reduce raționamentul; riscă doar să întrerupă răspunsul. Cele mai bune practici xAI recomandă setarea acesteia peste cel mai lung răspuns așteptat sau lăsarea valorii implicite de 128.000 de tokeni. Pentru a reduce raționamentul, scădeți efortul pe modelele care îl acceptă sau alegeți un model mai ieftin.
Urmărirea bugetului în producție
class CostTracker:
# Tarife per MTok: (intrare, intrare cache, ieșire) pe nivel de context
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 # tokeni de prompt
def __init__(self):
self.total_cost = 0
self.request_count = 0
def track(self, response, model="grok-4.5"):
usage = response.usage # răspuns API Responses
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 # include raționamentul
)
self.total_cost += cost
self.request_count += 1
return cost
Prețuri valabile la 5 august 2026 — prețurile se modifică regulat: înainte de orice calcul bugetar, verificați grila actuală pe pagina oficială xAI pentru modele și prețuri.
Puncte cheie
- Tokenii de raționament sunt facturați la tariful pentru tokeni de ieșire
- Prețurile din 2026 sunt structurate pe niveluri: peste 200k tokeni de context, prețul per token se dublează
- grok-4.5 costă 2/6 USD per MTok sub 200k (4/12 USD peste); grok-4.20-0309-reasoning costă 1,25/2,50 USD (2,50/5 USD peste)
- Cele trei pârghii principale: adaptați efortul de raționament, alegeți modelul potrivit, rămâneți sub nivelul de 200k
- Urmăriți-vă costurile cerere cu cerere, luând în calcul nivelul aplicabil