Come usare l'API di Grok 4.7 con Python: chiave API, OpenAI SDK e prima richiesta

Ultima verifica: 28 settembre 2026.

xAI ha introdotto Grok 4.7 nel settembre 2026 per programmazione, attività agentiche e lavoro basato sulla conoscenza. Supporta una finestra di contesto da 500.000 token, la Responses API e Chat Completions. Per gli sviluppatori, la parte difficile spesso non è la prima richiesta, bensì gestire un’altra credenziale del provider, la configurazione dell’SDK, l’account di fatturazione, il catalogo dei modelli e l’endpoint insieme al resto di uno stack multi-modello.

Puoi chiamare Grok 4.7 da Python con l’SDK OpenAI puntando il client a CometAPI, autenticandoti con una chiave CometAPI e selezionando grok-4.7. Lo stesso account, la stessa chiave e la stessa base URL di CometAPI possono anche fornire accesso ai modelli supportati GPT, Claude, Gemini e DeepSeek. In altre parole, puoi mantenere un’unica integrazione di gateway scegliendo di volta in volta il modello più adatto al compito.

Questa guida usa Grok 4.7 per la prima richiesta funzionante, poi mostra cosa rimane invariato quando aggiungi altre famiglie di modelli. Spiega anche il limite importante di “one API”: autenticazione e accesso al gateway sono unificati, ma strumenti specifici del modello, parametri, limiti di contesto ed endpoint supportati possono comunque differire.

Avvio rapido Python per Grok 4.7

L’attuale pagina del modello Grok 4.7 su CometAPI documenta l’ID del modello grok-4.7, la base URL https://api.cometapi.com/v1 e un esempio Python costruito con l’SDK OpenAI. La pagina dedicata usa la Responses API, quindi è il punto di partenza più sicuro per questo tutorial.

1. Crea una chiave CometAPI

Crea o accedi al tuo account CometAPI, quindi genera una chiave nella console dei token API. Conservala come variabile d’ambiente invece di inserire il segreto direttamente nel codice sorgente.

export COMETAPI_KEY="your_cometapi_key_here"

Per Windows PowerShell:

$env:COMETAPI_KEY="your_cometapi_key_here"

Non effettuare commit della chiave su Git, non incollarla in un notebook pubblico e non esporla in JavaScript lato browser. Le applicazioni di produzione dovrebbero caricarla da un gestore di segreti o da un ambiente server protetto.

2. Installa l’SDK OpenAI per Python

Crea un ambiente isolato e installa l’SDK corrente:

python -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade openai

Su Windows, attiva l’ambiente con .venv\Scripts\Activate.ps1. L’quickstart dell’API OpenAI ufficiale usa lo stesso pacchetto Python e lo stesso pattern di client; CometAPI modifica la chiave API, la base URL e l’ID del modello.

3. Invia la prima richiesta a Grok 4.7

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
)

response = client.responses.create(
    model="grok-4.7",
    input="Explain one practical use of a unified AI API in two sentences.",
)

print(response.output_text)

Salva il file come grok47_quickstart.py, quindi esegui:

python grok47_quickstart.py

Se la richiesta va a buon fine, lo script stampa la risposta testuale del modello. La tua applicazione sta ora usando il client OpenAI per Python, inviando traffico a CometAPI e selezionando Grok 4.7 tramite l’ID del modello.

Cosa fa ogni riga nella richiesta a Grok 4.7

api_key. L’SDK invia la tua credenziale CometAPI nella richiesta. Una sola chiave CometAPI può essere usata per i modelli abilitati sullo stesso account.

base_url. Questo reindirizza il client OpenAI dal servizio predefinito al gateway CometAPI. Mantieni il suffisso /v1.

model="grok-4.7". L’ID del modello seleziona Grok 4.7. Tratta gli ID dei modelli come input di deployment esatti e sensibili al maiuscolo/minuscolo e confermali sulla pagina del modello live prima del rilascio.

client.responses.create(...). Invia la richiesta tramite la Responses API. L’attuale pagina Grok 4.7 di CometAPI documenta questa rotta e la documentazione attuale di Grok 4.7 di xAI elenca anche la Responses API come supportata.

Puoi usare Grok 4.7 con Chat Completions invece?

Sì. Il changelog del 22 settembre 2026 di CometAPI indica che Grok 4.7 supporta il formato Chat API. Se un’applicazione esistente è costruita su Chat Completions, la chiamata SDK OpenAI corrispondente è:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
)

