IT ▾
Ottieni la chiave API

uncensoredgrok.comGuida

API Grok per sviluppatori: un'opzione compatibile con OpenAI

Se hai cercato un'api grok per sviluppatori, ecco cosa offre questo sito e cosa non offre. È un'API testuale indipendente compatibile con OpenAI, non il servizio di xAI, e funziona con qualsiasi SDK OpenAI.

Aggiornato

Illustrazione isometrica di un terminale che trasmette blocchi di dati in un cubetto server, che rappresenta un'API LLM per sviluppatori
uncensoredgrok.com2026-10-06

Cosa ottieni e cosa non ottieni

Siamo precisi fin da subito, perché il nome del sito può trarre in inganno. Questa non è l'API ufficiale di xAI o di Grok. È un'API ospitata davanti a un modello a pesi aperti, gestita da un provider indipendente e ottimizzata per rispondere senza rifiuti di contenuti per uso adulto legale. Non è nemmeno un router tra diversi fornitori. Se ti servono i modelli di xAI, vai su xAI e controlla i loro termini e prezzi attuali.

Ciò per cui è utile è un flusso di lavoro standard per sviluppatori. L'API parla il formato delle chat completions di OpenAI, quindi le librerie client che usi già continuano a funzionare. Modifichi due valori, il base URL e la chiave, e passi uncensored come ID del modello. Esistono due endpoint: POST /v1/chat/completions e GET /v1/models. L'autenticazione è un header standard Authorization: Bearer.

Il servizio è solo testuale. Non ci sono generazione di immagini, audio o video, né embeddings né fine-tuning. La finestra di contesto è di 100.000 token, contati complessivamente tra prompt e completion, e max_tokens è opzionale. C'è un limite rigido sui contenuti: niente che coinvolga contenuti sessuali con minorenni, mai.

Se questo corrisponde a ciò che stai costruendo, il resto di questa pagina copre i dettagli che gli sviluppatori chiedono: la prima richiesta, lo streaming, l'output strutturato, gli strumenti, i limiti e il costo.

La tua prima richiesta

Crea un account dalla pagina della chiave API, copia la chiave e invia una richiesta. La registrazione funziona con Google o con email e password. I nuovi utenti possono richiedere $0,50 di credito di prova con un clic su quella pagina, uno per persona, valido per sette giorni. La chiave di prova funziona con limiti inferiori rispetto a una chiave completa: 2 richieste parallele e 60 richieste al minuto.

Inizia con curl, perché rimuove ogni altra variabile:

curl https://api.uncensoredgrok.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "Explain idempotency keys in two sentences."}
    ]
  }'

La stessa chiamata con l'SDK Python ufficiale:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredgrok.com/v1",
    api_key="YOUR_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Explain idempotency keys in two sentences."}],
    temperature=0.7,
)
print(resp.choices[0].message.content)

Una chiamata a GET /v1/models è un modo economico per verificare che la tua chiave e il base URL siano corretti prima di fare debug di qualsiasi altra cosa. Ogni risposta trasporta gli header X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency. Registra l'ID della richiesta con i tuoi log e osserva l'header del saldo se esegui job non presidiati.

I parametri di campionamento come temperature, top_p, stop, seed e le penalità di frequenza e presenza sono passati al modello. Le note complete sui parametri sono nella pagina della documentazione.

Streaming

Imposta stream: true e la risposta arriva come eventi server-sent, un chunk per gruppo di token, con l'utilizzo riportato alla fine dello stream. Per un'interfaccia chat questa è la differenza tra uno schermo che aspetta e uno schermo che digita.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a haiku about retries."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\ntokens:", chunk.usage)

In Node il pattern è lo stesso:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.uncensoredgrok.com/v1",
  apiKey: process.env.API_KEY,
});

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Write a haiku about retries." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Un dettaglio è importante per la pianificazione della capacità. Una richiesta in streaming mantiene il suo slot di concorrenza fino alla fine dello stream. Se un client apre uno stream e poi si blocca, quello slot rimane occupato, quindi chiudi gli stream che non leggi più.

Modalità JSON e chiamata di funzioni

Per l'output strutturato, passa response_format con il tipo json_object. Indica anche nel prompt che vuoi JSON e nomina le chiavi che ti aspetti. La modalità JSON aiuta il modello a produrre testo analizzabile, ma dovresti comunque convalidare il risultato nel tuo codice e gestire un'analisi fallita.

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"title\": string, \"tags\": [string]}"},
        {"role": "user", "content": "Summarize: a guide to rate limiting for API clients."},
    ],
)
import json
data = json.loads(resp.choices[0].message.content)

Chiamata di funzioni

La chiamata di funzioni segue la forma di OpenAI. Invii tools e opzionalmente tool_choice. Il modello risponde con tool_calls, esegui la funzione e invii il risultato indietro come messaggio con role: "tool". Anche le chiamate agli strumenti possono essere in streaming.

import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up an order by id",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = {"order_id": args["order_id"], "status": "shipped"}
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)

Analizza sempre la stringa degli argomenti in modo difensivo. I modelli a volte restituiscono argomenti che non sono JSON valido, e un try/except attorno a json.loads con un solo retry è un'assicurazione economica.

Limiti di richieste, 429 e retry

Una chiave completa permette 8 richieste parallele e 300 richieste al minuto. Una chiave di prova ne permette 2 e 60. Il corpo massimo della richiesta è 8 MB. Quando superi un limite ottieni HTTP 429, e il codice errore ti dice quale limite: rate_limited significa troppe richieste al minuto, concurrency significa troppe contemporaneamente. In caso di sovraccarico temporaneo l'API restituisce anche 429 con un header Retry-After: 5.

