Monitoraġġ tal-ispejjeż u l-użu
F'din il-paġna
Monitoraġġ tal-ispejjeż u l-użu
L-ispejjeż tal-API jistgħu joħorġu mill-kontroll malajr ħafna jekk ma tħarisx lejhom. Din il-lezzjoni tgħallmek kif issegwi, tistma, u tikkontrolla n-nefqa tiegħek fil-produzzjoni. L-istorja tirrepeti ruħha minn proġett għal ieħor: karatteristika tidħol ħajja nhar il-Ħamis, ħadd ma jiċċekkja d-dashboard matul il-ġimgħa, u l-kont ta’ nhar it-Tnejn filgħodu jkun daqs il-baġit sħiħ tax-xahar. Il-passi hawn taħt jgħinuk taqbad id-devjazzjoni tal-ispejjeż hekk kif iseħħu, mhux tletin jum wara.
Fehim tal-fatturazzjoni
L-ispejjeż jiġu kkalkulati għal kull miljun token, bi prezzijiet differenti għall-input u l-output. Din l-asimmetrija għandha konsegwenzi diretti fuq il-għażliet tad-disinn tiegħek: li tibgħat dokument twil bħala input jiswef ferm inqas milli tħalli l-mudell jiġġenera wieħed twil. Kull tweġiba tirritorna l-għadd eżatt għaż-żewġ direzzjonijiet, allura qatt m’għandek bżonn tistma.
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!
Kalkolatur tal-ispejjeż
Il-konverżjoni ta’ dawn il-kontaturi f’dollari teħtieġ gradilja tal-prezzijiet. Iżolaha f’struttura ddedikata minflok ma tferrex kostanti madwar il-kodiċi tiegħek: meta jinbidlu l-prezzijiet jew iżżid mudell, ikollok bżonn timmodifika linja waħda biss. Ir-rati hawn taħt huma indikattivi u għandhom jiġu vverifikati matul kull reviżjoni tal-baġit.
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
Tmienja minn għaxra ta’ ċenteżmu għal kull sejħa tidher rassiguranti sakemm timmultiplikaha bl-ħamsin elf sejħa kuljum ta’ chatbot fil-produzzjoni—dik hija erba’ mitt dollaru kuljum. Dejjem idda l-abitudni li taħseb f’volumi mensili, qatt mhux għal kull sejħa.
Traċċar tal-ispejjeż f’ħin reali
Il-kalkoli tal-unitajiet huma inutili jekk ma jiġux aggregati. Dan it-traċċar jaggrega n-nefqa fuq tliet assi—skont il-jum, skont il-mudell, u skont in-numru ta’ sejħiet—u jqabbel it-total tal-jum ma’ baġit li tkun stabbilejt. L-allerti huma gradwati: twissija meta jifdal inqas minn 20% tal-baġit, segwita minn allert iebsa meta tinqabeż il-limitu. Dan il-pass intermedjarju huwa prezzjuż għax jagħtik ħin biex tintervjeni qabel ma jitqatta’ s-servizz.
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 b’kontroll tal-baġit
Il-monitoraġġ mhux dejjem biżżejjed: quddiem loop difettuża li ssejjaħ l-API kontinwament, għandek bżonn “circuit breaker” finanzjarju. Dan il-klijent jiċċekkja l-baġit li fadal qabel ma joħroġ it-talba u jirrifjuta ċ-ċar is-sejħa jekk l-invilupp ikun eżawrit. Is-servizz jiddeterjora, iżda b’mod ikkontrollat mingħajr kontijiet sorprendenti. Il-kontabbiltà tal-ispejjeż iseħħ wara, ladarba l-użu attwali jkun magħruf.
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}")
Ottimizzazzjoni tal-ispejjeż
1. Għażla tal-mudell it-tajjeb
Il-leva l-aktar qawwija tibqa’ r-routing skont il-kumplessità. Kompitu ta’ klassifikazzjoni fi tliet kategoriji m’għandux bżonn l-aktar mudell għali: għal dan il-kompitu, id-differenza fil-kont tilħaq fattur ta’ ħamsa u għoxrin għal kwalità identika. Agħmel il-kumplessità parametru espliċitu tal-funzjoni tiegħek minflok deċiżjoni mwaħħla fil-loġika.
# 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. Caching tat-tweġibiet
It-tieni leva hija li tevita li tħallas darbtejn għall-istess tweġiba. FAQ, katalogu tal-prodotti, jew formola standard jiġġeneraw prompts identiċi għalkollox għexieren ta’ drabi kuljum. Iċ-ċavetta tal-cache tgħaqqad il-mudell, l-input, u l-parametri—li tinkludihom kollha huwa essenzjali, inkella bidla fit-temperatura tirritorna silenzjużament it-tweġiba l-qadima.
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. Limitazzjoni tat-tokens tal-output
Fl-aħħar nett, poġġi limitu fuq l-output kull meta t-tul tiegħu jkun prevedibbli. Peress li l-output huwa l-parti għalja, li titlob kelma waħda waqt li tawtorizza elfejn token iħalli l-bieb miftuħ għal tweġiba verbali li tħallas għaliha iżda ma tużahiex.
# 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
)
Rati sal-5 ta’ Awwissu 2026 — il-prezzijiet jinbidlu regolarment: qabel kwalunkwe kalkolu tal-baġit, ivverifika l-gradilja attwali fuq il-paġna uffiċjali tal-prezzijiet ta’ OpenAI.
Punti Ewlenin
- L-ispejjeż jiddependu mill-mudell U d-direzzjoni (input vs output)
- Implimenta traċċar tal-ispejjeż b’allerti tal-baġit
- Uża l-mudell it-tajjeb għal kull kompitu: Luna għall-volum, Terra b’mod default
- Il-caching jista’ jnaqqas drammatikament l-ispejjeż għal talbiet ripetittivi
- Stabbilixxi
max_output_tokensmeta t-tul tat-tweġiba jkun prevedibbli - Iċċekkja d-dashboard ta’ OpenAI għat-traċċar uffiċjali tal-konsum