Come si usa l'API Grok 4.7? Prima chiamata funzionante in 5 minuti

TL;DR

• Grok 4.7 è il modello testuale di xAI pensato per coding e attività agentiche, già disponibile su HiAPI: apri la pagina del modello per iniziare subito a chattare; i nuovi utenti ricevono 200 crediti alla registrazione.
• Prezzo della piattaforma $0.84 input / $2.52 output (per 1M tokens, lettura cache $0.21), circa il 58% di sconto rispetto al prezzo ufficiale. Una richiesta da 2K input + 1K output costa circa $0.0042; con una richiesta media da 3K token totali (circa $0.0084 ciascuna), $10 coprono circa 1200 chiamate.
• Chiamata più rapida: POST https://api.hiapi.ai/v1/chat/completions, imposta model su grok-4.7; nel codice OpenAI SDK esistente basta cambiare base_url e model.

Cos'è Grok 4.7 e cosa c'è di nuovo

Grok 4.7, rilasciato il 2026-09-21, è il modello attualmente consigliato per default da xAI, incentrato su coding, attività agentiche e knowledge work. Secondo i dati dichiarati da xAI, il punteggio su Terminal-Bench 4.0 passa dal 20,3% di 4.6 al 38,0%, quasi il doppio (dati autodichiarati). Per chi lo chiama via API, le novità da tenere d'occhio sono quattro:

• Coding e attività agentiche sono gli scenari principali: xAI lo ha integrato in strumenti di coding come Cursor e GitHub Copilot; la pianificazione di attività a lungo termine è il punto forte di questa versione.
• Quattro livelli di ragionamento: reasoning_effort supporta low / medium / high / xhigh, default high; il processo di pensiero viene restituito separatamente nel campo reasoning_content, così puoi decidere se mostrarlo.
• JSON object + tool calling: response_format: {"type": "json_object"} forza un output JSON valido; le chiamate di funzione usano il formato standard OpenAI tools, quindi per estrazioni strutturate e cicli agent non serve alcun wrapper aggiuntivo.
• Contesto 500K: una singola richiesta può contenere un intero codebase o lunghi documenti.

Risultato reale: un pezzo di codice per l'analisi dati con pandas

L'output qui sotto è ciò che abbiamo ottenuto eseguendo realmente Grok 4.7 su HiAPI (il prompt completo è nel link sotto). Il compito era analizzare dati di ordini e-commerce: GMV mensile, top 20 utenti per spesa cumulata, trend del primo ordine dei nuovi utenti, con created_at di tipo stringa. Il modello ha completato in 18,5 secondi, con codice completo ed eseguibile, gestendo autonomamente la conversione delle date da stringa:

# ---------- 0. Gestione date: conversione stringa -> datetime ----------
df["created_at"] = pd.to_datetime(df["created_at"], errors="coerce")
df = df.dropna(subset=["created_at", "amount", "user_id"])

# Conta solo gli ordini validi (adatta i valori di status al business reale)
df_valid = df[df["status"] == "paid"].copy()

# ---------- 1. GMV e numero di ordini per mese ----------
df_valid["month"] = df_valid["created_at"].dt.to_period("M")
monthly = (
    df_valid.groupby("month", as_index=False)
    .agg(GMV=("amount", "sum"), order_count=("order_id", "count"))
    .sort_values("month")
)

Questa esecuzione ha usato 3440 token di input e 1427 token di output, circa $0.007 al prezzo della piattaforma. Per ottenere lo stesso risultato, clicca su esegui questo prompt una volta nella pagina del modello →

Due percorsi per iniziare

Percorso uno: browser, 3 passi, zero codice

1. Apri la pagina del modello Grok 4.7, accedi o registrati (i nuovi utenti ricevono 200 crediti).
2. Incolla il tuo prompt nella casella di testo, ad esempio clicca su questo link, il prompt è già compilato automaticamente.
3. Invia direttamente; il credito viene scalato in base ai token effettivamente usati.

Percorso due: API, 3 passi, integra nella tua applicazione

1. Crea una API Key nella console HiAPI.
2. Sostituisci YOUR_HIAPI_API_KEY nel curl qui sotto con la tua Key ed esegui.
3. Imposta model su grok-4.7, sostituisci messages con i tuoi input di business e hai finito.

curl: prima chiamata

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_HIAPI_API_KEY" \
  -d '{
    "model": "grok-4.7",
    "messages": [
      {"role": "system", "content": "You are a senior backend engineer."},
      {"role": "user", "content": "Explain what a database connection pool is in two sentences."}
    ],
    "reasoning_effort": "high",
    "max_tokens": 2000
  }'

Nella risposta, choices[0].message.content è il testo principale, reasoning_content è il processo di pensiero; usage.completion_tokens_details.reasoning_tokens indica separatamente quanti token di ragionamento sono stati consumati. Per lo streaming, aggiungi "stream": true e analizza in SSE.

Python: non-streaming + streaming

Non-streaming, basta requests:

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",
        "messages": [
            {"role": "user", "content": "Write a Python function that merges two sorted lists into one sorted list."}
        ],
        "reasoning_effort": "medium",
        "max_tokens": 4000,
    },
    timeout=120,
)
resp.raise_for_status()
data = resp.json()
print(data["choices"][0]["message"]["content"])

