...
← Curs Aplicații AI cu Claude și OpenAI: toate lecțiile
Lecția 7 · Cum funcționează LLM-urile

Cât costă un apel și cum alegi modelul

O aplicație AI care merge perfect în teste poate deveni o surpriză neplăcută pe factură când o folosesc mii de oameni. Vestea bună: costul se calculează exact, din tokeni și din prețul modelului. În această lecție scrii funcția de cost pe care o vei refolosi în tot cursul, estimezi costul lunar al unei aplicații și înveți cum alegi modelul potrivit.

Prețul: dolari pe milion de tokeni

Furnizorii taxează separat tokenii de intrare (tot ce trimiți: instrucțiuni, istoric, documente, întrebare) și tokenii de ieșire (ce scrie modelul). Prețul se dă în dolari per milion de tokeni. Pentru modelele din curs:

ModelidIntrare $/1MIeșire $/1MContext
Claude Haiku 5.5claude-haiku-5-50,100,501M
Claude Sonnet 5.5claude-sonnet-5-52101M
Claude Opus 5.5claude-opus-5-54201M
GPT-6 Lunagpt-6-luna0,100,50272K
GPT-6.1 Solgpt-6.1-sol210272K
GPT-6 Astragpt-6-astra1050272K
Prețurile se schimbă

Tabelul este valabil la 31 octombrie 2026. Furnizorii lansează modele noi și ajustează prețurile, așa că înainte de o lansare verifici paginile oficiale de prețuri și ții prețurile într-un singur loc în cod (un dicționar), nu împrăștiate prin program.

Costul unui apel

Formula este simplă: cost = tokeni_intrare × preț_intrare / 1.000.000 + tokeni_ieșire × preț_ieșire / 1.000.000. Tokenii îi iei din raspuns.usage, după apel.

usageinput_tokens: 1200output_tokens: 300(de la API, după apel)× prețul modelului1200 × 0,10 $ / 1.000.000+ 300 × 0,50 $ / 1.000.000Claude Haiku 5.5Cost apel0,000270 $≈ 0,001215 leiAceeași cerere pe Claude Sonnet 5.5 (2 / 10 $): 0,005400 $, de 20 de ori mai mult.Tokenii de ieșire costă de 5 ori mai mult decât cei de intrare la toate modelele din tabel.
Calculul costului: tokenii din usage înmulțiți cu prețul pe milion al modelului, separat pentru intrare și ieșire.
import anthropic

MODEL = "claude-haiku-5-5"
PRET_INTRARE, PRET_IESIRE = 0.10, 0.50   # $ per 1M tokeni, Claude Haiku 5.5

client = anthropic.Anthropic()
raspuns = client.messages.create(
    model=MODEL,
    max_tokens=50,
    messages=[{"role": "user", "content": "Clasifică mesajul într-un cuvânt (Livrare, Plată, Retur): Când îmi vine coletul?"}],
)

u = raspuns.usage
cost = (u.input_tokens * PRET_INTRARE + u.output_tokens * PRET_IESIRE) / 1_000_000
print("Categorie:", raspuns.content[0].text)
print(f"{u.input_tokens} + {u.output_tokens} tokeni = {cost:.8f} $")
print(f"Un milion de astfel de apeluri: {cost * 1_000_000:.2f} $")
Categorie: Livrare
37 + 2 tokeni = 0.00000470 $
Un milion de astfel de apeluri: 4.70 $

Un apel de clasificare costă o fracțiune infimă de cent. De aceea, la modelele mici, întrebarea nu este „cât costă un apel”, ci „câte apeluri fac pe lună și câți tokeni trimit la fiecare”.

Aceeași cerere, modele diferite

Ține prețurile într-un dicționar PRETURI și compari ușor toate modelele pentru o cerere tipică a aplicației tale:

PRETURI = {  # dolari per 1 milion de tokeni: (intrare, ieșire)
    "claude-haiku-5-5": (0.10, 0.50),
    "claude-sonnet-5-5": (2.00, 10.00),
    "claude-opus-5-5": (4.00, 20.00),
    "gpt-6-luna": (0.10, 0.50),
    "gpt-6.1-sol": (2.00, 10.00),
    "gpt-6-astra": (10.00, 50.00),
}

