Monitorowanie kosztów i zużycia
Na tej stronie
Monitorowanie kosztów i zużycia
Koszty API mogą wymknąć się spod kontroli błyskawicznie, jeśli ich nie pilnujesz. Ta lekcja nauczy Cię, jak śledzić, szacować i kontrolować wydatki w środowisku produkcyjnym. Historia powtarza się z projektu na projekt: funkcja wchodzi na produkcję w czwartek, nikt nie sprawdza panelu w weekend, a poniedziałkowy rachunek równa się całemu miesięcznemu budżetowi. Poniższe kroki pomogą Ci wykryć dryf kosztów w momencie jego wystąpienia, a nie trzydzieści dni później.
Zrozumienie rozliczeń
Koszty są naliczane za milion tokenów, przy czym ceny dla danych wejściowych (input) i wyjściowych (output) różnią się. Ta asymetria ma bezpośrednie konsekwencje dla wyborów projektowych: wysłanie długiego dokumentu jako dane wejściowe kosztuje znacznie mniej niż wygenerowanie przez model długiej odpowiedzi. Każda odpowiedź zwraca dokładną liczbę tokenów w obu kierunkach, więc nigdy nie musisz nic szacować.
from openai import OpenAI
client = OpenAI()
# Każda odpowiedź zawiera metryki zużycia
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}")
# Wyjście kosztuje więcej niż wejście!
Kalkulator kosztów
Przeliczenie tych liczników na dolary wymaga siatki cenowej. Wyodrębnij ją w dedykowanej strukturze, zamiast rozrzucać stałe po całym kodzie: gdy ceny się zmienią lub dodasz nowy model, musisz zmodyfikować tylko jedną linię. Poniższe stawki są orientacyjne i należy je weryfikować podczas każdego przeglądu budżetu.
from dataclasses import dataclass
@dataclass
class ModelRate:
input_per_million: float
output_per_million: float
# Przybliżone ceny w USD za milion tokenów
# Zawsze sprawdzaj aktualne ceny na 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:
"""Oblicza koszt wywołania w 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
# Przykład
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Wynik: Cost: $0.008000
Osiem dziesiątych centa za wywołanie brzmi uspokajająco, dopóki nie pomnożysz tego przez pięćdziesiąt tysięcy dziennych wywołań produkcyjnego chatbota – to czterysta dolarów dziennie. Zawsze wyrabiaj w sobie nawyk myślenia w kategoriach miesięcznych wolumenów, nigdy pojedynczych wywołań.
Tracker kosztów w czasie rzeczywistym
Obliczenia jednostkowe są bezużyteczne, jeśli nie zostaną zagregowane. Ten tracker sumuje wydatki w trzech przekrojach: dziennie, według modelu oraz według liczby wywołań, a następnie porównuje dzienną sumę do ustalonego budżetu. Alerty są stopniowane: ostrzeżenie, gdy pozostało mniej niż 20% budżetu, followed by twardy alert po przekroczeniu limitu. Ten pośredni krok jest cenny, ponieważ daje Ci czas na interwencję przed odcięciem usługi.
import json
from datetime import datetime, date
from collections import defaultdict
class CostTracker:
"""Śledzenie kosztów API w czasie rzeczywistym."""
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):
"""Rejestruje koszty wywołania."""
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:
"""Zwraca pozostały budżet na dziś."""
today = date.today().isoformat()
return self.daily_budget - self.costs_per_day[today]
def budget_alert(self) -> bool:
"""Sprawdza, czy budżet zbliża się do limitu."""
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:
"""Generuje raport kosztów."""
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,
}
# Użycie
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 z kontrolą budżetu
Samo monitorowanie nie zawsze wystarcza: w obliczu błędnej pętli ciągle wywołującej API potrzebujesz finansowego wyłącznika awaryjnego (circuit breaker). Ten klient sprawdza pozostały budżet przed wysłaniem żądania i stanowczo odmawia wykonania wywołania, jeśli koperta jest wyczerpana. Usługa ulega degradacji, ale w sposób kontrolowany, bez niespodzianek na fakturze. Księgowanie kosztów następuje afterward, gdy znane jest rzeczywiste zużycie.
class BudgetControlledClient:
"""Klient odmawiający wywołań po przekroczeniu budżetu."""
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:
"""Wywołanie API z kontrolą budżetu."""
# Sprawdź budżet przed wywołaniem
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, jeśli budżet jest niski
self.tracker.budget_alert()
return response
# Użycie
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}")
Optymalizacja kosztów
1. Wybór odpowiedniego modelu
Najpotężniejszym dźwigiem pozostaje routowanie ze względu na złożoność. Zadanie klasyfikacji w trzech kategoriach nie potrzebuje najdroższego modelu: w tym przypadku różnica w rachunku sięga dwudziestu pięciu razy przy identycznej jakości. Uczyń złożoność jawnym parametrem swojej funkcji, zamiast decyzji zaszytej na sztywno w logice.
# Względny koszt na zadanie (przybliżony, ~300 tokenów wejścia / 20 wyjścia):
# Prosta klasyfikacja: gpt-5.6-luna ~0,0001$ vs gpt-5.6-sol ~0,002$
# Właściwy model robi 25-krotną różnicę w kosztach!
def optimized_call(prompt: str, complexity: str) -> str:
"""Wybiera najbardziej ekonomiczny odpowiedni 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. Buforowanie odpowiedzi (Caching)
Drugim dźwigiem jest unikanie płacenia dwa razy za tę samą odpowiedź. FAQ, katalog produktów czy standardowy formularz generują dziesiątki razy dziennie ściśle identyczne prompty. Klucz cache’a łączy model, dane wejściowe i parametry – uwzględnienie ich wszystkich jest kluczowe, inaczej zmiana temperatury po cichu zwróciłaby starą odpowiedź.
import hashlib
class CachedClient:
"""Klient z cache'em, aby uniknąć zbędnych wywołań."""
def __init__(self):
self.client = OpenAI()
self.cache: dict[str, str] = {}
def create(self, model: str, input: str, **kwargs) -> str:
# Utwórz klucz cache'a
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. Limitowanie tokenów wyjściowych
Na koniec, ograniczaj wyjście zawsze, gdy jego długość jest przewidywalna. Ponieważ wyjście jest droższą częścią, proszenie o pojedyncze słowo przy autoryzacji dwóch tysięcy tokenów zostawia otwarte drzwi dla rozwlekłej odpowiedzi, za którą zapłacisz, ale jej nie wykorzystasz.
# Zawsze ustawiaj max_output_tokens dla przewidywalnych zadań
response = client.responses.create(
model="gpt-5.6-terra",
input="Classify this text: positive, negative, or neutral.",
max_output_tokens=10 # Oczekujemy pojedynczego słowa
)
Stawki na dzień 5 sierpnia 2026 r. – ceny zmieniają się regularnie: przed jakimkolwiek obliczeniem budżetu zweryfikuj aktualną siatkę na oficjalnej stronie cenowej OpenAI.
Kluczowe wnioski
- Koszty zależą od modelu ORAZ kierunku (wejście vs wyjście)
- Wdróż tracker kosztów z alertami budżetowymi
- Używaj właściwego modelu do każdego zadania: Luna do dużych wolumenów, Terra domyślnie
- Cache’owanie może drastycznie obniżyć koszty dla powtarzalnych żądań
- Ustawiaj
max_output_tokens, gdy długość odpowiedzi jest przewidywalna - Sprawdzaj panel OpenAI w celu oficjalnego śledzenia zużycia