Költségek és használat monitorozása
Ezen az oldalon
Költségek és használat monitorozása
Az API-költségek gyorsan elszabadulhatnak, ha nem figyeled őket. Ez a lecke megtanít, hogyan követheted nyomon, becsülheted meg és tarthatod kordában a kiadásaidat éles környezetben. A történet projektől projektig ismétli önmagát: egy funkció csütörtökön élesedik, hétvégén senki nem nézi a vezérlőpultot, hétfő reggelre pedig a számla eléri a teljes havi keretet. Az alábbi lépések segítenek abban, hogy a költségvetési eltérést azonnal észleld, ne harminc nappal később.
Számlázás megértése
A költségeket milliónyi tokenre számítják, különböző árakkal a bemeneti (input) és kimeneti (output) adatokra. Ennek az aszimmetriának közvetlen hatása van a tervezési döntéseidre: egy hosszú dokumentum bemenetként való elküldése jelentősen olcsóbb, mint ha a modell generálna egy hosszú választ. Minden válasz pontosan visszaadja mindkét irány tokenszámát, így sosem kell becslésekkel dolgoznod.
from openai import OpenAI
client = OpenAI()
# Minden válasz tartalmazza a használati metrikákat
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}")
# A kimenet többe kerül, mint a bemenet!
Költségszámoló
Ezeknek a számlálóknak dollárra való átváltása egy ártáblázatot igényel. Zárd ezt egy dedikált szerkezetbe, ahelyett, hogy konstansokat szór szét a kódodban: ha az árak változnak vagy új modellt adsz hozzá, csak egy sort kell módosítanod. Az alábbi árak tájékoztató jellegűek, és minden költségvetési felülvizsgálatkor ellenőrizni kell őket.
from dataclasses import dataclass
@dataclass
class ModelRate:
input_per_million: float
output_per_million: float
# Hozzávetőleges árak USD-ben milliónyi tokenre
# Mindig ellenőrizd az aktuális árakat a platform.openai.com/pricing oldalon
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:
"""Kiszámítja egy hívás költségét USD-ben."""
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
# Példa
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Eredmény: Cost: $0.008000
Hívásonként nyolctized cent megnyugtatónak hangozhat, egészen addig, amíg meg nem szorzod egy éles chatbot napi ötvenezer hívásával – ez napi négyszáz dollár. Szokd rá magad, hogy mindig havi volumenben gondolkodj, sosem hívásonként.
Valós idejű költségnyelvő
Az egységszámítások önmagukban haszontalanok, ha nem aggregálod őket. Ez a nyelvező három tengely mentén összesíti a kiadásokat – naponta, modellenként és hívásszámonként –, és összehasonlítja a napi összeget az általad meghatározott költségvetéssel. A riasztások fokozatosak: figyelmeztetés, ha a költségvetés kevesebb mint 20%-a maradt, majd hard riasztás a limit túllépésekor. Ez a közbenső lépés értékes, mert időt ad a beavatkozásra, mielőtt a szolgáltatást leállítanák.
import json
from datetime import datetime, date
from collections import defaultdict
class CostTracker:
"""Valós idejű API-költségkövetés."""
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):
"""Rögzíti egy hívás költségeit."""
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:
"""Visszaadja a mai napra fennmaradó költségvetést."""
today = date.today().isoformat()
return self.daily_budget - self.costs_per_day[today]
def budget_alert(self) -> bool:
"""Ellenőrzi, hogy a költségvetés közel van-e a limithez."""
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:
"""Költségjelentést generál."""
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,
}
# Használat
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))
Költségvetés-vezérelt kliens
A monitorozás nem mindig elég: egy hibás, folyamatosan API-t hívó ciklus esetén pénzügyi megszakítóra (circuit breaker) van szükséged. Ez a kliens a kérés elküldése előtt ellenőrzi a fennmaradó költségvetést, és határozottan elutasítja a hívást, ha a keret kimerült. A szolgáltatás degradálódik, de ellenőrzött módon, meglepetésszámlák nélkül. A költségelszámolás utólag történik, miután a tényleges használat ismertté vált.
class BudgetControlledClient:
"""Kliens, amely elutasítja a hívásokat, ha a költségvetés túllépi a limitet."""
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-hívás költségvetés-ellenőrzéssel."""
# Költségvetés ellenőrzése a hívás előtt
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
)
# Riasztás, ha alacsony a költségvetés
self.tracker.budget_alert()
return response
# Használat
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}")
Költségek optimalizálása
1. A megfelelő modell kiválasztása
A leghatékonyabb eszköz továbbra is a komplexitás szerinti útvonalválasztás. Egy három kategóriás osztályozási feladatnak nincs szüksége a legdrágább modellre: ennél a feladatnál a számla különbsége huszonötszörös lehet azonos minőség mellett. Tedd a komplexitást a függvényed explicit paraméterévé, ne pedig a logikába hardcoded döntéssé.
# Relatív költség feladatonként (hozzávetőleges, ~300 bemeneti token / 20 kimeneti):
# Egyszerű osztályozás: gpt-5.6-luna ~0,0001 $ vs gpt-5.6-sol ~0,002 $
# A megfelelő modell 25-szörös különbséget jelent a költségekben!
def optimized_call(prompt: str, complexity: str) -> str:
"""Kiválasztja a leggazdaságosabb megfelelő modellt."""
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. Válaszok gyorsítótárazása
A második eszköz, hogy elkerüld ugyanazon válasz kétszeri kifizetését. Egy GYIK, termékkatalógus vagy szabványos űrlap naponta tucatszor generál szigorúan azonos promptokat. A gyorsítótár kulcsa egyesíti a modellt, a bemenetet és a paramétereket – mindet beleértve elengedhetetlen, különben egy hőmérséklet-változás csendesen a régi választ adná vissza.
import hashlib
class CachedClient:
"""Kliens gyorsítótárral a felesleges hívások elkerülésére."""
def __init__(self):
self.client = OpenAI()
self.cache: dict[str, str] = {}
def create(self, model: str, input: str, **kwargs) -> str:
# Gyorsítótár kulcs létrehozása
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. Kimeneti tokenek korlátozása
Végül, korlátozd a kimenetet, amikor annak hossza előre jelezhető. Mivel a kimenet a drága rész, ha egyetlen szót kérsz, de engedélyezel kétezer tokent, az utat nyitja egy bőbeszédű válasz előtt, amit kifizetsz, de nem használsz fel.
# Mindig állítsd be a max_output_tokens értéket előre jelezhető feladatoknál
response = client.responses.create(
model="gpt-5.6-terra",
input="Classify this text: positive, negative, or neutral.",
max_output_tokens=10 # Egyetlen szóra számítunk
)
Árak 2026. augusztus 5-i állapot szerint — az árak rendszeresen változnak: bármilyen költségvetési számítás előtt ellenőrizd az aktuális ártáblázatot a hivatalos OpenAI árazási oldalon.
Főbb megállapítások
- A költségek a modelltől ÉS az iránytól függenek (bemenet vs. kimenet)
- Implementálj költségkövetőt költségvetési riasztásokkal
- Használd a megfelelő modellt minden feladathoz: Luna nagy volumenhez, Terra alapértelmezettként
- A gyorsítótárazás drasztikusan csökkentheti a költségeket az ismétlődő kéréseknél
- Állítsd be a
max_output_tokensértéket, ha a válasz hossza előre jelezhető - Ellenőrizd az OpenAI vezérlőpultot a hivatalos fogyasztáskövetéshez