TOKENI_INTRARE = 1200   # de exemplu: instrucțiuni + istoric + întrebare
TOKENI_IESIRE = 300     # un răspuns de câteva fraze

for model, (p_in, p_out) in PRETURI.items():
    cost = (TOKENI_INTRARE * p_in + TOKENI_IESIRE * p_out) / 1_000_000
    print(f"{model:18} {cost:.6f} $ / apel   {cost * 100_000:8.2f} $ / 100.000 apeluri")
claude-haiku-5-5   0.000270 $ / apel      27.00 $ / 100.000 apeluri
claude-sonnet-5-5  0.005400 $ / apel     540.00 $ / 100.000 apeluri
claude-opus-5-5    0.010800 $ / apel    1080.00 $ / 100.000 apeluri
gpt-6-luna         0.000270 $ / apel      27.00 $ / 100.000 apeluri
gpt-6.1-sol        0.005400 $ / apel     540.00 $ / 100.000 apeluri
gpt-6-astra        0.027000 $ / apel    2700.00 $ / 100.000 apeluri

Diferența dintre cel mai ieftin și cel mai scump model este de 100 de ori. Pentru 100.000 de apeluri, înseamnă 27 $ față de 2.700 $.

Costul lunar al unei aplicații

Pentru bugetul unei aplicații, înmulțești costul unui apel tipic cu numărul de apeluri: utilizatori activi × mesaje pe zi × zile.

UTILIZATORI_ACTIVI = 2000
MESAJE_PE_ZI = 5
ZILE = 30
TOKENI_INTRARE = 1200
TOKENI_IESIRE = 300
PRET_INTRARE, PRET_IESIRE = 0.10, 0.50   # Claude Haiku 5.5
CURS_LEU = 4.50                           # aproximativ

apeluri = UTILIZATORI_ACTIVI * MESAJE_PE_ZI * ZILE
cost_apel = (TOKENI_INTRARE * PRET_INTRARE + TOKENI_IESIRE * PRET_IESIRE) / 1_000_000
total = apeluri * cost_apel

print("Apeluri pe lună:", apeluri)
print(f"Cost lunar: {total:.2f} $ (aproximativ {total * CURS_LEU:.2f} lei)")
print(f"Cost pe utilizator: {total / UTILIZATORI_ACTIVI:.4f} $")
Apeluri pe lună: 300000
Cost lunar: 81.00 $ (aproximativ 364.50 lei)
Cost pe utilizator: 0.0405 $

Joacă-te cu calculatorul de mai jos: schimbă modelul, numărul de utilizatori și lungimea mesajelor și urmărește cum se schimbă costul lunar, în dolari și în lei.

Nu uita de istoric

Într-un chatbot, TOKENI_INTRARE crește la fiecare replică, pentru că retrimiți conversația (lecția 4). Măsoară valoarea medie reală din usage în loguri, nu o ghici.

Cum alegi modelul

1
Începe cu modelul mic (Claude Haiku 5.5 sau GPT-6 Luna): rapid, ieftin și suficient pentru majoritatea sarcinilor de clasificare, extragere, rezumat și suport.
2
Scrie un set de cazuri de test reale (10–20 de întrebări cu răspunsul așteptat) și rulează-l pe modelul mic (modulul 2 îți arată cum).
3
Urci la un model mai mare doar dacă testele arată că e nevoie: răspunsuri greșite la sarcini de raționament, cod sau analiză.
4
Împarte sarcinile: modelul mic pentru cererile simple și dese, modelul mare doar pentru cele grele (rutare).
SarcinaModel potrivit pentru început
Clasificarea mesajelor, extragerea datelor dintr-un emailHaiku 5.5 / GPT-6 Luna, efort low
Chatbot de suport din documentele firmeiHaiku 5.5 / GPT-6 Luna
Analize, planuri, cod complexSonnet 5.5 / GPT-6.1 Sol
Cele mai grele sarcini, agenți care lucrează mult singuriOpus 5.5 / GPT-6 Astra, după ce testele o cer

