Crea con CometAPITi serve una sola API per più modelli?Testa il flusso di lavoro in Playground, poi crea una chiave API quando modello e costo sono adatti al tuo caso d'uso.
Come utilizzare l'API di Claude Fable 5.2: guida completa 2026
Impara l'API Claude Fable 5.2 con la configurazione ufficiale di Anthropic e CometAPI, esempi in Python, streaming, input di immagini, prezzi e best practice per la produzione
Claude Fable 5.2 API consente di aggiungere capacità di ragionamento avanzato ad assistenti per il coding, flussi di ricerca e applicazioni che richiedono lavoro multi-step prolungato. Puoi connetterti direttamente ad Anthropic oppure usare CometAPI, a seconda di come vuoi gestire l’accesso al modello e l’integrazione.
Per costi token inferiori e un’integrazione multi-modello più semplice, Claude Fable 5.2 API tramite CometAPI è un punto di partenza pratico: le tariffe pubblicate in input e output sono inferiori del 20% rispetto alle tariffe standard dell’API Anthropic, e puoi mantenere il formato di richiesta Anthropic Messages all’interno di un flusso condiviso di accesso ai modelli e fatturazione. Scegli l’accesso diretto ad Anthropic quando il requisito principale sono controlli di account specifici del provider o una funzione nativa.
Questa guida copre entrambe le strade, quindi illustra richieste Python, streaming, cronologia della conversazione, input di immagini e verifiche per la produzione. Ti servono Python 3.10 o successivo, una chiave API per il percorso scelto e l’accesso a claude-fable-5-2.
Revisionato per chiarezza, attribuzione delle fonti e terminologia API aggiornata.
Punti chiave
Claude Fable 5.2 API usa l’ID modello claude-fable-5-2 in entrambe le strade mostrate qui.
Accesso diretto ad Anthropic e CometAPI usano chiavi e fatturazioni separate; scegli un percorso prima di inviare una richiesta.
CometAPI si adatta ad applicazioni multi-provider grazie a credenziali condivise, fatturazione e interfacce API compatibili.
Inizia con una richiesta testuale, poi aggiungi impostazioni di ragionamento, streaming, cronologia della conversazione e immagini secondo necessità.
CometAPI riduce gli addebiti token di Claude Fable 5.2 del 20% rispetto alle tariffe standard ufficiali di seguito, incluse le operazioni di cache elencate.
Che cos’è la Claude Fable 5.2 API?
Claude Fable 5.2 è il modello di ragionamento di Anthropic per lavori tecnici impegnativi. È stato pubblicato il 9 novembre 2026. L’API offre alla tua applicazione l’accesso al modello senza doverne gestire l’infrastruttura.
I progetti iniziali tipici includono la revisione di una modifica a un repository, l’analisi di una raccolta di documenti e la spiegazione di un design di sistema complesso. Ognuno inizia con una richiesta e una risposta; strumenti e cicli conversazionali più lunghi possono seguire una volta che quel percorso funziona.
Specifiche della Claude Fable 5.2 API
Specifica
Specifiche ufficiali di Claude Fable 5.2
ID modello
claude-fable-5-2
Finestra di contesto
1M token
Output massimo
128K token
Input / output
Testo e immagini / testo
Ragionamento
Adattivo; sempre attivo
Sforzo API predefinito
high
Formato di richiesta in questa guida
Anthropic Messages
I limiti di contesto e output descrivono la capacità, non le dimensioni suggerite della richiesta. Usa un prompt breve e un budget di output contenuto mentre verifichi credenziali e gestione della risposta.
Cosa c’è di nuovo nella Claude Fable 5.2 API rispetto a Fable 5.1?
Se già usi Fable 5.1, l’aggiornamento riguarda soprattutto prestazioni migliori sui task tecnici, prezzi standard dei token più bassi e cambiamenti di compatibilità per conversazioni e strumenti. Il confronto usa Fable 5.1 come generazione precedente.
Risultati più solidi su task tecnici impegnativi
Nelle valutazioni di rilascio di Anthropic, Fable 5.2 ha ottenuto il 49.1% su FrontierCode 2.0 contro il 32.4% di Fable 5.1, entrambi a sforzo xhigh. I punteggi Chartography sono saliti dal 44.8% al 73.4%. Anthropic riporta anche una generazione dell’output fino al 30% più veloce rispetto alla 5.1 e una modalità rapida opzionale. Si tratta di risultati riportati dal fornitore; una generazione più veloce non garantisce un ciclo richiesta-risposta più breve per il tuo carico di lavoro.
Per una revisione di repository o un task di analisi documentale difficile, verifica se il nuovo modello individua errori che quello attuale non coglie. Mantieni coerenti prompt, input e criteri di valutazione così che il confronto risponda a una domanda pratica: completa più spesso il tuo lavoro reale con successo?
Prezzi standard più bassi rispetto a Fable 5.1
Le tariffe standard pubblicate da Anthropic scendono da $10 a $8 per milione di token in input e da $50 a $40 per milione di token in output. Le letture di cache scendono da $0.25 a $0.20. Ognuna è una riduzione del 20%. Questi sono prezzi ufficiali da generazione a generazione; il successivo confronto con CometAPI misura una differenza separata tra fornitori di accesso.
A uso invariato di 100,000 token in input e 10,000 token in output, una richiesta standard non in cache scende da $1.50 su Fable 5.1 a $1.20 su Fable 5.2. I risparmi effettivi dipendono dai token generati, dai retry, dalla cache e dalle modalità opzionali.
Quattro modifiche di compatibilità da verificare
Il change log ufficiale identifica quattro modifiche che possono influire su un’integrazione esistente:
I controlli della conversazione ora coprono ogni account. Riprodurre il thinking dopo aver modificato messaggi precedenti, istruzioni di sistema o strumenti può fallire, anche su account più vecchi che in precedenza passavano.
Il rollback non preserva tutto il ragionamento. Solo Fable 5.2 e Mythos 5.2 possono leggere i blocchi di thinking di Fable 5.2. Passando a 5.1 o a un altro modello quel ragionamento può andare perso.
L’uso del computer richiede il toolset più recente. Il vecchio computer_20251124 fallisce al di fuori di Amazon Bedrock; usa computer_toolset_20260801 e adatta il loop degli strumenti.
Modifiche di compatibilità per Advisor. Un esecutore Fable 5.2 richiede un advisor Fable 5.2 o Mythos 5.2.
Cosa rimane uguale
Le specifiche di Fable 5.1 includono già una finestra di contesto da 1M token, 128K di output massimo, input di testo e immagini, thinking adattivo sempre attivo e sforzo API predefinito alto. Queste rimangono capacità utili in 5.2, ma non sono nuovi motivi per migrare.
Come migrare alla Claude Fable 5.2 API—e ne vale la pena?
Inizia con una migrazione piccola, misurabile e reversibile. Una prima richiesta riuscita è solo l’inizio: la tua applicazione deve anche preservare lo stato della conversazione, completare i workflow degli strumenti e gestire correttamente il fallback.
Spostare un’integrazione esistente su Fable 5.2
Usa la guida alla migrazione di Anthropic insieme a questi passaggi:
Cambia il modello in una configurazione di test. Imposta MODEL su claude-fable-5-2 nel client_config.py usato di seguito. Mantieni insieme la chiave e la base URL del percorso selezionato. Esegui prima una conversazione breve e nuova.
Rivedi le opzioni di richiesta. Per integrazioni più vecchie, rimuovi thinking disabilitato o con budget manuale, prefilling dell’assistente e selezione forzata degli strumenti. Ometti temperature, top_p e top_k. Usa output_config.effort per regolare il ragionamento.
Controlla la gestione della cronologia. Riproduci le risposte complete dell’assistente nel loro ordine originale. Mantieni invariati i messaggi precedenti, le istruzioni di sistema e le definizioni degli strumenti; aggiungi i nuovi turni in coda. Verifica eventuale codice che riduce la cronologia o aggiorna gli strumenti.
Aggiorna insieme gli strumenti opzionali. Applica le modifiche per l’uso del computer e dell’advisor dove rilevante. Avvia una nuova conversazione dopo aver cambiato le definizioni degli strumenti.
Testa il percorso di ritorno. Esegui un task multi-turno, un round trip di strumenti e un fallback al tuo modello precedente. Una risposta di fallback riuscita non significa che il thinking precedente sia stato preservato.
Quando usi CometAPI, conferma disponibilità del modello e funzionalità opzionali richieste su quel percorso prima di abilitarle in produzione. Una semplice interfaccia Messages compatibile non stabilisce di per sé il supporto per ogni funzione del provider.
Ne vale la pena migrare?
Da Fable 5.1: dai priorità a un pilota se il lavoro tecnico complesso è già prezioso per la tua applicazione. Le tariffe standard più basse rendono l’esperimento interessante, ma confronta il costo dei task completati invece di presumere che ogni richiesta userà gli stessi token.
Da Opus, Sonnet o Haiku: inizia dai task che il tuo modello attuale fatica a completare. Spostare ogni richiesta su Fable può aumentare la spesa senza migliorare il lavoro semplice. Puoi mantenere le richieste routinarie sul modello esistente e valutare Fable per i casi più difficili.
Mantieni l’assetto attuale per ora se soddisfa gli obiettivi di qualità e tempi di risposta, o se le modifiche richieste a cronologia e strumenti superano il beneficio misurato. Un upgrade dovrebbe risolvere un problema che sai identificare.
Anthropic Official API vs CometAPI: perché ho scelto la seconda
Anthropic fornisce accesso diretto all’API Messages. CometAPI fornisce un endpoint Messages compatibile con Anthropic, insieme a interfacce per altre famiglie di modelli. La decisione importante è quale account e livello di integrazione debbano servire la tua applicazione.
Applicazioni che cercano costi token più bassi o integrazione multi-provider
Verifica funzionalità
Verifica i requisiti di modello e account Anthropic
Verifica sia i requisiti del modello sia la route del gateway selezionata
Dove CometAPI semplifica un’applicazione multi-modello
CometAPI documenta una chiave e un livello di fatturazione condivisi attraverso più formati API. Per un team che mantiene diverse integrazioni di modelli, ciò può ridurre il numero di credenziali e flussi di account separati da gestire. Il beneficio cresce quando Claude è una parte di un prodotto più ampio.
Puoi anche mantenere un’integrazione SDK Anthropic esistente: la configurazione del client qui sotto cambia chiave e base URL mentre il corpo della richiesta Messages resta lo stesso. Per applicazioni che già usano un’interfaccia chat compatibile, CometAPI offre un ulteriore punto d’ingresso; scegli il formato che preserva le funzionalità di cui la tua applicazione ha bisogno.
La sua rendicontazione di utilizzo per account e per chiave ti dà un punto comune per riconciliare i consumi. È utile quando funzionalità di prodotto separate usano modelli differenti e hai bisogno di comprenderne la spesa combinata.
Scegliere il percorso per il tuo progetto
Inizia con CometAPI quando la riduzione della spesa per token è una priorità, che tu usi Claude da solo o insieme ad altri provider. Testa richieste rappresentative con il tuo client esistente per confermare le funzionalità necessarie. Scegli l’accesso diretto ad Anthropic quando i requisiti ruotano attorno a controlli di account specifici del provider. In entrambi i casi, verifica completamento dei task, consumo e latenza prima di portare traffico di produzione.
Come usare la Claude Fable 5.2 API passo dopo passo?
Scegli un percorso di accesso per la tua prima richiesta. Gli esempi Python condividono un piccolo file di configurazione, così potrai testare in seguito l’altro percorso senza riscrivere il corpo della richiesta.
Passo 1: Crea una chiave API
Per l’accesso ufficiale, segui la configurazione della chiave API nella Console Claude. Usa una chiave con ambito workspace per questo tutorial e conferma che l’account abbia accesso e fatturazione configurati. Salvala come ANTHROPIC_API_KEY. Le chiavi non con ambito workspace richiedono anche l’header workspace descritto nella documentazione di autenticazione Anthropic.
Per CometAPI, crea una chiave nella dashboard API e conferma accesso al modello e saldo. Salvala come COMETAPI_KEY. Una chiave di un provider non può autenticarsi sull’endpoint dell’altro provider.
Conserva la chiave in modo sicuro. Evita di inserire le credenziali direttamente nel codice sorgente dell’applicazione o in JavaScript lato frontend.
Su macOS o Linux, esegui l’assegnazione appropriata nella shell che avvierà Python:
# Imposta la variabile per il percorso scelto.
export ANTHROPIC_API_KEY="your_anthropic_api_key"
# Oppure, per CometAPI:
export COMETAPI_KEY="your_cometapi_api_key"
In Windows PowerShell, usa la variabile d’ambiente corrispondente:
# Imposta la variabile per il percorso scelto.
$env:ANTHROPIC_API_KEY = "your_anthropic_api_key"
# Oppure, per CometAPI:
$env:COMETAPI_KEY = "your_cometapi_api_key"
Passo 2: Invia una prima richiesta con cURL
Si tratta di comandi Bash alternativi. Esegui quello per l’account selezionato per ispezionare la risposta HTTP prima di introdurre Python.
Invia una richiesta testuale direttamente ad Anthropic con una chiave API con ambito workspace:
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "content-type: application/json" \
-d '{
"model": "claude-fable-5-2",
"max_tokens": 4096,
"messages": [{
"role": "user",
"content": "Spiega la limitazione della frequenza delle API in tre frasi."
}]
}'
Invia la richiesta equivalente tramite CometAPI:
curl https://api.cometapi.com/v1/messages \
-H "x-api-key: $COMETAPI_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-fable-5-2",
"max_tokens": 4096,
"messages": [{
"role": "user",
"content": "Spiega la limitazione della frequenza delle API in tre frasi."
}]
}'
Gli esempi HTTP usano gli header di versione documentati per ciascun percorso: versioni dell’API Anthropic e formato Messages di CometAPI. Un SDK gestisce questi header per te; funzionalità beta opzionali necessitano comunque di verifica specifica per il percorso.
L’endpoint restituisce una risposta in stile Anthropic che contiene content, usage e stop_reason.
Passo 3: Configura il client Python
Installa l’SDK Python di Anthropic nell’ambiente Python attivo.
Installa o aggiorna il pacchetto:
python -m pip install --upgrade anthropic
Crea client_config.py nella cartella del progetto. Scegli esattamente una delle seguenti configurazioni; tutti gli script successivi importano client e MODEL da questo file.
Configurazione CometAPI: salva questo come client_config.py quando usi il tuo account CometAPI:
import os
from anthropic import Anthropic
MODEL = "claude-fable-5-2"
client = Anthropic(
api_key=os.environ["COMETAPI_KEY"],
auth_token=None,
base_url="https://api.cometapi.com",
)
Configurazione ufficiale: usa questa versione di client_config.py per l’accesso diretto ad Anthropic:
import os
from anthropic import Anthropic
MODEL = "claude-fable-5-2"
client = Anthropic(
api_key=os.environ["ANTHROPIC_API_KEY"],
auth_token=None,
base_url="https://api.anthropic.com",
)
Per l’SDK Messages, queste base URL non hanno il suffisso /v1. Quando confronti i percorsi, esegui sessioni separate con la chiave e la configurazione del client corrispondenti invece di scambiare credenziali all’interno di una conversazione attiva.
Passo 4: Invia una richiesta con Python
Salva questo come fable52.py accanto a client_config.py. La richiesta funziona con la configurazione selezionata:
from client_config import client, MODEL
response = client.messages.create(
model=MODEL,
max_tokens=4096,
messages=[{
"role": "user",
"content": "Spiega il Python sincrono e asincrono.",
}],
)
for block in response.content:
if block.type == "text":
print(block.text)
print("Motivo di arresto:", response.stop_reason)
print("Token in ingresso:", response.usage.input_tokens)
print("Token in uscita:", response.usage.output_tokens)
Esegui l’esempio nel terminale in cui hai impostato la chiave:
python fable52.py
Una richiesta solo testo riuscita stampa la risposta e l’uso. Verifica end_turn prima di considerare completa la risposta. Se il motivo di arresto è max_tokens, rivedi l’output parziale e il budget; un successo HTTP non significa di per sé che il lavoro richiesto sia terminato.
Come aggiungere ragionamento, streaming e immagini a Claude Fable 5.2?
Mantieni client_config.py dalla sezione di setup. Ogni script seguente usa il percorso selezionato, così puoi testare nuove funzionalità senza cambiare il codice di connessione di base.
Controllare lo sforzo di ragionamento
Fable 5.2 usa il thinking adattivo sempre attivo. Puoi omettere thinking o impostarne il tipo su adattivo; thinking disabilitato e budget dei token di thinking manuale non sono supportati.
Il parametro effort accetta low, medium, high, xhigh e max. Inizia con il valore predefinito dell’API, high, e cambialo solo dopo avere una baseline utile per il tuo task.
Salva questo come fable52_effort.py ed esegui python fable52_effort.py per impostare esplicitamente l’effort:
from client_config import client, MODEL
response = client.messages.create(
model=MODEL,
max_tokens=8192,
thinking={"type": "adaptive"},
output_config={"effort": "high"},
messages=[{
"role": "user",
"content": "Individua le modalità di guasto in un sistema di worker basato su coda.",
}],
)
for block in response.content:
if block.type == "text":
print(block.text)
print("Motivo di arresto:", response.stop_reason)
Lascia fuori temperature, top_p e top_k nella richiesta iniziale. Fable 5.2 inoltre rifiuta la scelta forzata degli strumenti; non portare con te tipi tool_choice any o tool da un’altra integrazione.
Streaming per applicazioni interattive
Invece di attendere l’intera risposta, la tua applicazione può mostrare il testo generato man mano che arriva.
Usa l’helper di streaming dei Messaggi per leggere incrementi di testo e raccogliere il messaggio finale.
Salva questo come fable52_stream.py ed esegui python fable52_stream.py:
from client_config import client, MODEL
with client.messages.stream(
model=MODEL,
max_tokens=8192,
messages=[{
"role": "user",
"content": "Progetta un'architettura a microservizi tollerante ai guasti.",
}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
final_message = stream.get_final_message()
print("\nMotivo di arresto:", final_message.stop_reason)
print("Uso:", final_message.usage)
Potrebbe esserci una pausa prima che appaia il primo testo mentre il modello ragiona. Considera lo stream completo solo dopo che l’helper termina con successo; il testo parziale da solo non conferma una risposta completata.
Preservare la cronologia della conversazione multi-turno
A differenza di un’interfaccia chat stateful, la normale API Messages richiede alla tua applicazione di fornire la cronologia della conversazione.
Salva questo come fable52_history.py ed esegui python fable52_history.py per effettuare due richieste correlate:
from client_config import client, MODEL
history = [{
"role": "user",
"content": "Progetta un'architettura di elaborazione eventi scalabile.",
}]
first = client.messages.create(
model=MODEL,
max_tokens=8192,
output_config={"effort": "high"},
messages=history,
)
if first.stop_reason != "end_turn":
raise RuntimeError(f"Il primo turno non è completo: {first.stop_reason}")
history.append({
"role": "assistant",
"content": [block.model_dump() for block in first.content],
})
history.append({
"role": "user",
"content": "Ora individua i tre scenari di guasto a rischio più elevato.",
})
second = client.messages.create(
model=MODEL,
max_tokens=8192,
output_config={"effort": "high"},
messages=history,
)
for block in second.content:
if block.type == "text":
print(block.text)
print("Motivo di arresto:", second.stop_reason)
Nota che l’esempio preserva il contenuto completo dell’assistente dalla prima risposta invece di estrarne solo il testo visibile.
Fable 5.2 convalida il thinking rispetto alla conversazione precedente. Mantieni invariati i messaggi precedenti, le istruzioni di sistema e le definizioni degli strumenti quando riproduci quei blocchi. Aggiungi il turno successivo invece di ricostruire il prefisso.
L’illustrazione del contesto e della compaction di Anthropic mostra perché una sessione lunga richiede alla fine una cronologia di lavoro più piccola. Il diagramma proviene da Claude Code; un’applicazione API personalizzata deve implementare la propria gestione del contesto.
Per questo tutorial, mantieni intatta la cronologia breve. Prima di aggiungere compaction a un’applicazione più lunga, conferma che il tuo gateway supporti l’opzione server-side documentata. Se avvii una nuova conversazione da un riepilogo, non allegare blocchi di thinking firmati dal vecchio prefisso.
Invio di un’immagine per l’analisi
Il formato nativo di input immagine colloca un blocco immagine accanto a un’istruzione testuale. Questo esempio legge un PNG locale; verifica supporto immagini e limiti di dimensione sul percorso gateway scelto prima di usare input più grandi.
Metti dashboard.png accanto agli script, salva questo come fable52_vision.py ed esegui python fable52_vision.py:
import base64
from pathlib import Path
from client_config import client, MODEL
image_data = base64.b64encode(
Path("dashboard.png").read_bytes()
).decode("ascii")
response = client.messages.create(
model=MODEL,
max_tokens=4096,
messages=[{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": image_data,
},
},
{
"type": "text",
"text": "Individua tre problemi di usabilità in questa dashboard.",
},
],
}],
)
for block in response.content:
if block.type == "text":
print(block.text)
print("Motivo di arresto:", response.stop_reason)
In un loop di strumenti lato client, definisci gli strumenti con schemi di input, leggi i blocchi tool_use restituiti, esegui l’operazione consentita nella tua applicazione e invia blocchi tool_result corrispondenti nel messaggio utente successivo. Preserva la risposta completa dell’assistente prima di restituire quei risultati.
Inizia con uno strumento in sola lettura, ad esempio la ricerca di un record. Valida i suoi argomenti e tratta tool_use come una continuazione del task. Un modello che genera una chiamata a uno strumento non esegue da solo il codice della tua applicazione.
Quanto costa la Claude Fable 5.2 API?
Le tariffe pubblicate di CometAPI sono inferiori del 20% rispetto alle tariffe standard Anthropic in tutte e cinque le categorie di token qui sotto. I prezzi sono in USD per un milione di token; confronta la stessa categoria su ciascun percorso quando stimi il tuo carico di lavoro.
Tariffa per 1M token
API diretta Anthropic
Tariffa mostrata da CometAPI
Input standard
$8
$6.4
Output standard
$40
$32
Cache write, TTL 5 min
$10
$8
Cache write, TTL 1 ora
$16
$12.8
Cache read
$0.20
$0.16
Le tariffe sono state verificate il 10 novembre 2026. Questo confronto usa le tariffe standard API pubblicate, prima di eventuali accordi specifici di account o addebiti aggiuntivi per strumenti.
Stima di una richiesta senza cache
Per 100,000 token in input e 10,000 token in output senza caching, CometAPI costa una stima di (0.1 x $6.40) + (0.01 x $32) = $0.96. Lo stesso uso di token alle tariffe standard di Anthropic costa (0.1 x $8) + (0.01 x $40) = $1.20. Risparmi $0.24 per richiesta, ovvero il 20%, prima di eventuali addebiti aggiuntivi per strumenti.
Con 1,000 richieste con quel consumo di token, la spesa stimata per i token scende da $1,200 a $960, lasciando $240 per esecuzioni aggiuntive o altri carichi di lavoro con modelli. Per un budget di produzione, usa i conteggi di token effettivamente fatturati e includi retry, operazioni di cache e strumenti fatturati separatamente.
La guida di CometAPI al fallback di modelli e provider offre un utile passo successivo: un modello secondario compatibile può usare la stessa chiave e base URL di CometAPI, con un percorso ufficiale configurato separatamente se necessario. La tua applicazione deve implementare la policy; i soli ID modello non normalizzano i formati dei contenuti né garantiscono un recupero riuscito.
Limitazioni di Claude Fable 5.2
Nonostante le capacità avanzate, Fable 5.2 presenta diversi vincoli pratici:
Costi token più elevati: a $8 per milione di token in input e $40 per milione di token in output, è notevolmente più costoso di Opus 5.5.
Latenza moderata: le sue capacità di ragionamento avanzate e orizzonte lungo non lo rendono la scelta migliore per applicazioni sensibili alla latenza.
Thinking adattivo non disattivabile: gli sviluppatori devono gestire la profondità del ragionamento tramite le impostazioni di effort.
Task su cybersecurity e biologia limitati: Fable include classificatori di sicurezza che bloccano alcune richieste di ricerca ad alto rischio in ambito cybersecurity e biologico.
Restrizioni sui parametri API: la selezione forzata degli strumenti usando i tipi di tool_choice any e tool restituisce un errore 400. Parametri di campionamento come temperature, top_p e top_k dovrebbero essere omessi.
Requisiti di conservazione dei dati: la documentazione del modello di Anthropic specifica una conservazione dei dati di 30 giorni per Fable 5.2, salvo eccezioni esplicite autorizzate.
Verifiche comuni di setup
Sintomo
Prima azione
401 o 403
Verifica che la chiave appartenga all’endpoint selezionato e abbia accesso al modello.
Modello sconosciuto o 404
Controlla la base URL e l’ID modello esatto.
400 invalid request
Ispeziona il body dell’errore per campi non supportati o un prefisso preservato non valido.
Motivo di arresto max_tokens
Rivedi la risposta parziale e il budget di output prima di avviare un’altra richiesta.
Per un errore imprevisto, registra ora, ID modello, stato e request ID quando presente. Tieni chiavi API e testo sensibile del prompt fuori dai log di routine.
Domande frequenti
Come ottengo l’accesso alla Claude Fable 5.2 API?
Scegli l’accesso diretto ad Anthropic o CometAPI, crea una chiave API per quel provider e configura fatturazione o saldo. Invia la tua prima richiesta Messages con il modello claude-fable-5-2. Gli endpoint usati in questa guida sono https://api.anthropic.com/v1/messages e https://api.cometapi.com/v1/messages. Usa la chiave emessa dal provider che chiami; le chiavi non sono intercambiabili. Segui la sezione di setup sopra e la documentazione Messages di CometAPI per il percorso gateway.
Quanto costa la Claude Fable 5.2 API?
La tariffa standard Anthropic è $8 per milione di token in input e $40 per milione di token in output. CometAPI elenca $6.40 e $32, rispettivamente, come verificato l’11 novembre 2026. A tali tariffe, 100,000 token in input più 10,000 token in output costano $1.20 direttamente o $0.96 tramite CometAPI, senza caching o addebiti aggiuntivi. Le operazioni di cache e le modalità opzionali hanno tariffe separate.
Posso usare l’SDK Python di Anthropic con CometAPI?
Sì. CometAPI documenta un endpoint Messages compatibile con Anthropic. Configura il client Anthropic con la tua chiave CometAPI e base_url="https://api.cometapi.com", quindi usa client.messages.create. La base URL dell’SDK in questa guida non ha il suffisso /v1. Mantieni l’ID modello impostato su claude-fable-5-2 e verifica ogni funzionalità opzionale sul percorso selezionato prima di farci affidamento.
Posso disattivare il thinking nella Claude Fable 5.2 API?
No. Fable 5.2 usa thinking adattivo sempre attivo. Controlla la profondità del ragionamento con output_config.effort; il valore predefinito dell’API è high. Non inviare thinking disabilitato o una configurazione manuale di budget_tokens. La guida alla migrazione spiega le impostazioni supportate. Testa effort più basso su task rappresentativi se vuoi ridurre costo o latenza del ragionamento.
Claude Fable 5.2 supporta input di immagini e una finestra di contesto da 1M token?
Sì. Le specifiche del modello elencano input di testo e immagini, output testuale, finestra di contesto da 1M token e fino a 128K token di output. L’input immagine consente di analizzare un’immagine esistente; non rende il modello un generatore di immagini. Conferma i limiti di dimensione della richiesta sul percorso scelto prima di inviare payload grandi.
Posso migrare da Fable 5.1 cambiando solo l’ID modello?
Una semplice richiesta di testo nuova potrebbe richiedere solo la modifica del modello, ma un’integrazione di produzione richiede più verifiche. La guida ufficiale alla migrazione identifica modifiche alla convalida del prefisso di conversazione, compatibilità dei blocchi di thinking, uso del computer e selezione dell’advisor. Segui la sezione sulla migrazione sopra, soprattutto se la tua applicazione modifica la cronologia, cambia modello a metà conversazione o usa questi strumenti.
Perché la mia richiesta alla Claude Fable 5.2 API restituisce un errore 400?
Leggi prima il messaggio di errore della risposta. Le cause comuni includono impostazioni di thinking non supportate, prefilling dell’assistente, selezione forzata degli strumenti o riproduzione di blocchi di thinking dopo aver modificato la conversazione precedente. La guida alla migrazione di Anthropic descrive queste restrizioni. Riproduci il problema con una richiesta minima nuova, quindi aggiungi di nuovo opzioni e cronologia in modo incrementale. Ripetere la stessa richiesta non valida non lo risolverà.
Come dovrei gestire i rate limit della Claude Fable 5.2 API?
Riduci le richieste concorrenti e segui Retry-After quando il gateway lo restituisce. La configurazione dei retry dell’SDK Python ti consente di limitare i retry automatici; già ritenta alcuni errori transitori, inclusi i 429. Evita di impilare un loop di retry applicativo illimitato sopra. Se i problemi persistono, controlla quota e saldo dell’account selezionato invece di aumentare il numero di retry.
Conclusioni
Scegli un percorso, salva la sua configurazione del client ed esegui l’esempio testuale finché non sai spiegare il motivo di arresto e l’uso restituiti. Poi valida una funzionalità aggiuntiva per volta con input che il tuo prodotto riceverà davvero.
Esegui un piccolo pilota simile alla produzione tramite CometAPI e confronta gli addebiti token registrati con la stima sopra. Se la tua roadmap include altri provider, aggiungi un secondo modello per testare il flusso di accesso e fatturazione condiviso. Mantieni disponibile l’accesso diretto ad Anthropic quando serve un requisito nativo, ed espandi la configurazione che soddisfa i tuoi obiettivi di qualità e budget.
Come utilizzare l'API di Claude Fable 5.2: guida completa 2026 - CometAPI
