Praćenje troškova i korištenja
Na ovoj stranici
Praćenje troškova i korištenja
Troškovi API-ja mogu brzo izmaknuti kontroli ako ih ne pratiš. Ova lekcija uči te kako pratiti, procijeniti i kontrolirati svoju potrošnju u produkciji. Priča se ponavlja iz projekta u projekt: značajka krene u rad četvrtkom, nitko ne provjeri nadzornu ploču tijekom vikenda, a ponedjeljkom ujutro račun odgovara cijelom mjesečnom proračunu. Koraci u nastavku pomažu ti uhvatiti odstupanje u troškovima čim se dogodi, a ne trideset dana kasnije.
Razumijevanje naplate
Troškovi se obračunavaju po milijunu tokena, s različitim cijenama za ulaz (input) i izlaz (output). Ta asimetrija ima izravne posljedice na tvoje dizajnerske odluke: slanje dugog dokumenta kao ulaza košta znatno manje nego traženje od modela da generira dug odgovor. Svaki odgovor vraća točan broj tokena za oba smjera, tako da nikada ne moraš procjenjivati.
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!
Kalkulator troškova
Pretvaranje ovih brojača u dolare zahtijeva cjenik. Izdvoj ga u posebnu strukturu umjesto da raspršuješ konstante kroz kod: kada se cijene promijene ili dodaš model, trebaš modificirati samo jedan redak. Stope u nastavku su okvirne i treba ih provjeriti tijekom svake revizije proračuna.
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
Osam desetinki centa po pozivu zvuči ohrabrujuće dok to ne pomnožiš s pedeset tisuća dnevnih poziva produkcijskog chatbota – to je četiri stotine dolara dnevno. Uvijek stekni naviku razmišljati u mjesečnim volumenima, nikada po pozivu.
Pratitelj troškova u stvarnom vremenu
Izračuni po jedinici beskorisni su ako se ne agregiraju. Ovaj pratitelj zbraja potrošnju kroz tri osi – po danu, po modelu i po broju poziva – te uspoređuje dnevni ukupni iznos s proračunom koji si postavio. Upozorenja su stupnjevita: upozorenje kada preostane manje od 20 % proračuna, nakon čega slijedi strogo upozorenje pri prelasku limita. Taj međukorak vrijedan je jer ti daje vremena za intervenciju prije nego što se usluga prekine.
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))
Klijent s kontrolom proračuna
Praćenje nije uvijek dovoljno: suočen s neispravnom petljom koja neprestano zove API, trebaš financijski osigurač. Ovaj klijent provjerava preostali proračun prije izdavanja zahtjeva i jednostavno odbija poziv ako je omotnica potrošena. Usluga se degradira, ali na kontroliran način, bez iznenađenja na računu. Obračun troškova događa se naknadno, jednom kada je stvarno korištenje poznato.
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}")
Optimizacija troškova
1. Odabir pravog modela
Najmoćnija poluga ostaje usmjeravanje prema složenosti. Zadatak klasifikacije u tri kategorije nema potrebe za najskupljim modelom: za ovaj zadatak razlika u računu doseže faktor dvadeset i pet uz istu kvalitetu. Učini složenost eksplicitnim parametrom svoje funkcije umjesto odluke ugrađene u logiku.
# 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. Predmemoriranje odgovora (Caching)
Druga poluga je izbjegavanje plaćanja dvaput za isti odgovor. Često postavljana pitanja (FAQ), katalog proizvoda ili standardni obrasci generiraju strogo identične upite desetke puta dnevno. Ključ predmemore (cache key) kombinira model, ulaz i parametre – uključivanje svih njih je ključno, inače bi promjena temperature tiho vratila stari odgovor.
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. Ograničavanje izlaznih tokena
Konačno, ograniči izlaz kad god je njegova duljina predvidiva. Budući da je izlaz skuplji dio, traženje jedne riječi uz dopuštenje od dvije tisuće tokena ostavlja otvorena vrata opširnom odgovoru koji ćeš platiti, ali ga nećeš iskoristiti.
# 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
)
Cijene od 5. kolovoza 2026. – cijene se redovito mijenjaju: prije svakog izračuna proračuna provjeri trenutni cjenik na službenoj stranici s cijenama OpenAI-ja.
Ključne točke
- Troškovi ovise o modelu I smjeru (ulaz naspram izlaza)
- Implementiraj pratitelja troškova s upozorenjima o proračunu
- Koristi pravi model za svaki zadatak: Luna za volumen, Terra kao zadani izbor
- Predmemoriranje može drastično smanjiti troškove za ponavljajuće zahtjeve
- Postavi
max_output_tokenskada je duljina odgovora predvidiva - Provjeri OpenAI nadzornu ploču za službeno praćenje potrošnje