Övervaka kostnader och användning
På denna sida
Övervaka kostnader och användning
API-kostnader kan snabbt spåra ur om du inte håller koll på dem. I den här lektionen lär du dig hur du spårar, uppskattar och kontrollerar dina utgifter i produktion. Historien upprepar sig projekt efter projekt: en funktion lanseras på en torsdag, ingen kollar dashboards under helgen, och på måndag morgon matchar fakturan hela månadsbudgeten. Stegen nedan hjälper dig att fånga kostnadsavvikelser i samma stund de inträffar, inte trettio dagar senare.
Förstå fakturering
Kostnader beräknas per miljon tokens, med olika priser för inmatning (input) och utmatning (output). Denna asymmetri får direkta konsekvenser för dina designval: att skicka ett långt dokument som inmatning kostar betydligt mindre än att låta modellen generera ett långt svar. Varje svar returnerar den exakta räkningen för båda riktningarna, så du behöver aldrig gissa.
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!
Kostnadskalkylator
Att omvandla dessa räknare till dollar kräver en prislista. Isolera den i en dedikerad struktur istället för att sprida konstanter genom hela din kod: när priser ändras eller du lägger till en modell behöver du bara modifiera en rad. Priserna nedan är vägledande och bör verifieras vid varje budgetgranskning.
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
Åtta tiondels cent per anrop låter betryggande tills du multiplicerar det med de femtio tusen dagliga anropen från en produktionschatbot – det blir fyrahundra dollar om dagen. Vänj dig alltid vid att tänka i månadsvolymer, aldrig per anrop.
Realtids-spårare för kostnader
Enhetsberäkningar är värdelösa om de inte aggregeras. Denna spårare sammanställer utgifter längs tre axlar – per dag, per modell och per antal anrop – och jämför dagens totala summa med en budget du har satt. Aviseringarna är graderade: en varning när mindre än 20 % av budgeten återstår, följt av en hård varning när gränsen överskrids. Detta mellansteget är värdefullt eftersom det ger dig tid att ingripa innan tjänsten stängs av.
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))
Klient med budgetkontroll
Övervakning räcker inte alltid: vid en felaktig loop som anropar API:t kontinuerligt behöver du en ekonomisk strömbrytare. Denna klient kontrollerar återstående budget innan begäran skickas och vägrar rakt ut att utföra anropet om ramen är uttömd. Tjänsten försämras, men på ett kontrollerat sätt utan överraskningsfakturor. Kostnadsredovisningen sker efteråt, när faktisk användning är känd.
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}")
Optimera kostnader
1. Välj rätt modell
Den kraftfullaste hävstången är fortfarande routning baserad på komplexitet. En klassificeringsuppgift med tre kategorier har inget behov av den dyraste modellen: för denna uppgift når skillnaden i faktura en faktor på tjugofem vid samma kvalitet. Gör komplexitet till en explicit parameter i din funktion istället för ett beslut hårdkodat i logiken.
# 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. Cacha svar
Den andra hävstången är att undvika att betala två gånger för samma svar. En FAQ, produktkatalog eller ett standardformulär genererar strikt identiska prompts dussintals gånger om dagen. Cache-nyckeln kombinerar modell, inmatning och parametrar – att inkludera alla är avgörande, annars skulle en ändring i temperaturen tyst returnera det gamla svaret.
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. Begränsa utmatningstokens
Avslutningsvis, sätt ett tak för utmatningen när dess längd är förutsägbar. Eftersom utmatning är den dyra delen, lämnar du dörren öppen för ett verbost svar som du betalar för men inte använder om du ber om ett enda ord men tillåter två tusen tokens.
# 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
)
Priser från den 5 augusti 2026 – priser ändras regelbundet: innan någon budgetberäkning, verifiera den aktuella prislistan på den officiella OpenAI-prissidan.
Viktiga punkter
- Kostnader beror på modellen OCH riktningen (inmatning kontra utmatning)
- Implementera en kostnadsspårare med budgetvarningar
- Använd rätt modell för varje uppgift: Luna för volym, Terra som standard
- Cachning kan drastiskt minska kostnaderna för repetitiva förfrågningar
- Sätt
max_output_tokensnär svarslängden är förutsägbar - Kontrollera OpenAI-dashboarden för officiell spårning av förbrukning