Calcolare e prevedere i costi delle API
Scriverà un helper Python che stimi il costo prima dell'invio di una richiesta contando i token e applicando i prezzi specifici di ciascun modello, così da evitare addebiti imprevisti.
Calcolare e prevedere i costi delle API è una lezione AI Engineering Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Engineering Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Engineering Academy include 4 lezioni in totale.
Perché è importante prevedere i costi
I costi delle API per le applicazioni basate su LLM possono diventare sorprendentemente elevati su larga scala. Una singola query che sembra economica, con un costo di 0,002 $, arriva a 200 $ se viene eseguita 100.000 volte. Senza previsione e monitoraggio dei costi, le funzionalità di AI possono generare fatture cloud impreviste, superiori all'intera spesa per l'infrastruttura.
La buona notizia è che i costi degli LLM sono completamente prevedibili prima di inviare una richiesta: conosce il modello, può contare i token di input con tiktoken e stimare i token di output in base all'impostazione max_tokens o alle medie storiche. Integrare la previsione dei costi nell'applicazione fin dal primo giorno evita sorprese in fattura.
Struttura dei prezzi di OpenAI
OpenAI addebita separatamente i token di input e i token di output; questi ultimi costano in genere 3-4 volte di più. I prezzi variano in base al modello. Come riferimento per il 2025, verifichi sempre la pagina dei prezzi aggiornata perché può cambiare:
- gpt-4o-mini: circa 0,15 $/milione di token di input, circa 0,60 $/milione di token di output
- gpt-4o: circa 2,50 $/milione di token di input, circa 10,00 $/milione di token di output
- text-embedding-3-small: circa 0,02 $/milione di token
La differenza di costo tra i modelli è enorme: gpt-4o è circa 17 volte più costoso di gpt-4o-mini per token di input. La scelta del modello è la leva più importante per controllare i costi: inizi sempre dal modello meno costoso che soddisfa i requisiti di qualità.
Una funzione di supporto per stimare i costi
Crei uno strumento di stima dei costi da chiamare prima di inviare ogni richiesta. Questo strumento conta i token di input con tiktoken, stima i token di output dal parametro max_tokens, recupera il prezzo per modello e restituisce il costo stimato in dollari. Lo utilizzi durante lo sviluppo e registri i risultati, così acquisirà familiarità con il costo dei diversi tipi di query.
import tiktoken
# Prices per million tokens as of early 2025
PRICING = {
'gpt-4o': {'input': 2.50, 'output': 10.00},
'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
'gpt-4-turbo': {'input': 10.00, 'output': 30.00},
'text-embedding-3-small': {'input': 0.02, 'output': 0.0},
}
def estimate_cost(messages, model='gpt-4o-mini', expected_output_tokens=500):
enc = tiktoken.encoding_for_model(model)
input_tokens = sum(
len(enc.encode(m.get('content', ''))) + 4
for m in messages
) + 3
if model not in PRICING:
raise ValueError(f'Unknown model: {model}')
rates = PRICING[model]
input_cost = (input_tokens / 1_000_000) * rates['input']
output_cost = (expected_output_tokens / 1_000_000) * rates['output']
total = input_cost + output_cost
print(f'Model: {model}')
print(f'Input tokens: {input_tokens} (${input_cost:.6f})')
print(f'Est. output tokens: {expected_output_tokens} (${output_cost:.6f})')
print(f'Estimated total: ${total:.6f}')
return totalMonitoraggio dei costi effettivi dalle risposte dell'API
Dopo ogni chiamata API, l'oggetto di risposta contiene il numero effettivo di token utilizzati. Lo estragga per registrare i costi reali e confrontarli con le stime. Nel tempo, la differenza tra i token di output stimati ed effettivi indica quanto accuratamente sta prevedendo l'utilizzo, mentre i log forniscono una suddivisione dei costi per funzionalità o segmento di utenti.
import openai
client = openai.OpenAI()
PRICING = {
'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
}
def chat_with_cost_tracking(model, messages):
response = client.chat.completions.create(
model=model, messages=messages
)
usage = response.usage
rates = PRICING.get(model, {'input': 0, 'output': 0})
actual_cost = (
(usage.prompt_tokens / 1_000_000) * rates['input'] +
(usage.completion_tokens / 1_000_000) * rates['output']
)
print(f'Input: {usage.prompt_tokens} tokens')
print(f'Output: {usage.completion_tokens} tokens')
print(f'Total: {usage.total_tokens} tokens')
print(f'Actual cost: ${actual_cost:.6f}')
return response, actual_costProiezione dei costi mensili
Una volta noto il costo medio per richiesta e il volume previsto di richieste, proiettare i costi mensili è semplice. Crei un foglio di calcolo per il modello dei costi o un semplice script Python che consenta di testare diverse ipotesi: cosa succederebbe se il numero di utenti attivi giornalieri raddoppiasse? E se aggiungessimo una funzionalità che effettua 3 chiamate API per ogni azione dell'utente invece di 1?
def project_monthly_cost(
avg_cost_per_request,
requests_per_day,
days=30
):
daily_cost = avg_cost_per_request * requests_per_day
monthly_cost = daily_cost * days
print(f'Avg cost/request: ${avg_cost_per_request:.6f}')
print(f'Requests/day: {requests_per_day:,}')
print(f'Daily cost: ${daily_cost:.2f}')
print(f'Monthly cost: ${monthly_cost:.2f}')
# Growth scenarios
for multiplier in [2, 5, 10]:
scaled = monthly_cost * multiplier
print(f' At {multiplier}x traffic: ${scaled:.2f}/month')
# Example: customer support bot
project_monthly_cost(
avg_cost_per_request=0.002, # 2 cents per support query
requests_per_day=5000
)Impatto della scelta del modello sui costi
La leva più importante per ridurre i costi consiste nell'utilizzare il modello meno costoso che soddisfa i requisiti di qualità. Per molte attività, gpt-4o-mini offre prestazioni paragonabili a gpt-4o, ma a un costo circa 17 volte inferiore. Prima di scegliere automaticamente il modello più potente, esegua un benchmark del modello meno costoso sull'attività specifica e passi a quello più costoso solo se la qualità scende al di sotto della soglia stabilita.
Una strategia di instradamento a livelli è ancora più efficace: classifichi le richieste in arrivo in base alla complessità e indirizzi le query semplici verso modelli economici e quelle complesse verso modelli costosi. Anche indirizzare il 70% del traffico verso il modello economico e il 30% verso quello costoso consente di risparmiare circa il 70% dei costi di AI.
Lunghezza del prompt e costi
Ogni token nel prompt ha un costo. Un prompt di sistema prolisso, che potrebbe essere condensato senza perderne il significato, aumenta direttamente il costo dell'API per ogni richiesta. Misurate il numero di token dei vostri prompt e cercate opportunità per rendere la formulazione più concisa. Allo stesso modo, spesso è possibile sostituire esempi few-shot lunghi con equivalenti più brevi senza sacrificare la precisione.
Nei sistemi RAG, il contesto recuperato costituisce spesso la parte più consistente del prompt. Restituire 10 blocchi grandi quando ne basterebbero 3 più piccoli e scelti con cura comporta uno spreco di token per ogni query. Ottimizzate il recupero per ridurre al minimo il contesto ridondante massimizzando al contempo la rilevanza.
Batching per l'efficienza dei costi
OpenAI offre una Batch API che elabora le richieste in modo asincrono con uno sconto del 50% rispetto al prezzo standard. Se il vostro caso d'uso non è sensibile alla latenza — elaborazione di documenti, processi di analisi notturni, generazione massiva di contenuti — la Batch API può dimezzare i costi con modifiche minime al codice.
Le richieste batch vengono inviate come file JSONL, elaborate entro 24 ore, e i risultati vengono recuperati dall'API. Questa soluzione è ideale per pipeline di preelaborazione eseguite secondo una pianificazione e che non necessitano di risposte in tempo reale.
import openai
import json
client = openai.OpenAI()
# Create batch request file
requests = [
{'custom_id': f'doc-{i}',
'method': 'POST',
'url': '/v1/chat/completions',
'body': {
'model': 'gpt-4o-mini',
'messages': [{'role': 'user', 'content': f'Summarize document {i}'}],
'max_tokens': 200
}}
for i in range(100)
]
# Write to JSONL
with open('/tmp/batch_input.jsonl', 'w') as f:
for req in requests:
f.write(json.dumps(req) + '\n')
# Upload and submit (50% off list price)
print('Would submit batch for 100 documents at 50% discount')
# batch_file = client.files.create(file=open('/tmp/batch_input.jsonl','rb'), purpose='batch')
# batch = client.batches.create(input_file_id=batch_file.id, endpoint='/v1/chat/completions', completion_window='24h')Impostazione dei limiti di spesa
Configurate sempre limiti di spesa per impedire che i costi aumentino senza controllo. Nella dashboard di OpenAI potete impostare limiti mensili di spesa che interrompono l'accesso all'API quando viene raggiunto il limite. Impostate un limite rigido pari alla spesa massima accettabile e un limite flessibile all'80% di tale valore, così da ricevere un avviso via email prima di raggiungere il limite rigido.
Nel codice dell'applicazione, implementate un budget per utente o per funzionalità registrato nel database. Verificate il budget prima di ogni chiamata all'API e restituite un errore se è esaurito. In questo modo impedite che un singolo utente fuori controllo o un bug in un processo batch consumi l'intera quota mensile nel giro di poche ore.
Memorizzazione nella cache per evitare chiamate API ridondanti
La chiamata API più economica è quella che non effettuate. Implementate la memorizzazione nella cache a livello applicativo per servire dalla cache le richieste identiche invece di chiamare nuovamente l'API. Anche una semplice cache Redis indicizzata sull'hash SHA256 del prompt può eliminare una parte significativa delle chiamate ridondanti in un'applicazione di produzione.
Per gli embedding, la memorizzazione nella cache è particolarmente efficace: lo stesso testo dovrebbe essere sottoposto a embedding una sola volta. Salvate gli embedding nel database vettoriale usando il testo originale come chiave e verificate l'esistenza di un embedding prima di chiamare l'API degli embedding. In una pipeline RAG, gli embedding dei documenti vengono calcolati una volta durante l'indicizzazione e riutilizzati per ogni query che recupera quei documenti.
import hashlib
import json
# Simple in-memory cache (use Redis in production)
_cache = {}
def cached_completion(client, model, messages, **kwargs):
cache_key = hashlib.sha256(
json.dumps({'model': model, 'messages': messages}).encode()
).hexdigest()
if cache_key in _cache:
print('Cache HIT - no API call made')
return _cache[cache_key]
response = client.chat.completions.create(
model=model, messages=messages, **kwargs
)
_cache[cache_key] = response
print('Cache MISS - API call made')
return responseCreazione di una dashboard dei costi
In produzione, dovete avere visibilità sui costi dell'IA suddivisi per funzionalità, utente e modello. Create una dashboard dei costi registrando in un database di serie temporali il numero di token di ogni chiamata API e i relativi metadati (ID utente, nome della funzionalità, modello). Aggregate quindi i dati per rispondere a domande come: quale funzionalità genera la spesa maggiore? Gli utenti avanzati stanno generando costi sproporzionati? Il costo per query è aumentato dopo una modifica al prompt?
Questa visibilità è essenziale per prendere decisioni di ottimizzazione basate sui dati invece di cercare di indovinare dove ridurre i costi. La maggior parte delle aziende scopre che il 20% delle funzionalità rappresenta l'80% della spesa per l'IA e che ottimizzare queste funzionalità ha un impatto sproporzionato.
Verifica rapida
Verificate la vostra comprensione dei concetti di AI Engineering trattati in questa lezione.
Riepilogo della lezione
In questa lezione avete imparato che: è possibile prevedere i costi dell'API prima dell'invio contando i token di input con tiktoken e stimando i token di output, la scelta del modello è il principale fattore di costo: gpt-4o-mini può costare 17 volte meno di gpt-4o per le attività appropriate e la memorizzazione nella cache, il batching e i limiti di spesa impediscono che i costi aumentino senza controllo in produzione. Ora analizzeremo le strategie per gestire conversazioni lunghe che superano la finestra di contesto.
Domande Frequenti
La lezione «Calcolare e prevedere i costi delle API» è gratuita?
Sì — il testo completo di «Calcolare e prevedere i costi delle API» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Engineering Academy, passa a CoddyKit PRO. Il corso AI Engineering Academy include 4 lezioni in totale.
Cosa imparerò in «Calcolare e prevedere i costi delle API»?
Scriverà un helper Python che stimi il costo prima dell'invio di una richiesta contando i token e applicando i prezzi specifici di ciascun modello, così da evitare addebiti imprevisti. Eserciti AI Engineering Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Engineering Academy?
Non è richiesta alcuna esperienza precedente. AI Engineering Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Calcolare e prevedere i costi delle API»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Engineering Academy?
Sì. Ogni lezione AI Engineering Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Che cos'è un token?
- Finestre di contesto: dimensioni e implicazioni
- Calcolare e prevedere i costi delle API
- Strategie per restare entro i limiti del contesto