Monitoraggio di costi e utilizzo
In questa pagina
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_tokensquando la lunghezza della risposta è prevedibile - Controlla la dashboard OpenAI per il tracciamento ufficiale dei consumi