Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Monitoraggio di costi e utilizzo

Lezione 16 di 22 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Monitoraggio di costi e utilizzo
  2. Comprendere la fatturazione
  3. Calcolatore dei costi
  4. Tracker dei costi in tempo reale
  5. Client con controllo del budget
  6. Ottimizzazione dei costi
  7. Punti chiave

Monitoraggio di costi e utilizzo

I costi delle API possono sfuggire di mano molto rapidamente se non li tieni d’occhio. Questa lezione ti insegna come tracciare, stimare e controllare le tue spese in produzione. La storia si ripete di progetto in progetto: una funzionalità va in live il giovedì, nessuno controlla la dashboard nel weekend e lunedì mattina la fattura corrisponde all’intero budget mensile. I passaggi seguenti ti aiutano a intercettare la deriva dei costi non appena si verifica, non trenta giorni dopo.

Comprendere la fatturazione

I costi sono calcolati per milione di token, con prezzi diversi per input e output. Questa asimmetria ha conseguenze dirette sulle tue scelte progettuali: inviare un documento lungo come input costa significativamente meno rispetto a far generare al modello un testo lungo. Ogni risposta restituisce il conteggio esatto per entrambe le direzioni, quindi non devi mai stimare.

from openai import OpenAI
client = OpenAI()

# Ogni risposta include le metriche di utilizzo
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Spiega la fatturazione delle API OpenAI."
)

usage = response.usage
print(f"Token di input: {usage.input_tokens}")
print(f"Token di output: {usage.output_tokens}")
print(f"Token totali: {usage.total_tokens}")

# L'output costa più dell'input!

Calcolatore dei costi

Convertire questi contatori in dollari richiede una griglia tariffaria. Isotala in una struttura dedicata invece di spargere costanti in tutto il tuo codice: quando i prezzi cambiano o aggiungi un modello, devi modificare una sola riga. Le tariffe riportate di seguito sono indicative e dovrebbero essere verificate durante ogni revisione del budget.

from dataclasses import dataclass

@dataclass
class ModelRate:
    input_per_million: float
    output_per_million: float

# Prezzi approssimativi in USD per milione di token
# Verifica sempre i prezzi attuali su 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:
    """Calcola il costo di una chiamata in USD."""
    rate = RATES.get(model)
    if not rate:
        raise ValueError(f"Modello sconosciuto: {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

# Esempio
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Costo: ${cost:.6f}")
# Risultato: Costo: $0.008000

Otto decimi di centesimo per chiamata sembrano rassicuranti finché non li moltiplichi per le cinquantamila chiamate giornaliere di un chatbot in produzione: sono quattrocento dollari al giorno. Abituati sempre a pensare in volumi mensili, mai per singola chiamata.

Tracker dei costi in tempo reale

I calcoli unitari sono inutili se non vengono aggregati. Questo tracker aggrega la spesa su tre assi: per giorno, per modello e per numero di chiamate, e confronta il totale giornaliero con un budget che hai impostato. Gli avvisi sono graduati: un avviso quando rimane meno del 20% del budget, seguito da un allarme rigoroso al superamento del limite. Questo passaggio intermedio è prezioso perché ti dà il tempo di intervenire prima che il servizio venga interrotto.

import json
from datetime import datetime, date
from collections import defaultdict

class CostTracker:
    """Tracciamento dei costi delle API in tempo reale."""

    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):
        """Registra i costi di una chiamata."""
        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:
        """Restituisce il budget residuo per oggi."""
        today = date.today().isoformat()
        return self.daily_budget - self.costs_per_day[today]

    def budget_alert(self) -> bool:
        """Verifica se il budget è vicino al limite."""
        remaining = self.remaining_budget()
        if remaining <= 0:
            print("ALLARME: Budget giornaliero superato!")
            return True
        elif remaining < self.daily_budget * 0.2:
            print(f"ATTENZIONE: ${remaining:.2f} rimanenti sul budget giornaliero")
            return True
        return False

    def report(self) -> dict:
        """Genera un report dei costi."""
        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,
        }