Questo ti dà una regola di retry semplice: su 429, aspetta Retry-After se presente, altrimenti backoff esponenziale con jitter, e limita i tentativi.

import time, random
from openai import OpenAI, RateLimitError

client = OpenAI(base_url="https://api.uncensoredgrok.com/v1", api_key="YOUR_KEY", max_retries=0)

def ask(messages, attempts=5):
    for i in range(attempts):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", 2 ** i))
            time.sleep(wait + random.random())
    raise RuntimeError("still rate limited")

Se esegui job batch, limita il tuo pool di worker a 8 su una chiave completa. Otto worker che tengono ciascuno una richiesta sono il limite massimo, e un nono ti farà ottenere solo errori 429 con il codice concurrency. Le richieste fallite o rifiutate non vengono addebitate, quindi il retry non ti costa denaro.

Abitudini che fanno risparmiare tempo in produzione

Alcune pratiche ripagano rapidamente una volta che la prima richiesta funziona. Memorizza la chiave in una variabile d'ambiente o in un gestore di segreti, e dai a ogni ambiente la propria chiave in modo da poter ruotare una senza toccare le altre. Registra il valore X-Request-Id accanto al tuo ID di traccia; se qualcosa sembra sbagliato in una risposta, quell'ID è quello da citare.

Imposta un timeout sul client. Le generazioni lunghe sono normali quando permetti una completion grande, quindi scegli un timeout che si adatti alla tua risposta più lunga attesa, e usa lo streaming per qualsiasi cosa per cui una persona stia aspettando. Limita max_tokens nei percorsi visibili all'utente anche se il parametro è opzionale, perché un limite mette un soffitto sia alla latenza che alla spesa.

Mantieni sotto controllo la cronologia delle conversazioni che invii. La finestra è di 100.000 token, ma l'input viene fatturato su ogni chiamata, quindi tagliare i turni vecchi o riassumerli è l'ottimizzazione più economica che hai. Infine, blocca le tue impostazioni di campionamento. Impostare seed insieme a una temperatura fissa ti dà esecuzioni più ripetibili quando confronti varianti di prompt, anche se non dovresti considerarlo una garanzia di output identico.

Quanto costa

La tariffazione è $0,15 per 1M token di input e $0,50 per 1M token di output, da credito prepagato. Non c'è abbonamento e il credito non scade mai. Un esempio pratico lo rende concreto. Prendi una richiesta con 2.000 token di input e 500 token di output:

  • Input: 2.000 / 1.000.000 × $0,15 = $0,0003
  • Output: 500 / 1.000.000 × $0,50 = $0,00025
  • Totale: $0,00055 per richiesta, quindi 1.000 richieste di questo tipo costano $0,55.

Il credito di prova di $0,50 copre quindi circa 900 richieste di quelle dimensioni. Le ricariche vanno da $20 a $500 in qualsiasi importo intero, con un bonus del 5% da $50, 10% da $100 e 15% da $200. Una ricarica di $100, ad esempio, accredita $110. Il pagamento è solo cripto su questo sito: USDT su TRC20 o USDC su Base. La pagina dei prezzi ha la tabella attuale.

I prompt non sono usati per l'addestramento. Se stai valutando questo rispetto ad altri endpoint, l'articolo esistente su pagamento per token e la finestra di contesto da 100k copre come si comporta la misurazione nelle conversazioni lunghe.

Quando un'altra opzione è più adatta

Sii onesto riguardo all'adattamento. Se ti serve la generazione di immagini, embeddings, sintesi vocale o un modello sottoposto a fine-tuning, questa API non li offre. Se il tuo contratto o il team di compliance richiede un fornitore di prima parte, usa quel fornitore. Se ti serve una garanzia sull'identità del modello da un laboratorio specifico, questo è il prodotto sbagliato, poiché esegue un singolo modello a pesi aperti da un provider indipendente.

Dove si adatta è un'applicazione che già parla il protocollo OpenAI e ha bisogno di un modello testuale che risponda alle richieste adulte legali senza rifiutarle: strumenti di scrittura, app di roleplay e companion per adulti, etichettatura dati che tocca argomenti difficili e harness di test. Punta il tuo client esistente al nuovo base URL e confronta l'output sui tuoi prompt prima di impegnare il credito.

Domande e risposte

uncensoredgrok.comDomande e risposte
È questa l'API ufficiale di Grok?

No. È un'API indipendente compatibile con OpenAI davanti a un modello a pesi aperti. Non è gestita da xAI e non è un router tra fornitori.

Quale ID modello devo usare?

Usa uncensored come valore del modello in ogni richiesta. Una richiesta GET a /v1/models elenca ciò che la chiave può vedere.

Supporta lo streaming e la chiamata di funzioni?

Sì. Lo streaming funziona tramite SSE con stream: true, e la chiamata di funzioni supporta tools, tool_choice e tool_calls in streaming, con i risultati inviati come messaggi con role tool.

Come pago?

Su questo sito ricarichi solo con cripto, USDT su TRC20 o USDC su Base, in qualsiasi importo intero da $20 a $500.

Quali sono i limiti di richieste?

Una chiave completa ottiene 8 richieste parallele e 300 richieste al minuto. Una chiave di prova ne ottiene 2 e 60. Superato un limite ricevi HTTP 429.

uncensoredgrok.com2026-10-06

La tua chiave è a un modulo di distanza

Crea un account, copia la chiave, modifica il base URL. È tutta la configurazione.

Ottieni la chiave API