Ce que vous obtenez, et ce que vous n'obtenez pas
Soyons précis dès le départ, car le nom du site peut induire en erreur. Il ne s'agit pas de l'API officielle de xAI ou de Grok. C'est une API hébergée devant un seul modèle à poids ouverts, gérée par un fournisseur indépendant et ajustée pour répondre sans refus de contenu pour un usage adulte légal. Ce n'est pas non plus un routeur entre plusieurs fournisseurs. Si vous avez besoin des modèles propres à xAI, rendez-vous sur xAI et consultez leurs conditions et tarifs actuels.
Ce qui est utile, c'est un flux de travail développeur classique. L'API utilise le format de complétions de chat OpenAI, donc les bibliothèques clientes que vous utilisez déjà continuent de fonctionner. Vous modifiez deux valeurs, l'URL de base et la clé, et vous passez uncensored comme ID de modèle. Deux endpoints existent : POST /v1/chat/completions et GET /v1/models. L'authentification est un en-tête Authorization: Bearer standard.
Le service est uniquement textuel. Il n'y a pas de génération d'images, d'audio ou de vidéo, ni d'embeddings ni de fine-tuning. La fenêtre de contexte est de 100 000 tokens, comptés ensemble pour le prompt et la complétion, et max_tokens est optionnel. Il y a une limite de contenu stricte : rien qui implique du contenu sexuel avec des mineurs, jamais.
Si cela correspond à ce que vous construisez, la suite de cette page couvre les détails que les développeurs demandent : la première requête, le streaming, la sortie structurée, les outils, les limites et le coût.
Votre première requête
Créez un compte depuis la page de la clé API, copiez la clé et envoyez une requête. L'inscription fonctionne avec Google ou avec un e-mail et un mot de passe. Les nouveaux utilisateurs peuvent réclamer 0,50 $ de crédit d'essai gratuit en un clic sur cette page, une fois par personne, valable sept jours. La clé d'essai fonctionne avec des limites inférieures à celles d'une clé complète : 2 requêtes simultanées et 60 requêtes par minute.
Commencez par curl, car cela élimine toutes les autres variables :
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."}
]
}'
Le même appel avec le SDK Python officiel :
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)
Un appel à GET /v1/models est un moyen peu coûteux de vérifier que votre clé et votre URL de base sont correctes avant de déboguer autre chose. Chaque réponse contient les en-têtes X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests et X-RateLimit-Limit-Concurrency. Enregistrez l'ID de requête avec vos propres journaux, et surveillez l'en-tête de solde si vous exécutez des tâches non supervisées.
Les paramètres d'échantillonnage tels que temperature, top_p, stop, seed et les pénalités de fréquence et de présence sont transmis au modèle. La liste complète des paramètres se trouve sur la page de documentation.
Streaming
Définissez stream: true et la réponse arrive sous forme d'événements envoyés par le serveur, un chunk par groupe de tokens, avec l'utilisation rapportée à la fin du flux. Pour une interface de chat, c'est la différence entre un écran qui attend et un écran qui tape.
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)
Dans Node, le schéma est le même :
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 détail est important pour la planification de la capacité. Une requête en streaming conserve son slot de concurrence jusqu'à la fin du flux. Si un client ouvre un flux puis se met en attente, ce slot reste occupé, alors fermez les flux que vous ne lisez plus.
Mode JSON et appel d'outils
Pour une sortie structurée, passez response_format avec le type json_object. Indiquez également dans le prompt que vous voulez du JSON, et nommez les clés que vous attendez. Le mode JSON aide le modèle à produire du texte analysable, mais vous devez toujours valider le résultat dans votre code et gérer une analyse échouée.
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)
Appel de fonctions
L'appel de fonctions suit la forme OpenAI. Vous envoyez tools et éventuellement tool_choice. Le modèle répond avec tool_calls, vous exécutez la fonction, et vous renvoyez le résultat sous forme de message avec role: "tool". Les appels d'outils peuvent également être diffusés en 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)
Analysez toujours la chaîne d'arguments de manière défensive. Les modèles retournent parfois des arguments qui ne sont pas du JSON valide, et un try/except autour de json.loads avec une seule nouvelle tentative est une assurance peu coûteuse.
Limites de débit, 429 et tentatives
Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute. Une clé d'essai permet 2 et 60. Le corps de requête maximum est de 8 Mo. Lorsque vous dépassez une limite, vous obtenez un HTTP 429, et le code d'erreur indique quelle limite : rate_limited signifie trop de requêtes par minute, concurrency signifie trop de requêtes à la fois. En cas de surcharge temporaire, l'API renvoie également un 429 avec un en-tête Retry-After: 5.
Cela vous donne une règle de nouvelle tentative simple : en cas de 429, attendez Retry-After s'il est présent, sinon appliquez un backoff exponentiel avec jitter, et plafonnez les tentatives.
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")
Si vous exécutez des tâches par lots, plafonnez votre pool de workers à 8 sur une clé complète. Huit workers détenant chacun une requête est le plafond, et un neuvième ne vous rapportera que des 429 avec le code concurrency. Les requêtes échouées ou refusées ne sont pas facturées, donc les nouvelles tentatives ne vous coûtent pas d'argent.
Les habitudes qui font gagner du temps en production
Quelques pratiques rapportent rapidement une fois que la première requête fonctionne. Stockez la clé dans une variable d'environnement ou un gestionnaire de secrets, et donnez à chaque environnement sa propre clé afin de pouvoir en renouveler une sans toucher aux autres. Enregistrez la valeur X-Request-Id à côté de votre ID de trace ; si quelque chose semble incorrect dans une réponse, cet ID est celui à citer.
Définissez un délai d'attente sur le client. Les générations longues sont normales lorsque vous autorisez une grande complétion, alors choisissez un délai d'attente adapté à votre réponse la plus longue attendue, et utilisez le streaming pour tout ce qu'une personne attend. Plafonnez max_tokens dans les chemins visibles par l'utilisateur même si le paramètre est optionnel, car un plafond met une limite à la fois sur la latence et sur les dépenses.
Gardez l'historique de conversation que vous envoyez sous contrôle. La fenêtre est de 100 000 tokens, mais l'entrée est facturée à chaque appel, donc réduire les anciens tours ou les résumer est l'optimisation la moins chère que vous ayez. Enfin, figez vos paramètres d'échantillonnage. La définition de seed avec une température fixe vous donne des exécutions plus reproductibles lorsque vous comparez des variantes de prompt, bien que vous ne devriez pas le considérer comme une garantie de sortie identique.
Ce que cela coûte
La tarification est de 0,15 $ par 1 M de tokens d'entrée et de 0,50 $ par 1 M de tokens de sortie, à partir du crédit prépayé. Il n'y a pas d'abonnement et le crédit n'expire jamais. Un exemple concret le rend tangible. Prenons une requête avec 2 000 tokens d'entrée et 500 tokens de sortie :
- Entrée : 2 000 / 1 000 000 x 0,15 $ = 0,0003 $
- Sortie : 500 / 1 000 000 x 0,50 $ = 0,00025 $
- Total : 0,00055 $ par requête, donc 1 000 requêtes de cette taille coûtent 0,55 $.
Le crédit d'essai de 0,50 $ couvre donc environ 900 requêtes de cette taille. Les recharges vont de 20 $ à 500 $ en tout montant entier, avec un bonus de 5 % à partir de 50 $, de 10 % à partir de 100 $ et de 15 % à partir de 200 $. Une recharge de 100 $ crédite par exemple 110 $. Le paiement est uniquement en crypto sur ce site : USDT sur TRC20 ou USDC sur Base. La page de tarification contient le tableau actuel.
Les prompts ne sont pas utilisés pour l'apprentissage. Si vous pesez cela contre un autre endpoint, l'article existant sur paiement par token et fenêtre de contexte de 100k couvre le comportement de la comptabilisation dans les longues conversations.
Quand une autre option convient mieux
Soyez honnête sur l'adéquation. Si vous avez besoin de génération d'images, d'embeddings, de parole ou d'un modèle fine-tuned, cette API ne les propose pas. Si votre équipe de contrat ou de conformité exige un fournisseur de première partie, utilisez ce fournisseur. Si vous avez besoin d'une identité de modèle garantie d'un laboratoire spécifique, ce n'est pas le bon produit, car il exécute un seul modèle à poids ouverts d'un fournisseur indépendant.
Ce qui convient, c'est une application qui parle déjà le protocole OpenAI et a besoin d'un modèle textuel qui répond aux demandes adultes légales sans les refuser : outils d'écriture, applications de jeu de rôle et d'accompagnement pour adultes, étiquetage de données touchant des sujets difficiles, et bancs de test. Pointez votre client existant vers la nouvelle URL de base et comparez la sortie sur vos propres prompts avant de vous engager avec du crédit.
