Prezzi dell'API Claude Opus 5.5: metà del prezzo standard ufficiale, con i costi calcolati per attività

Su HiAPI, Claude Opus 5.5 costa $2,02 per milione di token di input e $10,08 per milione di token di output, la metà del prezzo standard ufficiale di Anthropic ($4 / $20). Il modello è sempre claude-opus-5-5, con la stessa finestra di contesto da 1M token e fino a 128K token di output, richiamabile tramite l'interfaccia compatibile con OpenAI.

Claude Opus 5.5, per milione di token	Prezzo standard ufficiale Anthropic	HiAPI
Input	$4,00	$2,02
Output (incluso il ragionamento)	$20,00	$10,08
Scrittura cache 5 minuti	$5,00	$2,52
Lettura cache	$0,20	$0,10
Contesto / output massimo	1M / 128K	1M / 128K

I prezzi ufficiali provengono dalla pagina dei prezzi di Anthropic, quelli di HiAPI dal listino in tempo reale di HiAPI; entrambi verificati il 6 ottobre 2026.

Quanto costa un'attività

Il prezzo per token non è intuitivo, quindi calcoliamo sotto il costo delle quattro attività più comuni. Il numero di token usato è la dimensione tipica di ciascuna attività: il tuo consumo reale potrà variare, ma il rapporto tra i prezzi dei due fornitori resta invariato.

Attività	Token di input	Token di output	Prezzo standard ufficiale Anthropic	HiAPI
Risposta in chat	2.000	1.000	$0,028	$0,014
Revisione del codice (un PR)	20.000	4.000	$0,160	$0,081
Un passo di un Agent in un codice di grandi dimensioni	120.000	8.000	$0,640	$0,323
Riassunto di un report di 150 pagine	200.000	3.000	$0,860	$0,434

Il calcolo per ogni riga è: token di input × prezzo unitario input + token di output × prezzo unitario output. Se revisioni 1.000 PR al mese, con il prezzo standard ufficiale sono $160, con HiAPI $80,72.

Due cose costano più di quanto molti pensino:

• Anche il ragionamento è fatturato come output. Opus 5.5 ragiona prima di ogni risposta, e quei token di ragionamento vengono conteggiati al prezzo di output. Più alto è effort, più ragiona e più token di output produce.
• Nei documenti lunghi si spende sull'input. Il riassunto di un report di 150 pagine produce solo 3.000 token, ma leggere 200.000 token lo rende l'attività più costosa della tabella.

Cosa compri con questi soldi: un esempio di revisione

Ecco la risposta che ottieni pagando. Abbiamo dato a Claude Opus 5.5 una breve funzione di checkout e gli abbiamo chiesto una revisione del codice:

def apply_discount(cart, code):
    discounts = {"SAVE10": 0.10, "SAVE20": 0.20}
    rate = discounts.get(code.upper())
    total = sum(item["price"] * item["qty"] for item in cart)
    if rate:
        total = total - total * rate
    return round(total, 2)

Commenti di revisione di Claude Opus 5.5:

1. Se il codice sconto non è compilato, code.upper() va in errore. Con code uguale a None viene sollevata un'eccezione AttributeError; correggi con (code or "").strip().upper().
2. Gli importi usano numeri in virgola mobile. Con molti articoli, l'errore in virgola mobile di price * qty può spostare il totale di un centesimo, e round() usa comunque l'arrotondamento al pari. Memorizza i prezzi come interi in "centesimi" oppure usa Decimal.
3. I codici sconto non validi vengono ignorati senza avviso. Se l'utente digita SAVE01 per errore, il totale viene calcolato a prezzo pieno senza alcun messaggio. Dovrebbe restituire o sollevare un risultato che la pagina di checkout possa mostrare all'utente.
4. La tabella degli sconti è codificata nel codice. Con due codici va ancora bene, ma prima che il team marketing ne aggiunga un terzo, spostala nella configurazione.

Una revisione così ha poche centinaia di token di contenuto visibile e, incluso il ragionamento, si colloca tra "risposta in chat" e "revisione del codice" nella tabella sopra: su HiAPI da 1 a 8 centesimi.

Risparmia ancora con la cache

Se molte richieste condividono lo stesso lungo prefisso, come un system prompt, una guida di stile o il riassunto di un codice, mettilo in cache. La lettura della cache di Opus 5.5 costa solo il 5% del prezzo normale di input.

Esempio: un system prompt di 30.000 token riutilizzato in 100 richieste, ciascuna con altri 1.000 token di input nuovo e 1.000 token di output:

