Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Overvågning af omkostninger og forbrug

Lektion 16 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Overvågning af omkostninger og forbrug
  2. Forståelse af fakturering
  3. Omkostningsberegner
  4. Realtids-omkostningssporing
  5. Klient med budgetkontrol
  6. Optimering af omkostninger
  7. Vigtige pointer

Overvågning af omkostninger og forbrug

API-omkostninger kan hurtigt løbe løbsk, hvis ikke du holder øje med dem. Denne lektion lærer dig, hvordan du sporer, estimerer og styrer dit forbrug i produktion. Historien gentager sig fra projekt til projekt: En funktion går live en torsdag, ingen tjekker dashboardet i weekenden, og mandag morgens regning svarer til hele månedsbudgettet. Trinnene nedenfor hjælper dig med at fange afvigelser i omkostningerne, lige så snart de opstår – ikke tredive dage senere.

Forståelse af fakturering

Omkostninger beregnes per million tokens, med forskellige priser for input og output. Denne asymmetri har direkte konsekvenser for dine designvalg: At sende et langt dokument som input koster betydeligt mindre end at få modellen til at generere et langt svar. Hvert svar returnerer det præcise antal for begge retninger, så du behøver aldrig at gætte.

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!

Omkostningsberegner

At omregne disse tællere til dollars kræver en pristabel. Isolér den i en dedikeret struktur i stedet for at sprede konstanter ud over hele din kode: Når priserne ændrer sig, eller du tilføjer en model, skal du kun ændre én linje. Priserne nedenfor er vejledende og bør verificeres ved hver budgetgennemgang.

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

Otte tiendedele af en cent per kald lyder beroligende, indtil du ganger det med de halvtreds tusind daglige kald fra en produktions-chatbot – det er fire hundrede dollars om dagen. Væn dig altid til at tænke i månedlige volumener, aldrig per kald.

Realtids-omkostningssporing

Enhedsberegninger er ubrugelige, medmindre de aggregeres. Denne tracker samler forbrug på tværs af tre akser – per dag, per model og per antal kald – og sammenligner dagens total med et budget, du har fastsat. Advarsler er graduerede: En advarsel, når mindre end 20 % af budgettet er tilbage, efterfulgt af en hård alarm, hvis grænsen overskrides. Dette mellemtrin er værdifuldt, fordi det giver dig tid til at gribe ind, før tjenesten bliver afbrudt.

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 budgetkontrol

Overvågning er ikke altid nok: Står du over for en fejlslagen løkke, der kalder API’et kontinuerligt, har du brug for en finansiel afbryder. Denne klient tjekker det resterende budget før anmodningen sendes og nægter blankt at udføre kaldet, hvis rammen er opbrugt. Tjenesten degraderes, men på en kontrolleret måde uden overraskelsesregninger. Omkostningsregnskabet sker bagefter, når det faktiske forbrug er kendt.

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}")

Optimering af omkostninger

1. Valg af den rigtige model

Den mest effektive løftestang forbliver routing baseret på kompleksitet. En klassificeringsopgave i tre kategorier har ikke brug for den dyreste model: For denne opgave kan forskellen i regningen nå en faktor på femogtyve ved identisk kvalitet. Gør kompleksitet til en eksplicit parameter i din funktion i stedet for en beslutning, der er hardcodet i logikken.

# 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. Cachning af svar

Den anden løftestang er at undgå at betale to gange for det samme svar. En FAQ, et produktkatalog eller en standardformular genererer strengt identiske prompts dusinvis af gange om dagen. Cache-nøglen kombinerer model, input og parametre – det er afgørende at inkludere dem alle, ellers vil en ændring i temperaturen stille og roligt returnere det gamle svar.

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ænsning af output-tokens

Endelig bør du sætte loft over output, når længden er forudsigelig. Da output er den dyre del, åbner det døren for et verbost svar, som du betaler for, men ikke bruger, hvis du beder om ét ord, men tillader to tusind 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 pr. 5. august 2026 – priser ændrer sig regelmæssigt: Før enhver budgetberegning skal du verificere den aktuelle pristabel på OpenAIs officielle prisside.

Vigtige pointer

  • Omkostninger afhænger af modellen OG retningen (input vs. output)
  • Implementér en omkostningssporing med budgetadvarsler
  • Brug den rigtige model til hver opgave: Luna til volumen, Terra som standard
  • Cachning kan drastisk reducere omkostninger ved gentagne forespørgsler
  • Sæt max_output_tokens, når svarets længde er forudsigelig
  • Tjek OpenAI-dashboardet for officiel forbrugssporing