Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Övervaka kostnader och användning

Lektion 16 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Övervaka kostnader och användning
  2. Förstå fakturering
  3. Kostnadskalkylator
  4. Realtids-spårare för kostnader
  5. Klient med budgetkontroll
  6. Optimera kostnader
  7. Viktiga punkter

Ö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_tokens när svarslängden är förutsägbar
  • Kontrollera OpenAI-dashboarden för officiell spårning av förbrukning