Introduzione
Chat compatibile con OpenAI per Grok 4.5, il modello per il codice della linea Grok di xAI. Un turno porta parti text e image_url, lo sforzo di ragionamento sale fino a xhigh e una singola risposta può arrivare a 450.000 token.
xAI pubblica Grok 4.5 per il software agentico, l'ingegneria e i compiti di workflow, lo ha addestrato con dati aggiuntivi di scienze, ingegneria e matematica e lo serve anche con gli alias grok-4.5-latest e grok-build-latest. Qui è un endpoint su /v1/chat/completions che legge fino a 500.000 token distribuiti su al massimo 256 messaggi ordinati e ne restituisce fino a 450.000 in una sola risposta. Input, input in cache e output vengono misurati separatamente l'uno dall'altro: è questa la parte che un ciclo di agente, mentre rigioca un prefisso lungo, sta davvero pagando.
Caratteristiche principali
Il prefisso che rimandi ha un contatore suo
Un ciclo di agente manda a ogni passo lo stesso system prompt, le stesse definizioni di strumenti e la stessa mappa dei file; di nuovo c'è solo la coda della conversazione. L'input servito dalla cache torna contato a parte nel blocco usage e misurato su una tariffa sua più bassa. Non c'è niente da accendere. Lasciare i primi messaggi invariati fra un passo e l'altro è tutta la tecnica, e quanto del prefisso sia finito davvero in cache te lo dice la risposta, invece di lasciartelo supporre.
Testo e immagini in ingresso, testo in uscita
Il contenuto può essere una stringa semplice o un array di parti, e questo modello ne dichiara due: {"type": "text", "text": "..."} e {"type": "image_url", "image_url": {"url": "...", "detail": "auto|low|high"}}. Uno screenshot e la domanda che lo riguarda viaggiano nello stesso turno, e il contenuto delle immagini è conteggiato dentro la finestra da 500.000 token, non sopra di essa. Su questo endpoint non esistono parti file né PDF, quindi una specifica, un log o un diff deve arrivare come testo incollato. Lo sforzo di ragionamento accetta low, medium, high o xhigh e parte da high; si paga in token di output, quindi pesa sul limite di risposta quanto sul conto.
Parametri della richiesta
| Parametro | Obbligatorio | Nota |
|---|---|---|
messages | Sì | Al massimo 256 turni. Il contenuto può mescolare parti text e |
reasoning_effort | No | low, medium, high o xhigh. High è il valore predefinito; lo sforzo viene speso in token di output, quindi xhigh alza il conto anche con una risposta corta. |
max_tokens | No | Limita la risposta visibile a 450.000; il valore predefinito di 4.096 tronca silenziosamente una risposta lunga. |
temperature | No | Da 0 a 2, predefinito 0,7. Usa 0 quando confronti due patch o due esecuzioni dello stesso compito. |
top_p | No | Da 0,01 a 1. Regola questo valore oppure temperature, non entrambi. |
tools | No | Fino a 128 definizioni di funzione per richiesta. Tenerne stabile l'ordine fra un passo e l'altro aiuta il prefisso a restare in cache. al massimo 128 elementi |
parallel_tool_calls | No | true o false, predefinito true: il modello può chiedere più chiamate agli strumenti nello stesso turno. Predefinito: |
tool_choice | No | auto, none, required, oppure un oggetto che nomina la funzione da chiamare. |
response_format | No | Chiedi un oggetto JSON quando la risposta viene interpretata dal passo successivo di un agente e non letta da una persona. |
Prezzi
Input $2 / Output $6 per 1 milione di token; Prompt da 200K token in su: Input $4 / Output $12
L'input totale include i token in cache. Da 200.000 token di input in su, le tariffe a contesto lungo si applicano a tutto l'input, all'input in cache e all'output della richiesta; input più piccoli usano le tariffe standard. L'input in cache viene misurato a parte dall'input nuovo e tariffato al di sotto. L'output include i token di ragionamento, quindi alzare lo sforzo di ragionamento costa di più anche quando la risposta visibile è lunga uguale. Controlla il budget della richiesta prima di inviarla. L'importo bloccato all'inizio non tiene conto di risparmi da cache e il conguaglio restituisce la differenza rispetto all'uso misurato.
Casi d’uso
Tenere l'intero ciclo dentro il contesto
Un agente di codice rimanda a ogni passo le sue istruzioni, le sue definizioni di strumenti e la sua mappa dei file, e ogni volta aggiunge qualche centinaio di token nuovi. Tutto questo sta dentro la finestra da 500.000 token, la parte ripetuta viene misurata come input in cache, e la richiesta passa alla fascia a contesto lungo solo a 200.000 token sommati di input e input in cache: cosa che la stima prima dell'invio ti dice prima che tu la paghi.
Refactoring con modulo, test e fallimento in un turno
Incolla insieme il modulo, il file di test e l'output fallito, poi chiedi la patch con il ragionamento che la sostiene. Alza reasoning_effort a xhigh quando la modifica va pensata prima di essere scritta: spende più token di output prima che compaia la prima riga di codice, e su un cambiamento che rileggerai riga per riga è la scelta giusta.
Far leggere insieme uno screenshot e uno stack trace
Allega una dashboard fallita come parte image_url con detail high, incolla lo stack trace come testo nello stesso messaggio e chiedi le cause in ordine di probabilità. Immagine e log arrivano in un turno solo, quindi il modello legge il pannello e non la tua descrizione di esso.
Riavere un dossier di migrazione in una risposta
450.000 token di output bastano per un piano di migrazione completo, un modulo riscritto o un manuale tradotto in una sola risposta invece che in un ciclo per capitoli. Alza max_tokens in modo esplicito: il predefinito di 4.096 tronca una generazione lunga senza sollevare un errore, e il troncamento è il guasto che somiglia di più a una risposta finita.
Consigli avanzati
Scegli il livello di sforzo per compito, non per progetto
reasoning_effort parte da high, quindi omettere il campo significa pagare già un lavoro ponderato e i token di output che ne derivano. Decidi chiamata per chiamata: xhigh per una migrazione o una dimostrazione, high per una revisione ordinaria, low per un turno meccanico come classificare una riga di log. Siccome lo sforzo si paga in token di output, una risposta corta a xhigh può costare più di una lunga a low.
Chiedi l'artefatto, con un corpo pronto da incollare
Fissa la forma dell'output nel messaggio di sistema e lascia che il turno utente porti le prove — il file, il log, lo screenshot — così il modello non deve indovinare il formato mentre lavora sul problema.
curl https://api.spicyapi.ai/v1/chat/completions \
-H "Authorization: Bearer $SPICY_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "xai/grok-4.5",
"messages": [
{"role": "system", "content": "Return the patched file in full. No diffs, no commentary, no omitted regions."},
{"role": "user", "content": [
{"type": "text", "text": "Both panels are the same service before and after the deploy. Which one regressed, and what in the diff explains it?"},
{"type": "image_url", "image_url": {"url": "https://cdn.spicyapi.ai/models/examples/inputs/c681580c3c6a0b63.jpeg", "detail": "high"}}
]}
],
"reasoning_effort": "high",
"max_tokens": 32000
}'
Leggi il blocco usage prima di toccare qualsiasi cosa
La risposta riporta separatamente i token di input, di input in cache e di output, ed è l'unica risposta onesta alla domanda se il tuo prefisso sia stato messo in cache. Regola partendo da lì e non dalla forma della conversazione: se la quota in cache resta a zero passo dopo passo, qualcosa cambia nei primi messaggi — un timestamp nel system prompt, un elenco di strumenti riordinato — e spostare quel pezzo in fondo alla richiesta è quasi sempre l'intera correzione. Le risposte lunghe leggile in streaming con stream: true, che restituisce eventi chat.completion.chunk fino a data: [DONE].
Avvio rapido dell’API
curl --fail-with-body -sN https://api.spicyapi.ai/v1/chat/completions \
-H "Authorization: Bearer $SPICY_API_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: $(uuidgen)" \
-d '{
"model": "xai/grok-4.5/chat",
"messages": [
{
"role": "user",
"content": "Summarise the following release notes into three bullet points."
}
],
"stream": true
}' \
| jq --unbuffered -Rrj 'select(startswith("data: ")) | .[6:] | select(. != "[DONE]") | fromjson | if .error then "\n[error] \(.error.message)\n" else (.choices[0].delta.content? // empty) end'
Nel riferimento dell’API trovi autenticazione, schema completo, polling e gestione degli errori.
