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

Monitorizarea costurilor și a utilizării

Lecția 16 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Monitorizarea costurilor și a utilizării
  2. Înțelegerea facturării
  3. Calculator de costuri
  4. Tracker de costuri în timp real
  5. Client cu control al bugetului
  6. Optimizarea costurilor
  7. Puncte cheie

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_tokens când lungimea răspunsului este predictibilă
  • Verificați tabloul de bord OpenAI pentru urmărirea oficială a consumului