completion = client.chat.completions.create(
    model="grok-4.7",
    messages=[
        {
            "role": "user",
            "content": "Give me a three-step API migration checklist.",
        }
    ],
)

print(completion.choices[0].message.content)

Usa Responses quando corrisponde alla pagina del modello e al workflow più recente dell’SDK OpenAI. Usa Chat Completions quando stai mantenendo un’integrazione chat consolidata. Non dare per scontato che ogni strumento nativo o parametro specifico del modello abbia una rappresentazione identica in entrambi i formati.

Come un’unica integrazione CometAPI raggiunge GPT, Claude, Gemini, DeepSeek e Grok

Un gateway di modelli unificato è utile quando un’applicazione necessita di più famiglie di modelli senza mantenere una credenziale separata e un percorso di inizializzazione del client per ogni provider. In CometAPI, la chiave API e la base URL restano fisse mentre l’applicazione seleziona un ID modello dal catalogo corrente. I formati degli endpoint e le funzionalità specifiche del provider possono comunque differire, quindi ogni modello dovrebbe essere testato con l’esatta forma di richiesta usata in produzione.

Opzioni di modelli correnti su CometAPI (verificate il 28 settembre 2026)

CometAPI elenca attualmente le seguenti famiglie di modelli nel suo catalogo. Gli esempi sotto usano ID modello verificati il 28 settembre 2026; disponibilità, alias, capacità e prezzi possono cambiare, quindi le applicazioni di produzione dovrebbero ricontrollare la pagina del modello live prima del deployment.

Questi ID modello sono stati controllati rispetto al catalogo e alle pagine dei modelli di CometAPI il 28 settembre 2026. Disponibilità, alias e prezzi possono cambiare; il codice di produzione dovrebbe usare una allowlist approvata e ricontrollare il catalogo live prima del deployment.

Per un semplice workflow testuale compatibile con OpenAI, puoi rendere configurabile il modello:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
)

model = os.getenv("COMETAPI_MODEL", "grok-4.7")

response = client.responses.create(
    model=model,
    input="Summarize the advantages and limits of a unified AI API.",
)

print(response.output_text)

Le parti riutilizzabili sono l’account, la chiave API, la URL del gateway, l’inizializzazione dell’SDK e il wrapper di richiesta della tua applicazione. Ciò che può cambiare è l’endpoint o lo schema di richiesta richiesto da una specifica famiglia di modelli. Un’API unificata riduce la frammentazione di integrazione e fatturazione; non cancella le capacità e i vincoli dei modelli a monte.

Uno schema Python multi-modello più sicuro

Le applicazioni di produzione dovrebbero definire una allowlist invece di accettare nomi di modelli arbitrari dagli utenti. Mantieni le informazioni sulle capacità accanto a ciascun modello approvato in modo che l’applicazione scelga un endpoint e un set di funzionalità compatibili.

MODEL_CONFIG = {
    "grok": {
        "id": "grok-4.7",
        "api": "responses",
    },
    "gpt": {
        "id": "gpt-6-sol",
        "api": "responses",
    },
}

def run_text_request(client, family, prompt):
    config = MODEL_CONFIG[family]

    if config["api"] == "responses":
        result = client.responses.create(
            model=config["id"],
            input=prompt,
        )
        return result.output_text

    raise ValueError(f"Unsupported API format: {config['api']}")

Estendi la allowlist solo dopo aver testato il modello selezionato con l’endpoint e i parametri usati dalla tua applicazione. Questo approccio impedisce che un cambiamento di catalogo o un refuso inviino silenziosamente il traffico di produzione a un modello indesiderato.

Errori comuni e come risolverli

Autenticazione non riuscita. Conferma che COMETAPI_KEY sia presente nella stessa shell che esegue Python, che la chiave sia attiva e che non siano stati copiati spazi extra o virgolette nel valore.

Impossibile trovare il modello. Ricontrolla l’ID del modello live esatto. Per questa guida, l’ID verificato è grok-4.7; non sostituire un nome visualizzato come “Grok 4.7 API.”

L’endpoint rifiuta un parametro. Rimuovi le opzioni specifiche del provider e riprova con la richiesta minima documentata. La compatibilità con OpenAI copre le forme SDK comuni, non ogni parametro nativo tra GPT, Claude, Gemini, DeepSeek e Grok.

La richiesta è soggetta a rate limit o il saldo è insufficiente. Controlla l’uso dell’account e la quota prima di aumentare i tentativi. I tentativi ciechi possono moltiplicare costi e carico senza risolvere un limite a livello di account.