Attenzione a due cose nello streaming: i primi delta.reasoning_content sono il processo di pensiero, i successivi delta.content sono il testo principale; usage compare solo nell'ultimo chunk (choices vuoto), e termina con data: [DONE]:

import json
import requests

with requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",
        "messages": [{"role": "user", "content": "Plan a Redis-based online presence system."}],
        "reasoning_effort": "high",
        "stream": True,
    },
    stream=True,
    timeout=300,
) as resp:
    resp.raise_for_status()
    for line in resp.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        payload = line[len("data:"):].strip()
        if payload == "[DONE]":
            break
        chunk = json.loads(payload)
        if not chunk["choices"]:
            print("\nusage:", chunk["usage"])  # usage è presente solo nell'ultimo chunk
            continue
        delta = chunk["choices"][0]["delta"]
        if delta.get("reasoning_content"):
            print(delta["reasoning_content"], end="", flush=True)
        elif delta.get("content"):
            print(delta["content"], end="", flush=True)

Tabella dei parametri

Campo	Obbligatorio	Valori	Descrizione
model	Sì	grok-4.7	Scrivi sempre questo ID
messages	Sì	Array di messaggi in formato OpenAI	Supporta i ruoli system / user / assistant / tool
reasoning_effort	No	low / medium / high / xhigh, default high	Intensità di ragionamento; il processo di pensiero viene restituito in reasoning_content
max_tokens	No	Intero positivo	Limite di output, include i reasoning tokens; se troppo basso, il ragionamento viene troncato per primo
response_format	No	{"type": "json_object"}	Forza un output JSON valido, adatto all'estrazione strutturata
tools	No	Array OpenAI function calling	Tool calling, supporta la restituzione dei risultati tool su più turni
stream	No	true / false, default false	Streaming SSE; usage è nell'ultimo chunk

Errori che incontrerai

L'ostacolo più comune quando si migra codice da altri modelli: grok-4.7 non supporta i tre parametri frequency_penalty, presence_penalty, stop; se li includi restituisce direttamente 400. reasoning_effort accetta solo i quattro valori low / medium / high / xhigh; con un valore errato l'API restituisce reasoning_effort: is outside allowed values; anche i campi fuori dal protocollo non passano: durante i nostri test abbiamo aggiunto un campo non registrato e l'API ha restituito request.zz: unregistered public parameter.

La soluzione è semplice: rimuovi questi tre parametri, imposta correttamente il livello e reinvia. Per gli altri 4xx controlla prima error.code e poi modifica il codice, senza indovinare.

Da sapere prima della messa in produzione

• I reasoning token sono fatturati come output. Un livello high può includere in una singola risposta decine di migliaia di token di processo di pensiero, fatturati a $2.52/M. Per compiti semplici, abbassare reasoning_effort a low o medium è l'interruttore di risparmio più diretto; usage.completion_tokens_details.reasoning_tokens permette di verificare questo numero separatamente.
• Oltre 200K l'intera richiesta passa al livello superiore. Quando il prompt raggiunge i 200K token (soglia contrattuale 199,999), l'intera richiesta viene fatturata al prezzo per testi lunghi: input $1.68 / output $5.04 / lettura cache $0.42, il doppio del livello normale. Mantieni il traffico ordinario sotto i 200K e non incollare l'intero codebase senza criterio.
• La lettura cache costa solo un quarto del prezzo pieno. I lunghi system prompt ripetuti e i prefissi delle conversazioni multi-turno colpiscono automaticamente la cache, con lettura cache a $0.21/M (un quarto del prezzo pieno $0.84/M). Nei cicli agent, mantieni stabile il prefisso e la bolletta ne beneficerà sensibilmente.

Domande frequenti

Grok 4.7 o Grok 4.6: quale scegliere? Il prezzo della piattaforma è identico ($0.84/$2.52). Per coding complesso e attività agentiche scegli 4.7 (consigliato per default da xAI); per compiti semplici in cui vuoi risparmiare token puoi restare su 4.6. Confronto dettagliato in Grok 4.7 vs Grok 4.6.

Supporta lo streaming? Sì, SSE standard. Nota che usage viene restituito solo nell'ultimo chunk; il usage dei chunk precedenti è vuoto.

reasoning_content costa extra? Non serve attivare nulla separatamente, ma i reasoning token generati contano nell'output e sono fatturati a prezzo output, quindi più alto è il livello, più pesante è la bolletta.

Il contesto di 500K è il limite di input? 500K è la finestra totale di input più output. Quando l'input si avvicina a 200K scatta il prezzo per testi lunghi; vedi «Da sapere prima della messa in produzione» sopra.

---

Per approfondire: per il calcolo dei prezzi vedi Quanto costa l'API Grok 4.7, per 5 prompt di scenario pronti da copiare vedi Raccolta di prompt per Grok 4.7, per l'utilizzo della generazione precedente vedi la pagina del modello Grok 4.6. Copia il prompt pandas qui sopra e vai alla pagina del modello per eseguire la tua prima chiamata.