Monitorizarea costurilor și a utilizării
Pe această pagină
Monitorizarea costurilor și a utilizării
Costurile API pot scăpa rapid de sub control dacă nu le supravegheați. Această lecție vă învață cum să urmăriți, să estimați și să controlați cheltuielile în producție. Povestea se repetă din proiect în proiect: o funcționalitate este lansată într-o joi, nimeni nu verifică tabloul de bord peste weekend, iar factura de luni dimineața egalizează întregul buget lunar. Pașii de mai jos vă ajută să detectați devierea costurilor în momentul în care apare, nu la treizeci de zile distanță.
Înțelegerea facturării
Costurile sunt calculate per milion de tokeni, cu prețuri diferite pentru input și output. Această asimetrie are consecințe directe asupra alegerilor de design: trimiterea unui document lung ca input costă semnificativ mai puțin decât generarea unuia lung de către model. Fiecare răspuns returnează numărul exact pentru ambele direcții, astfel încât nu trebuie niciodată să estimați.
from openai import OpenAI
client = OpenAI()
# Every response includes usage metrics
response = client.responses.create(
model="gpt-5.6-terra",
input="Explain OpenAI API billing."
)
usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total tokens: {usage.total_tokens}")
# Output costs more than input!
Calculator de costuri
Convertirea acestor contoare în dolari necesită o grilă de prețuri. Izolați-o într-o structură dedicată, în loc să împrăștiați constante în tot codul: când prețurile se schimbă sau adăugați un model, trebuie să modificați o singură linie. Tarifele de mai jos sunt indicative și trebuie verificate la fiecare revizuire a bugetului.
from dataclasses import dataclass
@dataclass
class ModelRate:
input_per_million: float
output_per_million: float
# Approximate prices in USD per million tokens
# Always check current prices on platform.openai.com/pricing
RATES = {
"gpt-5.6-luna": ModelRate(input_per_million=0.20, output_per_million=1.20),
"gpt-5.6-terra": ModelRate(input_per_million=2.0, output_per_million=12.0),
"gpt-5.6-sol": ModelRate(input_per_million=5.0, output_per_million=30.0),
}
def calculate_cost(model: str, input_tokens: int,
output_tokens: int) -> float:
"""Calculates the cost of a call in USD."""
rate = RATES.get(model)
if not rate:
raise ValueError(f"Unknown model: {model}")
input_cost = (input_tokens / 1_000_000) * rate.input_per_million
output_cost = (output_tokens / 1_000_000) * rate.output_per_million
return input_cost + output_cost
# Example
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Result: Cost: $0.008000
Opt zecimi de cent pe apel sună reconfortant până când înmulțiți cu cele cincizeci de mii de apeluri zilnice ale unui chatbot în producție – asta înseamnă patru sute de dolari pe zi. Obișnuiți-vă să gândiți în volume lunare, niciodată per apel.
Tracker de costuri în timp real
Calculul unitar este inutil dacă nu este agregat. Acest tracker agregă cheltuielile pe trei axe – pe zi, pe model și pe număr de apeluri – și compară totalul zilei cu un buget stabilit de dumneavoastră. Alertele sunt graduale: un avertisment când mai rămân mai puțin de 20% din buget, urmat de o alertă fermă la depășirea limitei. Acest pas intermediar este valoros deoarece vă oferă timp să interveniți înainte de întreruperea serviciului.
import json
from datetime import datetime, date
from collections import defaultdict
class CostTracker:
"""Real-time API cost tracking."""
def __init__(self, daily_budget_usd: float = 10.0):
self.daily_budget = daily_budget_usd
self.costs_per_day: dict[str, float] = defaultdict(float)
self.costs_per_model: dict[str, float] = defaultdict(float)
self.calls_per_day: dict[str, int] = defaultdict(int)
self.total_tokens = 0
def record(self, model: str, input_tokens: int,
output_tokens: int):
"""Records the costs of a call."""
cost = calculate_cost(model, input_tokens, output_tokens)
today = date.today().isoformat()
self.costs_per_day[today] += cost
self.costs_per_model[model] += cost
self.calls_per_day[today] += 1
self.total_tokens += input_tokens + output_tokens
return cost
def remaining_budget(self) -> float:
"""Returns the remaining budget for today."""
today = date.today().isoformat()
return self.daily_budget - self.costs_per_day[today]
def budget_alert(self) -> bool:
"""Checks if the budget is close to the limit."""
remaining = self.remaining_budget()
if remaining <= 0:
print("ALERT: Daily budget exceeded!")
return True
elif remaining < self.daily_budget * 0.2:
print(f"WARNING: ${remaining:.2f} remaining on daily budget")
return True
return False
def report(self) -> dict:
"""Generates a cost report."""
return {
"total_cost_usd": sum(self.costs_per_day.values()),
"cost_today_usd": self.costs_per_day.get(
date.today().isoformat(), 0
),
"remaining_budget_usd": self.remaining_budget(),
"costs_per_model": dict(self.costs_per_model),
"total_tokens": self.total_tokens,
}
# Usage
tracker = CostTracker(daily_budget_usd=5.0)
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
cost = tracker.record(
model="gpt-5.6-terra",
input_tokens=response.usage.input_tokens,
output_tokens=response.usage.output_tokens
)
print(f"Cost of this call: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))
Client cu control al bugetului
Monitorizarea nu este întotdeauna suficientă: în fața unei bucle defectuoase care apelează API-ul continuu, aveți nevoie de un disjunctiv financiar. Acest client verifică bugetul rămas înainte de a emite cererea și refuză ferm apelul dacă plicul este epuizat. Serviciul se degradează, dar într-un mod controlat, fără facturi surpriză. Contabilitatea costurilor are loc ulterior, odată ce utilizarea reală este cunoscută.
class BudgetControlledClient:
"""Client that refuses calls if the budget is exceeded."""
def __init__(self, daily_budget: float = 10.0):
self.client = OpenAI()
self.tracker = CostTracker(daily_budget_usd=daily_budget)
def create(self, model: str, input: str, **kwargs) -> object:
"""API call with budget control."""
# Check budget before the call
if self.tracker.remaining_budget() <= 0:
raise RuntimeError(
"Daily budget exhausted. "
f"Spent: ${self.tracker.report()['cost_today_usd']:.2f}"
)
response = self.client.responses.create(
model=model,
input=input,
**kwargs
)
cost = self.tracker.record(
model=model,
input_tokens=response.usage.input_tokens,
output_tokens=response.usage.output_tokens
)
# Alert if budget is low
self.tracker.budget_alert()
return response
# Usage
budget_client = BudgetControlledClient(daily_budget=2.0)
try:
response = budget_client.create("gpt-5.6-terra", "Hello!")
print(response.output_text)
except RuntimeError as e:
print(f"Blocked: {e}")
Optimizarea costurilor
1. Alegerea modelului potrivit
Pârghia cea mai puternică rămâne rutarea în funcție de complexitate. O sarcină de clasificare în trei categorii nu are nevoie de cel mai scump model: pentru această sarcină, diferența de facturare atinge un factor de douăzeci și cinci pentru o calitate identică. Faceți din complexitate un parametru explicit al funcției dumneavoastră, în loc de o decizie hardcodată în logică.
# Relative cost per task (approximate, ~300 input tokens / 20 output):
# Simple classification: gpt-5.6-luna ~$0.0001 vs gpt-5.6-sol ~$0.002
# The right model makes a 25x difference in costs!
def optimized_call(prompt: str, complexity: str) -> str:
"""Chooses the most economical suitable model."""
model = {
"simple": "gpt-5.6-luna",
"standard": "gpt-5.6-terra",
"complex": "gpt-5.6-sol",
}.get(complexity, "gpt-5.6-terra")
response = client.responses.create(model=model, input=prompt)
return response.output_text
2. Cache-uirea răspunsurilor
A doua pârghie este evitarea plății de două ori pentru același răspuns. Un FAQ, un catalog de produse sau un formular standard generează prompturi strict identice de zeci de ori pe zi. Cheia de cache combină modelul, inputul și parametrii – includerea tuturor este esențială, altfel o schimbare a temperaturii ar returna silențios vechiul răspuns.
import hashlib
class CachedClient:
"""Client with cache to avoid redundant calls."""
def __init__(self):
self.client = OpenAI()
self.cache: dict[str, str] = {}
def create(self, model: str, input: str, **kwargs) -> str:
# Create a cache key
cache_key = hashlib.md5(
f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
).hexdigest()
if cache_key in self.cache:
print("Cache hit!")
return self.cache[cache_key]
response = self.client.responses.create(
model=model, input=input, **kwargs
)
self.cache[cache_key] = response.output_text
return response.output_text
3. Limitarea tokenilor de output
În final, limitați outputul ori de câte ori lungimea sa este predictibilă. Deoarece outputul este partea costisitoare, cererea unui singur cuvânt în timp ce autorizați două mii de tokeni lasă ușa deschisă pentru un răspuns verbose pe care îl veți plăti, dar nu îl veți folosi.
# Always set max_output_tokens for predictable tasks
response = client.responses.create(
model="gpt-5.6-terra",
input="Classify this text: positive, negative, or neutral.",
max_output_tokens=10 # Expecting a single word
)
Tarife valabile la 5 august 2026 — prețurile se schimbă regulat: înainte de orice calcul bugetar, verificați grila curentă pe pagina oficială de prețuri OpenAI.
Puncte cheie
- Costurile depind de model ȘI de direcție (input vs output)
- Implementați un tracker de costuri cu alerte de buget
- Folosiți modelul potrivit pentru fiecare sarcină: Luna pentru volum, Terra implicit
- Cache-uirea poate reduce drastic costurile pentru cererile repetitive
- Setați
max_output_tokenscând lungimea răspunsului este predictibilă - Verificați tabloul de bord OpenAI pentru urmărirea oficială a consumului