La richiesta scade (timeout) o restituisce un errore temporaneo del server. Aggiungi backoff esponenziale limitato, un timeout di richiesta e un numero massimo di retry. Registra l’ID richiesta e il modello selezionato, ma non registrare la chiave API o contenuti sensibili del prompt.

Checklist di produzione

• Conserva la chiave CometAPI in un gestore di segreti e ruotala se viene esposta.
• Fissa ID modello approvati nella configurazione e rivedi il catalogo live prima del deployment.
• Testa l’esatto endpoint, la modalità di streaming, le chiamate agli strumenti, l’output strutturato e gli input multimodali che intendi usare.
• Imposta timeout espliciti e retry limitati; non riprovare richieste non valide.
• Registra modello, latenza, uso dei token, ID richiesta e metadati di costo senza archiviare segreti.
• Esegui un piccolo canary prima di spostare il traffico di produzione su un nuovo modello o alias.

Perché usare CometAPI per questo flusso di lavoro?

CometAPI è utile quando un team desidera testare o utilizzare diverse famiglie di modelli senza creare un’integrazione separata, un percorso di credenziali e un saldo prepagato per ogni provider. Il quickstart di Grok 4.7 usa il familiare client OpenAI per Python, mentre lo stesso account CometAPI può coprire i modelli supportati GPT, Claude, Gemini, DeepSeek, Grok e i modelli multimodali.

Il vantaggio è la consolidazione operativa: un account, una chiave, una URL di gateway e una superficie di utilizzo condivisa. La disciplina ingegneristica rimane però attenta al modello. I team dovrebbero comunque validare compatibilità degli endpoint, capacità specifiche del modello, prezzi, requisiti di dati e comportamento di fallback prima della produzione.

Prezzi di Grok 4.7 tramite CometAPI

La pagina del modello Grok 4.7 di CometAPI elenca due livelli di contesto. I prezzi sotto sono in dollari USA per 1 milione di token e sono stati verificati il 28 settembre 2026.

La stessa pagina elenca le corrispondenti tariffe dirette xAI come $2.00 input, $0.50 cache read e $6.00 output per il contesto standard, e $4.00 input, $1.00 cache read e $12.00 output per il contesto lungo. Questo rende le tariffe CometAPI visualizzate inferiori del 20% al momento della verifica. Considera queste cifre come uno snapshot datato e controlla la pagina prezzi live prima di stimare la spesa di produzione.

FAQ

Qual è l’ID del modello API Grok 4.7 su CometAPI?

L’ID modello attuale è grok-4.7.

Posso usare l’SDK OpenAI per Python con Grok 4.7?

Sì. Inizializza OpenAI con la tua chiave CometAPI, imposta la base URL dell’API su api.cometapi.com/v1, quindi chiama un endpoint supportato con model="grok-4.7".

Mi serve anche una chiave API xAI?

Non per il percorso CometAPI mostrato qui. La richiesta si autentica con una chiave CometAPI ed è fatturata tramite l’account CometAPI.

La stessa chiave CometAPI può accedere a GPT, Claude, Gemini e DeepSeek?

Sì, per i modelli disponibili sul tuo account CometAPI. Mantieni la chiave CometAPI e la base URL, seleziona un ID modello supportato e usa l’endpoint documentato per quel modello.

Una sola API significa che ogni modello accetta parametri identici?

No. Una sola API può unificare l’accesso all’account, l’autenticazione, il routing e la fatturazione. Strumenti nativi, controlli di ragionamento, input multimodali, impostazioni di sicurezza, limiti di contesto e supporto degli endpoint possono comunque variare per modello.

Dovrei usare Responses o Chat Completions per Grok 4.7?

Inizia con Responses perché l’attuale pagina del modello Grok 4.7 su CometAPI fornisce quell’esempio. Chat Completions è documentato anche nel changelog di CometAPI e può essere appropriato per una codebase basata su chat esistente.

Sintesi finale

Per chiamare Grok 4.7 da Python, installa l’SDK OpenAI, crea una chiave CometAPI, imposta la base URL di CometAPI mostrata nella sezione di setup e scegli grok-4.7. Inizia con una richiesta minimale, conferma l’endpoint e la forma della risposta, quindi aggiungi retry, timeout, logging e controlli di costo prima di passare in produzione.

Usa l’integrazione condivisa come base stabile, quindi mantieni verifiche esplicite delle capacità per ogni modello che aggiungi. Questo equilibrio—un unico gateway operativo con validazione consapevole del modello—è il modo più sicuro per trasformare un’API multi-modello in software di produzione.