Prezzo early bird (fino al 25 dic.), bloccato finché resti abbonato: Go a $10/mese (invece di $20), Plus con Opus 5.5 a soli $30/mese (invece di $50)Abbonati ora →
Chat testualecontesto 1M

Claude Sonnet 5.5

API Claude Sonnet 5.5 a metà del listino Anthropic: $1 in input, $5 in output per 1M di token. Novità rispetto a Sonnet 5, benchmark, breaking change e codice funzionante.

Prezzo / 1M tokenRisparmia 50%
UfficialeAIReiter
Input$2.00$1.00
Output$10.00$5.00
Lettura cache$0.20$0.10
Creazione cache$2.50$1.25
Readme
Input
Limita la lunghezza della risposta. I modelli di ragionamento contano anche il loro pensiero.
claude-sonnet-5-5
Output

A codebase you don't know is a risk, not a hurdle. The plan should burn down that risk in order: understand, run, trace, spike, then make the change small enough that "production-ready" is a property you can demonstrate, not a hope.

Here are the first five steps, with the evidence you collect at each.

Step 1 — Get it building and the baseline green (half day)
Read the README, the manifest(s), the CI config, and any architecture docs. Boot the app locally, run the full test suite, run the linter/typechecker.
Evidence: The exact commands that reproduce a clean build and a passing test suite from a fresh checkout (recorded output, not memory of it). A one-page map you wrote yourself: where the entry points are, the layers, the build/test toolchain, and the main risks to your feature (e.g. "this touches cron jobs and payments").

Step 2 — Trace the smallest end-to-end slice that resembles your feature (half day)
Don't start with your feature. Pick a neighboring one that already works and follow it from entry to persistence. Note the conventions along the way: how errors surface, how config is injected, how logging is done, how tests are written.
Evidence: An annotated trace — file → function → what it does — for that slice. A written list of "conventions I must follow" (not intuitions; things you observed in real code). A named shortlist of the 3–5 files you will actually touch. If you can't produce this trace, you're not ready to write code.

Step 3 — Spike the core path (day 2)
Build the ugly version: hardcoded values, no error handling, no tests. The purpose is to confirm the path you traced in step 2 is real and to surface what you didn't know you didn't know.
Evidence: A working spike demonstrating the feature's central data path, alongside a list of every assumption the spike broke and what you corrected. That correction list is the most valuable document in this whole plan.

Step 4 — Write the contract before the code (half of day 2 / day 3)
Once the spike proves the path, pin down what production needs: the inputs/outputs, the error cases, where it sits in the conventions from step 2. Then write the tests — they'll be red, but they're the specification.
Evidence: A one-to-two-page design doc, an agreed interface/API shape (with the team if there is one), and a red test suite that encodes intended behavior. If you can't write the contract without consulting the code, you haven't finished step 2.

