Monatóireacht a dhéanamh ar chostais agus ar úsáid
Ar an leathanach seo
Monatóireacht a dhéanamh ar chostais agus ar úsáid
Is féidir le costais API dul amú go tapa mura ndéanann tú faire orthu. Múineann an ceacht seo duit conas do chaitheamh airgid a rianú, a mheas agus a rialú i dtimpeallacht táirgthe. Is minic a fheictear an scéal céanna ó thionscadal go tionscadal: cuirtear gné ar fáil Déardaoin, ní sheiceálann aon duine an deasc rialaithe thar an deireadh seachtaine, agus bíonn an bille Dé Luain chomh mór leis an mbuiséad míosúil iomlán. Cuidíonn na céimeanna thíos leat claonadh costais a bhrath díreach nuair a tharlaíonn sé, seachas tríocha lá ina dhiaidh sin.
Tuiscint a fháil ar bhilleáil
Ríomhtar costais in aghaidh an mhilliúin tócan, le praghsanna éagsúla d’ionchur agus d’aschur. Tá tionchar díreach ag an éagothroime seo ar do roghanna dearaidh: costóidh sé i bhfad níos lú doiciméad fada a sheoladh mar ionchur ná mar a chosnóidh sé ar an tsamhail ceann fada a ghiniúint. Tugann gach freagra an comhaireamh cruinn don dá threo, mar sin ní gá duit meastachán a dhéanamh riamh.
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!
Áireamhán costais
Chun na comhairimh seo a thiontú go dollar, teastaíonn greille praghsála. Leithlisigh í i struchtúr tiomnaithe seachas tairisigh a scaipeadh ar fud do chóid: nuair a athraíonn praghsanna nó nuair a chuireann tú samhail leis, ní gá duit ach líne amháin a mhodhnú. Tá na rátaí thíos táscach agus ba chóir iad a fhíorú le linn gach athbhreithnithe buiséid.
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
Fuaimeann ocht ndeichiú de chent in aghaidh na glaonna suaimhneach go dtí go n-iolraíonn tú é faoi chaoga míle glao laethúil chatbhot táirgthe – sin ceithre chéad dollar in aghaidh an lae. Bíodh sé de nós agat smaoineamh i dtéarmaí toirteanna míosúla i gcónaí, ní riamh in aghaidh na glaonna.
Rianaire costais fíor-ama
Níl aon mhaith i ríomhaireachtaí aonaid mura ndéantar iad a chomhiomlánú. Déanann an rianaire seo caiteachas a chomhiomlánú ar thrí ais – in aghaidh an lae, in aghaidh na samhla, agus de réir líon na nglao – agus déanann sé comparáid idir iomlán an lae agus buiséad a shocraíonn tú. Tá aláraim chéimnithe ann: rabhadh nuair a bhíonn níos lú ná 20% den bhuiséad fágtha, agus aláraim chrua ina dhiaidh sin nuair a sháraítear an teorainn. Tá an chéim idirmheánach seo luachmhar toisc go dtugann sé am duit idirghabháil a dhéanamh sula ngearrtar an seirbhís.
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))
Cliant le rialú buiséid
Ní leor monatóireacht i gcónaí: os comhair lúba lochtacha a ghlaonn ar an API go leanúnach, teastaíonn briseadh ciorcaid airgeadais uait. Seiceálann an cliant seo an buiséad atá fágtha sula seoltar an t-iarratas agus diúltaíonn sé don ghlao go hiomlán má tá an clúdach ídithe. Meathlaíonn an tseirbhís, ach ar bhealach rialaithe gan billí gan choinne. Tarlaíonn cuntasaíocht costais ina dhiaidh sin, nuair a bheidh an úsáid iarbhír ar eolas.
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}")
Costais a bharrfheabhsú
1. An tsamhail cheart a roghnú
Is é an luamhán is cumhachtaí fós ná ródaí de réir castachta. Níl aon ghá leis an tsamhail is costasaí do thasc aicmithe trí chatagóir: don tasc seo, sroicheann an difríocht sa bhille fachtóir fiche a cúig le haghaidh cáilíochta comhionainne. Déan paraiméadar sainráite de do fheidhm den chastaacht seachas cinneadh atá crua-chódaithe sa loighic.
# 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. Freagraí a chur i dtaisce
Is é an dara luamhán ná íoc as an bhfreagra céanna faoi dhó a sheachaint. Gineann Ceisteanna Coitianta (FAQ), catalóg táirgí, nó foirm chaighdeánach leideanna atá go hiomlán comhionann dosaen uair sa lá. Comhcheanglaíonn eochair an taisce an tsamhail, an t-ionchur agus na paraiméadair – tá sé riachtanach iad go léir a chur san áireamh, murach sin d’fhillfeadh athrú teochta an freagra sean go ciúin.
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. Tócan aschuir a theorannú
Ar deireadh, cuir teorainn leis an aschur nuair is féidir a fhad a thuar. Ós rud é gurb é an t-aschur an chuid is costasaí, má iarrann tú focal amháin agus má údaróidh tú dhá mhíle tócan, fágann sé an doras ar oscailt do fhreagra fochallach a íocfaidh tú as ach nach n-úsáidfidh tú.
# 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
)
Rátaí ón 5 Lúnasa 2026 — athraíonn praghsanna go rialta: roimh aon ríomh buiséid, fíoraigh an ghreille reatha ar an leathanach oifigiúil praghsála OpenAI.
Príomhphointí
- Braitheann costais ar an tsamhail AGUS ar an treo (ionchur vs aschur)
- Cuir rianaire costais i bhfeidhm le haláraim bhuiséid
- Úsáid an tsamhail cheart do gach tasc: Luna do thoirt, Terra mar réamhshocrú
- Is féidir le taisceadh costais a laghdú go mór d’iarratais athfhillteacha
- Socraigh
max_output_tokensnuair is féidir fad na freagra a thuar - Seiceáil deasc OpenAI le haghaidh rianú oifigiúil tomhaltais