# Utilizzo
tracker = CostTracker(daily_budget_usd=5.0)

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Ciao!"
)

cost = tracker.record(
    model="gpt-5.6-terra",
    input_tokens=response.usage.input_tokens,
    output_tokens=response.usage.output_tokens
)
print(f"Costo di questa chiamata: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))

Client con controllo del budget

Il monitoraggio non è sempre sufficiente: di fronte a un loop difettoso che chiama continuamente l’API, hai bisogno di un interruttore finanziario. Questo client verifica il budget residuo prima di emettere la richiesta e rifiuta nettamente la chiamata se la busta è esaurita. Il servizio si degrada, ma in modo controllato e senza fatture a sorpresa. La contabilità dei costi avviene successivamente, una volta noto l’utilizzo effettivo.

class BudgetControlledClient:
    """Client che rifiuta le chiamate se il budget è superato."""

    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:
        """Chiamata API con controllo del budget."""
        # Controlla il budget prima della chiamata
        if self.tracker.remaining_budget() <= 0:
            raise RuntimeError(
                "Budget giornaliero esaurito. "
                f"Speso: ${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
        )

        # Avvisa se il budget è basso
        self.tracker.budget_alert()

        return response

# Utilizzo
budget_client = BudgetControlledClient(daily_budget=2.0)

try:
    response = budget_client.create("gpt-5.6-terra", "Ciao!")
    print(response.output_text)
except RuntimeError as e:
    print(f"Bloccato: {e}")

Ottimizzazione dei costi

1. Scelta del modello giusto

La leva più potente rimane il routing per complessità. Un’attività di classificazione a tre categorie non ha bisogno del modello più costoso: per questo compito, la differenza di fattura raggiunge un fattore venticinque a parità di qualità. Rendi la complessità un parametro esplicito della tua funzione piuttosto che una decisione hardcodata nella logica.

# Costo relativo per attività (approssimativo, ~300 token di input / 20 di output):
# Classificazione semplice: gpt-5.6-luna ~$0.0001 vs gpt-5.6-sol ~$0.002
# Il modello giusto fa una differenza di 25x nei costi!

def optimized_call(prompt: str, complexity: str) -> str:
    """Sceglie il modello più economico adatto."""
    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. Caching delle risposte

La seconda leva è evitare di pagare due volte per la stessa risposta. Una FAQ, un catalogo prodotti o un modulo standard generano prompt strettamente identici decine di volte al giorno. La chiave di cache combina modello, input e parametri: includerli tutti è essenziale, altrimenti una modifica della temperatura restituirebbe silenziosamente la vecchia risposta.

import hashlib

class CachedClient:
    """Client con cache per evitare chiamate ridondanti."""

    def __init__(self):
        self.client = OpenAI()
        self.cache: dict[str, str] = {}

    def create(self, model: str, input: str, **kwargs) -> str:
        # Crea una chiave di cache
        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. Limitazione dei token di output

Infine, limita l’output ogni volta che la sua lunghezza è prevedibile. Poiché l’output è la parte costosa, chiedere una singola parola autorizzandone duemila lascia la porta aperta a una risposta verbosa che pagherai ma non utilizzerai.

# Imposta sempre max_output_tokens per attività prevedibili
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Classifica questo testo: positivo, negativo o neutro.",
    max_output_tokens=10  # Ci si aspetta una singola parola
)

Tariffe aggiornate al 5 agosto 2026 — i prezzi cambiano regolarmente: prima di qualsiasi calcolo del budget, verifica la griglia attuale sulla pagina ufficiale dei prezzi OpenAI.

Punti chiave

  • I costi dipendono dal modello E dalla direzione (input vs output)
  • Implementa un tracker dei costi con avvisi di budget
  • Usa il modello giusto per ogni attività: Luna per i volumi, Terra come default
  • Il caching può ridurre drasticamente i costi per le richieste ripetitive
  • Imposta max_output_tokens quando la lunghezza della risposta è prevedibile
  • Controlla la dashboard OpenAI per il tracciamento ufficiale dei consumi