Step 5 — Implement in small, verified increments (days 3–4)
Replace the spike with the real thing in small commits, each one keeping the suite green, leaning on the existing patterns. Run lint/tests/typecheck per commit — CI, not just locally — and exercise the actual path against a real instance (staging or a local environment that isn't stubbed).
Evidence: A branch with progressive commits, each green in CI; coverage on the new code; something that proves it works against reality (a test result, a log trace, a screenshot); and a review by at least one person who knows the codebase. The review counts as evidence — an unfamiliar codebase has tribal knowledge you cannot extract from the files alone.

Steps 6+ would be the things that actually make it "shipped": a migration plan and its rollback, feature flagging, observability, the release and post-release verification. But the first five get you to a reviewed, green, working slice in staging — which is the point at which you can say "this will work in production" with evidence behind it, instead of a guess.

Generato in42.7s
Token input134
Token output2,354
Token / s55.13
TTFT-

Esegui apre AI Chat con questo prompt. Accesso e crediti richiesti.

Dettagli del modello

Usa la stessa chiave del modello nel Playground, nelle richieste API e nei flussi di lavoro interni.

ID modello
claude-sonnet-5-5
Fornitore
Anthropic
Protocollo
Anthropic Messages
Finestra di contesto
1,000,000 token
Output massimo
128,000 token
Token input
100 crediti / 1 M token
Token output
500 crediti / 1 M token
Lettura cache
10 crediti / 1 M token
Scrittura cache
125 crediti / 1 M token

Le novità di Claude Sonnet 5.5

Anthropic ha rilasciato Claude Sonnet 5.5 il 28 settembre 2026 come upgrade diretto di Sonnet 5. Il prezzo di listino è rimasto invariato; ciò che è cambiato è la quantità di lavoro che può svolgere e quanti token impiega per farlo.

Vicino a Opus 5.5 nel knowledge work

Anthropic riporta un punteggio GDPval-AA di 1844 per Sonnet 5.5, a soli due punti da Opus 5.5 (1846) e circa 400 punti avanti rispetto a Sonnet 5 (1449). Anthropic afferma inoltre che Opus 5.5 rimane nettamente superiore nei compiti aperti che richiedono un giudizio continuo.

Un netto passo avanti nel coding

Su CursorBench 4.0 Anthropic registra il 55,5% per Sonnet 5.5, contro il 34,1% di Sonnet 5 e il 57,8% di Opus 5.5. Anthropic lo posiziona per il lavoro quotidiano ben definito: sviluppo di funzionalità, correzione di bug e creazione di documenti, slide e fogli di calcolo.

Meno token per lo stesso compito

I primi clienti hanno riscontrato risparmi concreti nei propri carichi di lavoro: Slack ha registrato circa il 14% di token in uscita in meno senza modificare i prompt, e Balyasny Asset Management ha misurato circa 121K token per risposta contro i 497K su Sonnet 5 su 2.441 task finanziari.

Output più veloce, stesso tokenizer

Anthropic afferma che l'output è oltre il 30% più veloce rispetto a Sonnet 5; Artificial Analysis ha misurato circa 139 token di output al secondo. Il tokenizer è invariato, quindi lo stesso testo corrisponde allo stesso numero di token su entrambi i modelli.

Claude Sonnet 5.5 vs Sonnet 5 vs Opus 5.5

Tutti e tre funzionano con la stessa chiave AIReiter. In sintesi: abbandona Sonnet 5 non appena le tue richieste superano i controlli di migrazione indicati di seguito, e mantieni Opus 5.5 per i compiti aperti più complessi.

Sonnet 5.5 vs Sonnet 5: stesso prezzo, più risultati

Entrambi hanno un prezzo di listino di $2 in input e $10 in output per milione di token. Sonnet 5.5 ottiene punteggi più alti nei benchmark di coding e knowledge work citati sopra e solitamente completa i task con meno token, quindi lo stesso lavoro tende a costare meno.

Sonnet 5.5 vs Opus 5.5: metà prezzo

Qui Sonnet 5.5 costa $1,00 in input e $5,00 in output per milione di token; Opus 5.5 costa $2,00 e $10,00. Entrambi offrono una context window da 1M di token e un output massimo di 128K, quindi per passare da uno all'altro basta modificare il campo model.

Quando Opus 5.5 conviene ancora

Per task lunghi e ambigui in cui il modello deve pianificare, accorgersi dei propri errori e proseguire. Base44 ha segnalato 3,6 iterazioni per build di app su Sonnet 5.5 contro 7,7 su Opus 5; conviene quindi provare prima Sonnet 5.5 ed effettuare l'escalation solo per i task non riusciti.

Quando rimanere su Sonnet 5 per il momento

Se il tuo codice disabilita il thinking, forza uno strumento specifico o imposta temperature, queste richieste falliranno su Sonnet 5.5 finché non le modifichi. Anche gli strumenti di sicurezza potrebbero riscontrare più rifiuti. Correggi prima questi aspetti, poi effettua il passaggio.

Migrazione da Sonnet 5: cosa restituisce ora un errore

Modificare la stringa del modello in claude-sonnet-5-5 non è sempre sufficiente. Queste strutture di richiesta funzionavano su Sonnet 5 ma vengono rifiutate da Sonnet 5.5.

thinking: disabled restituisce 400

L'adaptive thinking è sempre attivo. Sostituisci {"type": "disabled"} con {"type": "between_tools"}, l'impostazione minima, che salta il thinking prima della prima risposta. between_tools funziona solo con effort impostato su low, medium o high; per xhigh o max, ometti thinking o invia {"type": "adaptive"}.

I budget manuali per thinking restituiscono 400

thinking: {"type": "enabled", "budget_tokens": N} viene rifiutato. Controlla invece la profondità tramite il livello di effort. I token di thinking vengono comunque sottratti da max_tokens e fatturati come output, quindi aumenta max_tokens se le risposte iniziano a essere troncate.

La scelta forzata del tool viene rifiutata

Un tool_choice che impone un tool specifico ora genera un errore. Utilizza la scelta automatica dei tool con definizioni rigorose dei tool e lascia che sia il modello a decidere quando chiamarli.

Valori personalizzati di temperature, top_p e top_k restituiscono 400

È accettato solo il campionamento predefinito. Rimuovi questi campi dalla richiesta anziché impostarli su valori fissi. Una novità va a tuo favore: il prompt minimo memorizzabile nella cache scende da 1.024 a 512 token.

Scegli il livello di effort prima del rilascio

L'effort è ora il fattore principale per costi e latenza. Ci sono cinque livelli: low, medium, high, xhigh e max.

Il valore predefinito dell'API è high

Se non invii alcun effort, l'API viene eseguita su high. Claude Code e le app Claude sono impostate su medium per impostazione predefinita. Imposta esplicitamente output_config.effort in modo che la tua fatturazione non dipenda da un valore predefinito.

max è costoso

A max effort, Artificial Analysis ha misurato $7.60 per task al prezzo di listino e 410M di token di output nel suo indice, rispetto a una mediana di 88M. Le affermazioni di efficienza di Anthropic riguardano i livelli inferiori, non max.

Inizia da medium, misura, poi cambia

Esegui i tuoi task reali a medium, controlla la qualità e aumenta il livello solo dove non è all'altezza. Per i cicli di strumenti sensibili alla latenza, low o medium con il ragionamento between_tools mantiene le prime risposte rapide.

Prezzi dell'API Claude Sonnet 5.5 su AIReiter

Gestisci chiavi API →

Ogni riga è fatturata al 50% del listino di Anthropic. Stesso modello, stesso protocollo Messages.

01Metà del listino su ogni voce

Input $1.00 (listino $2.00). Output $5.00 (listino $10.00). Letture cache $0.10 (listino $0.20). Scritture cache $1.25 (listino $2.50). Tutto per milione di token.

02Una chiamata reale: $1.50 invece di $3.00

Un milione di token di input più centomila token di output costano $1.50 qui e $3.00 sul listino di Anthropic. La stessa chiamata su Opus 5.5 qui costa $3.00.

03Fatturato sui token effettivamente utilizzati

All'avvio della chiamata viene trattenuta una stima, che viene poi conguagliata in base al conteggio reale dei token al completamento della risposta, restituendo la differenza. La tariffa è la stessa dal primo token al milionesimo; non esiste un piano tariffario a parte per contesti lunghi.

Prova Claude Sonnet 5.5 in 3 passaggi

  1. 01

    Ottieni una chiave e punta il client su AIReiter

    Crea una chiave API nella tua dashboard AIReiter. Negli SDK ufficiali di Anthropic imposta il base URL su https://aireiter.com/api — l'SDK aggiunge /v1/messages automaticamente.

  2. 02

    Invia una richiesta con curl

    curl https://aireiter.com/api/v1/messages \ -H "x-api-key: $AIREITER_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-sonnet-5-5", "max_tokens": 4096, "output_config": {"effort": "medium"}, "messages": [{"role": "user", "content": "Hello"}] }'

  3. 03

    Oppure usa l'SDK Python

    from anthropic import Anthropic client = Anthropic(api_key="YOUR_AIREITER_KEY", base_url="https://aireiter.com/api") msg = client.messages.create( model="claude-sonnet-5-5", max_tokens=4096, messages=[{"role": "user", "content": "Hello"}], ) print(msg.content[0].text)

FAQ

01Quando è stato rilasciato Claude Sonnet 5.5 e qual è l'ID del modello?

Anthropic lo ha rilasciato il 28 settembre 2026. L'ID del modello API è claude-sonnet-5-5 e la sua data limite di conoscenza (knowledge cutoff) è giugno 2026.

02Quali sono la finestra di contesto e l'output massimo?

Una finestra di contesto da 1M di token e fino a 128K token di output per richiesta. Accetta input di testo e immagini e restituisce testo.

03Quanto costa l'API di Claude Sonnet 5.5?

Anthropic indica $2 per l'input e $10 per l'output per milione di token, la stessa tariffa di Sonnet 5. AIReiter fa pagare la metà: $1 per l'input, $5 per l'output, $0.10 per le letture della cache e $1.25 per le scritture nella cache.

04Posso disattivare il thinking?

Non del tutto. thinking disabilitato restituisce un errore 400. L'impostazione minima è between_tools, che funziona con effort low, medium e high.

05Sonnet 5.5 è migliore di Sonnet 5?

In base ai benchmark su coding e knowledge-work riportati da Anthropic, sì, con un ampio margine e allo stesso prezzo di listino. Verifica le modifiche per la migrazione sopra prima di effettuare il passaggio, poiché alcune strutture di richiesta di Sonnet 5 ora non sono più supportate.

06Perché la mia richiesta sulla sicurezza è stata rifiutata o ha ricevuto risposta da Sonnet 5?

Sonnet 5.5 è il primo Sonnet a integrare le protezioni di cybersecurity utilizzate sui modelli più avanzati di Anthropic. Alcune richieste a rischio più elevato effettuano il fallback a Sonnet 5 e le attività di sicurezza lecite possono incorrere in più rifiuti. Si tratta di un comportamento upstream.

07Ho bisogno di un account Anthropic?

No. Una chiave AIReiter funziona con l'endpoint AIReiter e puoi provare il modello nel playground su questa pagina prima di scrivere codice.

08Quali API sono supportate?

Anthropic Messages su /api/v1/messages è l'interfaccia principale, con supporto per lo streaming. Sono supportate anche le Chat Completions in stile OpenAI e le Responses API, mentre /api/v1/models elenca i modelli disponibili per la tua chiave.