Salt la conținutul principal
Română— Alege o limbă
Meniu

Facturare și optimizarea costurilor

Lecția 9 din 12 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Tokenii de raționament pe factura dumneavoastră
  2. Prețuri pe model (iulie 2026)
  3. Urmărirea costului fiecărei cereri
  4. Strategii de optimizare a costurilor
  5. Urmărirea bugetului în producție
  6. Puncte cheie

Actualizat la 3 noiembrie 2026: Exemplele anterioare accesau usage.prompt_tokens și usage.completion_tokens pe răspunsurile API-ului Responses, care expun input_tokens, output_tokens și detaliile acestora (cached_tokens, reasoning_tokens): codul genera o eroare AttributeError. 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