Wat je krijgt, en wat je niet krijgt
Laten we eerst precies zijn, want de naam van de site kan misleidend zijn. Dit is niet de officiële API van xAI of Grok. Het is een gehoste API voor één open-weight model, gerund door een onafhankelijke provider en afgestemd op antwoorden zonder inhoudsweigeringen voor legaal gebruik door volwassenen. Het is ook geen router tussen meerdere leveranciers. Als je de eigen modellen van xAI nodig hebt, ga dan naar xAI en controleer hun huidige voorwaarden en prijzen.
Waarvoor het nuttig is, is een eenvoudige ontwikkelaarsworkflow. De API spreekt het OpenAI chat-completies-formaat, dus de clientbibliotheken die je al gebruikt blijven werken. Je verandert twee waarden, de base URL en de sleutel, en je voert uncensored in als model-ID. Er zijn twee endpoints: POST /v1/chat/completions en GET /v1/models. Authenticatie is een standaard Authorization: Bearer-header.
De service ondersteunt alleen tekst. Er is geen beeld-, audio- of videogeneratie, geen embeddings en geen fine-tuning. Het contextvenster is 100.000 tokens, geteld over prompt en completion samen, en max_tokens is optioneel. Er is één harde inhoudslimiet: niets dat seksuele inhoud met minderjarigen omvat, ooit.
Als dat overeenkomt met wat je bouwt, behandelt de rest van deze pagina de details waar ontwikkelaars naar vragen: het eerste verzoek, streaming, gestructureerde output, tools, limieten en kosten.
Je eerste verzoek
Maak een account aan via de API-sleutelpagina, kopieer de sleutel en stuur een verzoek. Aanmelden werkt met Google of met e-mail en wachtwoord. Nieuwe gebruikers kunnen $0,50 aan proeftegoed claimen met één klik op die pagina, één per persoon, geldig voor zeven dagen. De proefsleutel werkt onder lagere limieten dan een volledige sleutel: 2 gelijktijdige verzoeken en 60 verzoeken per minuut.
Begin met curl, omdat dit elke andere variabele verwijdert:
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."}
]
}'
Dezelfde aanroep met de officiële Python SDK:
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)
Een aanroep naar GET /v1/models is een goedkope manier om te controleren of je sleutel en base URL correct zijn voordat je iets anders debugt. Elk antwoord bevat de headers X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests en X-RateLimit-Limit-Concurrency. Log de request ID met je eigen logs en houd de balansheader in de gaten als je onbemande taken uitvoert.
Sampling parameters zoals temperature, top_p, stop, seed en de frequentie- en aanwezigheidsstraffen worden doorgegeven aan het model. De volledige parameteropmerkingen staan op de documentatiepagina.
Streaming
Stel stream: true in en het antwoord komt aan als server-sent events, één chunk per token-groep, met verbruik gerapporteerd aan het einde van de stream. Voor een chat-interface is dit het verschil tussen een scherm dat wacht en een scherm dat typt.
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 is het patroon hetzelfde:
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 ?? "");
}
Eén detail is belangrijk voor capaciteitsplanning. Een gestreamd verzoek houdt zijn concurrency-slot vast tot de stream eindigt. Als een client een stream opent en dan stagneert, blijft dat slot bezet, dus sluit streams die je niet langer leest.
JSON-modus en tool calling
Voor gestructureerde output geef je response_format met het type json_object. Zeg ook in de prompt dat je JSON wilt, en noem de sleutels die je verwacht. JSON-modus helpt het model om parseerbare tekst te produceren, maar je moet het resultaat nog steeds valideren in je code en een mislukte parse afhandelen.
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)
Tool calling
Tool calling volgt de OpenAI-vorm. Je stuurt tools en optioneel tool_choice. Het model antwoordt met tool_calls, je voert de functie uit en je stuurt het resultaat terug als een bericht met role: "tool". Tool calls kunnen ook streamen.
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)
Parseer de argumentenstring altijd defensief. Modellen retourneren soms argumenten die geen geldige JSON zijn, en een try/except rondom json.loads met één retry is goedkope verzekering.
Rate limits, 429's en retries
Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe. Een proefsleutel staat 2 en 60 toe. De maximale request body is 8 MB. Als je een limiet overschrijdt, krijg je HTTP 429, en de foutcode vertelt je welke limiet: rate_limited betekent te veel verzoeken per minuut, concurrency betekent te veel in één keer. Bij tijdelijke overbelasting retourneert de API ook 429 met een Retry-After: 5-header.
Dat geeft je een eenvoudige retry-regel: bij 429 wacht je op Retry-After als deze aanwezig is, gebruik anders exponentiële back-off met jitter, en beperk het aantal pogingen.
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")
Als je batch-taken uitvoert, beperk dan je worker pool tot 8 op een volledige sleutel. Acht workers die elk één verzoek vasthouden is het plafond, en een negende zal je alleen maar 429's opleveren met de code concurrency. Mislukte of geweigerde verzoeken worden niet in rekening gebracht, dus retryen kost je geen geld.
Gewoontes die tijd besparen in productie
Een paar praktijken betalen zich snel uit zodra het eerste verzoek werkt. Sla de sleutel op in een omgevingsvariabele of een secrets manager, en geef elke omgeving zijn eigen sleutel zodat je er één kunt roteren zonder de anderen aan te raken. Log de X-Request-Id-waarde naast je eigen trace ID; als er iets mis lijkt te zijn in een antwoord, is die ID wat je moet vermelden.
Stel een timeout in op de client. Lange generaties zijn normaal als je een grote completion toestaat, dus kies een timeout die past bij je langst verwachte antwoord, en gebruik streaming voor alles waar iemand op wacht. Beperk max_tokens in gebruikersgerichte paden, hoewel de parameter optioneel is, omdat een limiet een plafond zet op zowel latentie als kosten.
Houd de gespreksgeschiedenis die je stuurt onder controle. Het venster is 100.000 tokens, maar input wordt bij elke aanroep gefactureerd, dus het inkorten van oude beurten of het samenvatten ervan is de goedkoopste optimalisatie die je hebt. Zet je samplinginstellingen vast ten slotte. Het instellen van seed samen met een vaste temperature geeft je meer herhaalbare runs als je promptvarianten vergelijkt, hoewel je het niet moet behandelen als een garantie voor identieke output.
Wat het kost
Prijzen zijn $0,15 per 1M input-tokens en $0,50 per 1M output-tokens, van prepaid credit. Er is geen abonnement en het tegoed vervalt nooit. Een uitgewerkt voorbeeld maakt het concreet. Neem een verzoek met 2.000 input-tokens en 500 output-tokens:
- Input: 2.000 / 1.000.000 x $0,15 = $0,0003
- Output: 500 / 1.000.000 x $0,50 = $0,00025
- Totaal: $0,00055 per verzoek, dus 1.000 zulke verzoeken kosten $0,55.
Het $0,50 proeftegoed dekt dus ongeveer 900 verzoeken van die grootte. Opwaarderingen lopen van $20 tot $500 in elk geheel bedrag, met een bonus van 5% vanaf $50, 10% vanaf $100 en 15% vanaf $200. Een top-up van $100 crediteert bijvoorbeeld $110. Betaling is alleen crypto op deze site: USDT op TRC20 of USDC op Base. De prijzenpagina heeft de huidige tabel.
Prompts worden niet gebruikt voor training. Als je dit afweegt tegen een ander endpoint, behandelt het bestaande artikel over betalen per token en het contextvenster van 100k hoe de metering zich gedraagt in lange gesprekken.
Wanneer een andere optie beter past
Wees eerlijk over de fit. Als je beeldgeneratie, embeddings, spraak of een gefinetuned model nodig hebt, biedt deze API dat niet. Als je contract- of compliance-team een first-party leverancier vereist, gebruik dan die leverancier. Als je gegarandeerde modelidentiteit van een specifiek lab nodig hebt, is dit het verkeerde product, omdat het één open-weight model van een onafhankelijke provider draait.
Waar het wel past, is een applicatie die al het OpenAI-protocol spreekt en een tekstmodel nodig heeft dat legale verzoeken van volwassenen beantwoordt zonder ze te weigeren: schrijftools, roleplay- en companion-apps voor volwassenen, datalabeling die moeilijke onderwerpen raakt, en testharnassen. Wijs je bestaande client naar de nieuwe base URL en vergelijk output op je eigen prompts voordat je credit vastlegt.
