Monitorovanie nákladov a využitia
Na tejto strane
Monitorovanie nákladov a využitia
Náklady na API môžu rýchlo vymknúť kontrole, ak ich nesleduješ. V tejto lekcii sa naučíš, ako v produkčnom prostredí sledovať, odhadovať a kontrolovať svoje výdavky. Príbeh sa opakuje projekt od projektu: funkcia ide do prevádzky vo štvrtok, cez víkend nikto neskontroluje dashboard a pondelňajší účet sa rovná celému mesačnému rozpočtu. Nasledujúce kroky ti pomôžu zachytiť odklon nákladov v momente, keď nastane, nie až o tridsať dní neskôr.
Pochopenie fakturácie
Náklady sa计算ujú za milión tokenov, pričom ceny za vstup (input) a výstup (output) sa líšia. Táto asymetria má priame dôsledky pre tvoje dizajnové rozhodnutia: odoslanie dlhého dokumentu ako vstupu stojí výrazne menej, než keď model vygeneruje dlhý text. Každá odpoveď vráti presný počet tokenov pre oba smery, takže nikdy nemusíš odhadovať.
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!
Kalkulačka nákladov
Prevod týchto počítadiel na doláre si vyžaduje cenovú mriežku. Izoluj ju do vyhradenej štruktúry namiesto toho, aby si konštanty rozhadzoval po celom kóde: keď sa ceny zmenia alebo pridáš model, stačí upraviť jeden riadok. Nižšie uvedené sadzby sú orientačné a mali by sa overovať pri každej kontrole rozpočtu.
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
Osem desatín centu za volanie znie upokojujúco, kým to nevynásobíš päťdesiatimi tisícmi denných volaní produkčného chatbota – to je štyristo dolárov denne. Vždy si zvykaj myslieť v mesačných objemoch, nikdy nie per volanie.
Tracker nákladov v reálnom čase
Výpočty jednotkových cien sú zbytočné, ak nie sú agregované. Tento tracker agreguje výdavky podľa troch osí – podľa dňa, podľa modelu a podľa počtu volaní – a porovnáva denný súčet s rozpočtom, ktorý si nastavil. Upozornenia sú gradované: varovanie, keď zostane menej ako 20 % rozpočtu, nasledované tvrdým alertom po prekročení limitu. Tento medzikrok je cenný, pretože ti dáva čas zasiahnuť skôr, než bude služba odstavená.
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))
Klient s kontrolou rozpočtu
Monitorovanie nie vždy stačí: ak čelíš chybnému cyklu, ktorý neustále volá API, potrebuješ finančný istič. Tento klient skontroluje zostávajúci rozpočet pred vydaním požiadavky a ak je obálka vyčerpaná, volanie jednoducho odmietne. Služba sa degraduje, ale kontrolovaným spôsobom bez prekvapivých účtov. Účtovanie nákladov prebieha až afterward, keď je známe skutočné využitie.
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}")
Optimalizácia nákladov
1. Výber správneho modelu
Najsilnejšou pákou zostáva smerovanie podľa zložitosti. Úloha klasifikácie do troch kategórií nepotrebuje najdrahší model: pri tejto úlohe dosahuje rozdiel vo fakturácii násobok dvadsaťpäť pri identickej kvalite. Urob zo zložitosti explicitný parameter svojej funkcie namiesto rozhodnutia natvrdo zakódovaného v logike.
# 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. Ukladanie odpovedí do cache
Druhou pákou je vyhnutie sa platbe dvakrát za tú istú odpoveď. FAQ, katalóg produktov alebo štandardný formulár generujú desiatkykrát denne úplne totožné výzvy. Kľúč cache kombinuje model, vstup a parametre – zahrnutie všetkých je nevyhnutné, inak by zmena teploty ticho vrátila starú odpoveď.
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. Obmedzenie výstupných tokenov
Nakoniec, vždy obmedz výstup tam, kde je jeho dĺžka predvídateľná. Keďže výstup je drahšia časť, požiadavka na jedno slovo pri povolení dvoch tisíc tokenov necháva dvere otvorené pre ukecanú odpoveď, za ktorú zaplatíš, ale nevyužiješ ju.
# 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
)
Sadzby platné k 5. augustu 2026 – ceny sa pravidelne menia: pred akýmkoľvek výpočtom rozpočtu si over aktuálnu mriežku na oficiálnej stránke s cenami OpenAI.
Kľúčové poznatky
- Náklady závisia od modelu A smeru (vstup vs. výstup)
- Implementuj tracker nákladov s alertmi pre rozpočet
- Používaj správny model pre každú úlohu: Luna pre objem, Terra ako predvolený
- Cache môže drasticky znížiť náklady pri opakovaných požiadavkách
- Nastav
max_output_tokens, keď je dĺžka odpovede predvídateľná - Kontroluj dashboard OpenAI pre oficiálne sledovanie spotreby