100 richieste	Prezzo standard ufficiale Anthropic	HiAPI
Senza cache	$14,40	$7,27
Con cache di 5 minuti	$3,14	$1,58

Su HiAPI basta aggiungere cache_control al messaggio system. Attualmente è supportata la scrittura della cache a 5 minuti; la scrittura a 1 ora non è ancora disponibile.

{
  "model": "claude-opus-5-5",
  "messages": [
    {
      "role": "system",
      "content": [
        {
          "type": "text",
          "text": "Answer as a concise architecture reviewer. ...",
          "cache_control": {"type": "ephemeral", "ttl": "5m"}
        }
      ]
    },
    {"role": "user", "content": "Review this design: ..."}
  ],
  "output_config": {"effort": "medium"}
}

Il campo usage restituito a ogni risposta mostra quanti token di cache sono stati scritti o letti.

Controlla i costi con effort

Il ragionamento di Opus 5.5 non può essere disattivato, ma puoi decidere quanto deve ragionare con output_config.effort: low, medium (predefinito), high, xhigh, max. Più alto è effort, più token di ragionamento vengono prodotti, fatturati al prezzo di output.

• Usa low per classificazione, estrazione di informazioni e riscrittura di testi brevi.
• Per la maggior parte delle attività di coding e scrittura mantieni medium.
• Per debug difficili, piani lunghi e attività Agent a più passi usa high o superiore.
• Imposta un limite rigido con max_tokens: limita sia il ragionamento sia la risposta visibile.

Come chiamarlo su HiAPI

HiAPI espone Opus 5.5 tramite POST https://api.hiapi.ai/v1/chat/completions, cioè nel formato OpenAI Chat Completions. Il codice esistente con OpenAI SDK funziona subito: basta cambiare base URL, Key e nome del modello:

from openai import OpenAI

client = OpenAI(base_url="https://api.hiapi.ai/v1", api_key="YOUR_HIAPI_KEY")

reply = client.chat.completions.create(
    model="claude-opus-5-5",
    messages=[{"role": "user", "content": "Review this function for bugs: ..."}],
    extra_body={"output_config": {"effort": "medium"}},
    max_tokens=4096,
)
print(reply.choices[0].message.content)
print(reply.usage)

Prima di passare, tieni presenti alcune differenze rispetto all'API ufficiale di Anthropic:

• Parametri di ragionamento: non passare thinking né un budget di ragionamento, usa solo output_config.effort.
• Chiamata degli strumenti: usa tool_choice: "auto"; forzare uno strumento specifico restituisce un errore.
• Cache: è supportata solo la scrittura della cache a 5 minuti.
• Batch API e fast mode: sono funzionalità esclusive dell'API ufficiale di Anthropic. Anche la Batch API ufficiale è scontata del 50% ($2 / $10), ma i risultati arrivano in modo asincrono: la maggior parte dei batch si completa entro 1 ora, con un massimo possibile di 24 ore; il prezzo di HiAPI è quello delle normali richieste in tempo reale.

Per esempi con curl, output in streaming e gestione degli errori, vedi Guida rapida all'API di Claude Opus 5.5 (in inglese). Se vuoi prima provare i prompt nel browser, apri la pagina del modello Claude Opus 5.5.

Domande frequenti

Quanto costa l'API di Claude Opus 5.5?

Il prezzo standard ufficiale di Anthropic è $4 per milione di token di input e $20 per milione di token di output. Su HiAPI sono $2,02 e $10,08, la metà del prezzo standard ufficiale.

Claude Opus 5.5 è più economico di Opus 5?

Sì. Anthropic ha abbassato il prezzo da $5 / $25 di Opus 5 a $4 / $20 di Opus 5.5, e anche la lettura della cache è scesa da $0,50 a $0,20. Su HiAPI Opus 5.5 costa $2,02 / $10,08.

I token di ragionamento sono a pagamento?

Sì, sono fatturati al prezzo dei token di output. Opus 5.5 ragiona sempre; abbassando effort puoi ridurre i token di ragionamento.

Qual è l'ID del modello Claude Opus 5.5?

claude-opus-5-5, sia nell'API ufficiale di Anthropic sia su HiAPI.

Quanto è grande il contesto di Claude Opus 5.5?

1 milione di token di input e fino a 128.000 token di output. Input lunghi e brevi sono fatturati allo stesso prezzo unitario.

Si può disattivare il ragionamento di Claude Opus 5.5?

No, il ragionamento è sempre attivo. Per farlo ragionare il meno possibile, usa output_config.effort: "low".