Kustannusten ja käytön seuranta
Tällä sivulla
Kustannusten ja käytön seuranta
API-kustannukset voivat karata käsistä nopeasti, jos et seuraa niitä. Tämä oppitunti opettaa sinulle, kuinka seuraat, arvioit ja hallitset kulujasi tuotantoympäristössä. Tarina toistuu projektista toiseen: ominaisuus julkaistaan torstaina, kukaan ei tarkista kojelautaa viikonlopun aikana, ja maanantaiaamun lasku vastaa koko kuukauden budjettia. Alla olevat vaiheet auttavat sinua havaitsemaan kustannusten ajautumisen heti, kun se tapahtuu, eivät kolmekymmentä päivää myöhemmin.
Laskutuksen ymmärtäminen
Kustannukset lasketaan miljoonaa tokenia kohden, ja syötteelle sekä tulosteelle on eri hinnat. Tällä epäsymmetrialla on suoria seurauksia suunnitteluratkaisuihisi: pitkän dokumentin lähettäminen syötteenä maksaa huomattavasti vähemmän kuin mallin pyytäminen tuottamaan pitkä vastaus. Jokainen vastaus palauttaa tarkan määrän molempiin suuntiin, joten sinun ei tarvitse koskaan arvioida niitä.
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!
Kustannuslaskuri
Näiden laskureiden muuntaminen dollareiksi vaatii hintataulukon. Eristä se omaan rakenteeseensa sen sijaan, että hajottaisit vakioita koodisi ympäri: kun hinnat muuttuvat tai lisäät mallin, sinun tarvitsee muokata vain yhtä riviä. Alla olevat hinnat ovat suuntaa antavia, ja ne tulee tarkistaa jokaisen budjettikatsauksen yhteydessä.
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
Kahdeksan kymmenesosaa senttiä pyyntöä kohden kuulostaa lohduttavalta, kunnes kerrot sen tuotantobotin viidelläkymmenellä tuhannella päivittäisellä pyynnöllä – se tekee neljäsataa dollaria päivässä. Totu aina ajattelemaan kuukausittaisia volyymeja, äläkä yksittäisiä pyyntöjä.
Reaaliaikainen kustannusseuranta
Yksikkölaskelmat ovat hyödyttömiä, ellei niitä aggregoida. Tämä seuranta kerää kulut kolmella akselilla – päivittäin, malleittain ja pyyntöjen lukumäärän mukaan – ja vertaa päivän kokonaissummaa asettamaasi budjettiin. Hälytykset ovat porrastettuja: varoitus, kun budjetista on jäljellä alle 20 %, ja sen jälkeen kova hälytys rajan ylittyessä. Tämä välivaihe on arvokas, koska se antaa sinulle aikaa puuttua asiaan ennen palvelun katkaisua.
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))
Asiakasohjelma budjetinhallinnalla
Pelkkä seuranta ei aina riitä: jos kohtaat viallisen silmukan, joka kutsuu API:a jatkuvasti, tarvitset taloudellisen varokatkaisijan. Tämä asiakasohjelma tarkistaa jäljellä olevan budjetin ennen pyynnön lähettämistä ja kieltäytyy suorastaan pyynnöstä, jos budjetti on käytetty loppuun. Palvelu heikkenee, mutta hallitusti ilman yllättäviä laskuja. Kustannusten kirjanpito tapahtuu jälkikäteen, kun todellinen käyttö on tiedossa.
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}")
Kustannusten optimointi
1. Oikean mallin valinta
Tehokkain vipu on edelleen reititys vaativuuden mukaan. Kolmen luokan luokittelutehtävä ei tarvitse kalleinta mallia: tässä tehtävässä laskun ero voi olla kaksikymmentäviisinkertainen samalla laadulla. Tee vaativuudesta funktion eksplisiittinen parametri äläkä kovakoodattua päätöstä logiikkaan.
# 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. Vastausten välimuistitus
Toinen vipu on välttää maksamasta kahdesti samasta vastauksesta. Usein kysytyt kysymykset (FAQ), tuoteluettelot tai standardilomakkeet tuottavat täysin identtisiä kehotteita kymmeniä kertoja päivässä. Välimuistin avain yhdistää mallin, syötteen ja parametrit – kaikkien sisällyttäminen on välttämätöntä, muuten lämpötilan muutos palauttaisi hiljaa vanhan vastauksen.
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. Tulostetokenien rajoittaminen
Lopuksi, aseta yläraja tulosteelle aina, kun sen pituus on ennustettavissa. Koska tuloste on kallis osa, yhden sanan pyytäminen sallimalla kaksi tuhatta tokenia jättää oven auki puheliaselle vastaukselle, josta maksat, mutta jota et käytä.
# 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
)
Hinnat 5. elokuuta 2026 – hinnat muuttuvat säännöllisesti: ennen kuin teet budjettilaskelmia, tarkista nykyinen hintataulukko OpenAI:n viralliselta hinnoittelusivulta.
Keskeiset asiat
- Kustannukset riippuvat mallista JA suunnasta (syöte vs. tuloste)
- Toteuta kustannusseuranta budjettihälytyksillä
- Käytä oikeaa mallia jokaiseen tehtävään: Luna volyymiin, Terra oletuksena
- Välimuistitus voi vähentää kustannuksia dramaattisesti toistuvissa pyynnöissä
- Aseta
max_output_tokens, kun vastauksen pituus on ennustettavissa - Tarkista OpenAI:n kojelauta virallista kulutusseurantaa varten