Greșeli frecvente

  • Calculezi costul doar din tokenii de intrare: ieșirea costă de 5 ori mai mult și, la răspunsuri lungi, domină factura.
  • Folosești din start cel mai mare model „ca să fie sigur”: plătești de 20–100 de ori mai mult pentru un câștig pe care nu l-ai măsurat.
  • Uiți împărțirea la 1.000.000: costurile ies de un milion de ori mai mari și iei decizii greșite.
  • Afișezi costul cu 2 zecimale: un apel de 0,000270 $ apare ca 0,00. Pentru apeluri individuale folosește 6 zecimale.
  • Nu pui nicio limită de cheltuieli în contul furnizorului: o buclă greșită poate face mii de apeluri într-o noapte (modulul 8).
MagazinDescrieri de produse

1.000 de descrieri generate cu Haiku 5.5 costă cenți; aceleași cu Opus 5.5 costă de 40 de ori mai mult.

SuportRutare pe modele

Întrebările simple merg la modelul mic, reclamațiile complicate la cel mare.

StartupBugetul pe utilizator

Prețul abonamentului se stabilește după costul real pe utilizator activ, din loguri.

Exercițiul tău

Scrie funcția cost_apel(usage, model) care întoarce costul unui apel în dolari și în lei (curs aproximativ 4,50), folosind prețurile din PRETURI. Trimite cererea dată, afișează Tokeni: X intrare, Y ieșire, apoi costul pentru MODEL și pentru claude-sonnet-5-5 (cu același usage), fiecare pe o linie: <model>: <dolari> $ / <lei> lei, cu 6 zecimale.

  • În cost_apel, ia prețurile cu pret_intrare, pret_iesire = PRETURI[model].
  • Calculează dolarii: (usage.input_tokens * pret_intrare + usage.output_tokens * pret_iesire) / 1_000_000 și întoarce (dolari, dolari * CURS_LEU).
  • Afișează Tokeni: X intrare, Y ieșire din raspuns.usage.
  • Pentru MODEL și "claude-sonnet-5-5" afișează <model>: <dolari> $ / <lei> lei, cu :.6f.
O funcție poate întoarce două valori: return dolari, lei; la apel le desfaci cu dolari, lei = cost_apel(raspuns.usage, model).

Soluția exercițiului

import anthropic

MODEL = "claude-haiku-5-5"
CURS_LEU = 4.50  # aproximativ

PRETURI = {  # dolari per 1 milion de tokeni: (intrare, ieșire)
    "claude-haiku-5-5": (0.10, 0.50),
    "claude-sonnet-5-5": (2.00, 10.00),
    "claude-opus-5-5": (4.00, 20.00),
    "gpt-6-luna": (0.10, 0.50),
    "gpt-6.1-sol": (2.00, 10.00),
    "gpt-6-astra": (10.00, 50.00),
}

client = anthropic.Anthropic()


def cost_apel(usage, model):
    pret_intrare, pret_iesire = PRETURI[model]
    dolari = (usage.input_tokens * pret_intrare + usage.output_tokens * pret_iesire) / 1_000_000
    return dolari, dolari * CURS_LEU


raspuns = client.messages.create(
    model=MODEL,
    max_tokens=300,
    messages=[{"role": "user", "content": "Scrie o descriere de 2 fraze pentru o cană termică de 450 ml."}],
)

print(f"Tokeni: {raspuns.usage.input_tokens} intrare, {raspuns.usage.output_tokens} ieșire")
for model in [MODEL, "claude-sonnet-5-5"]:
    dolari, lei = cost_apel(raspuns.usage, model)
    print(f"{model}: {dolari:.6f} $ / {lei:.6f} lei")
Excelent! Continuă cu lecția următoare →
main.pyPython
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Cum funcționează LLM-urile Lecția 7 · Cât costă un apel și cum alegi modelul
Progres 0% 0 din 10
Lecția curentă 7 / 8 Cum funcționează llm-urile