DE ▾
API-Schlüssel erhalten

uncensoredgrok.comLeitfaden

Grok-API für Entwickler: Eine OpenAI-kompatible Option

Wenn du nach einer grok api für Entwickler gesucht hast, hier ist, was diese Seite bietet und was nicht. Es ist eine unabhängige, OpenAI-kompatible Text-API, nicht der Dienst von xAI, und sie funktioniert mit jedem OpenAI SDK.

Aktualisiert

Isometrische Illustration eines Terminals, das Datenblöcke in einen Serverwürfel streamt, repräsentiert eine LLM-API für Entwickler
uncensoredgrok.com2026-10-06

Was du bekommst, und was nicht

Lass uns zunächst präzise sein, denn der Name der Seite kann irreführend sein. Dies ist nicht die offizielle API von xAI oder Grok. Es ist eine gehostete API vor einem Open-Weight-Modell, betrieben von einem unabhängigen Anbieter und darauf abgestimmt, ohne Inhaltsablehnungen für die legale Erwachsenen-Nutzung zu antworten. Es ist auch kein Router über mehrere Anbieter hinweg. Wenn du die eigenen Modelle von xAI benötigst, gehe zu xAI und prüfe deren aktuelle Bedingungen und Preise.

Nützlich ist es für einen einfachen Entwickler-Workflow. Die API spricht das OpenAI-Format für Chat-Vervollständigungen, sodass die Client-Bibliotheken, die du bereits nutzt, weiterhin funktionieren. Du änderst zwei Werte, die Base URL und den Schlüssel, und übergibst uncensored als Modell-ID. Es gibt zwei Endpunkte: POST /v1/chat/completions und GET /v1/models. Die Authentifizierung erfolgt über einen standardmäßigen Authorization: Bearer-Header.

Der Dienst unterstützt nur Text. Es gibt keine Bild-, Audio- oder Videoerzeugung, keine Embeddings und kein Fine-Tuning. Das Kontextfenster umfasst 100.000 Token, gezählt über Prompt und Vervollständigung zusammen, und max_tokens ist optional. Es gibt eine harte Inhaltsgrenze: nichts, das sexuelle Inhalte mit Minderjährigen beinhaltet, niemals.

Wenn das zu dem passt, was du baust, behandelt der Rest dieser Seite die Details, die Entwickler fragen: die erste Anfrage, Streaming, strukturierte Ausgabe, Tools, Limits und Kosten.

Deine erste Anfrage

Erstelle ein Konto über die API-Schlüssel-Seite, kopiere den Schlüssel und sende eine Anfrage. Die Anmeldung funktioniert mit Google oder mit E-Mail und Passwort. Neue Nutzer können $0,50 an Testguthaben mit einem Klick auf dieser Seite beanspruchen, eine pro Person, gültig für sieben Tage. Der Testschlüssel läuft unter niedrigeren Limits als ein voller Schlüssel: 2 parallele Anfragen und 60 Anfragen pro Minute.

Starte mit curl, da es jede andere Variable entfernt:

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."}
    ]
  }'

Der gleiche Aufruf mit dem offiziellen 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)

Ein Aufruf an GET /v1/models ist eine günstige Möglichkeit zu prüfen, ob dein Schlüssel und deine Base URL korrekt sind, bevor du etwas anderes debuggst. Jede Antwort enthält die Header X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests und X-RateLimit-Limit-Concurrency. Logge die Request-ID mit deinen eigenen Logs und beobachte den Balance-Header, wenn du unüberwachte Jobs ausführst.

Sampling-Parameter wie temperature, top_p, stop, seed und die Häufigkeits- und Präsenzstrafen werden an das Modell weitergegeben. Die vollständigen Parameterhinweise findest du auf der Dokumentationsseite.

Streaming

Setze stream: true und die Antwort kommt als Server-Sent Events an, ein Chunk pro Token-Gruppe, mit der Nutzungsmeldung am Ende des Streams. Für eine Chat-Schnittstelle ist dies der Unterschied zwischen einem Bildschirm, der wartet, und einem Bildschirm, der tippt.

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 ist das Muster dasselbe:

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 ?? "");
}

Ein Detail ist wichtig für die Kapazitätsplanung. Eine gestreamte Anfrage behält ihren Parallelitätsplatz bis zum Ende des Streams. Wenn ein Client einen Stream öffnet und dann einfriert, bleibt dieser Platz belegt, also schließe Streams, die du nicht mehr liest.

JSON-Modus und Tool-Aufrufe

Für strukturierte Ausgabe übergibst du response_format mit dem Typ json_object. Sage im Prompt auch, dass du JSON möchtest, und benenne die Schlüssel, die du erwartest. Der JSON-Modus hilft dem Modell, parsebaren Text zu erzeugen, aber du solltest das Ergebnis trotzdem in deinem Code validieren und einen fehlgeschlagenen Parse behandeln.

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)

Function Calling

Function Calling folgt der OpenAI-Struktur. Du sendest tools und optional tool_choice. Das Modell antwortet mit tool_calls, du führst die Funktion aus und sendest das Ergebnis als Nachricht mit role: "tool" zurück. Tool-Aufrufe können auch gestreamt werden.

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)

Parse die Argumentzeichenkette immer defensiv. Modelle geben manchmal Argumente zurück, die kein gültiges JSON sind, und ein try/except um json.loads mit einem Retry ist eine günstige Versicherung.

Ratenlimits, 429er und Wiederholungen

Ein voller Schlüssel erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute. Ein Testschlüssel erlaubt 2 und 60. Der maximale Request-Body ist 8 MB groß. Wenn du ein Limit überschreitest, erhältst du HTTP 429, und der Fehlercode sagt dir, welches Limit: rate_limited bedeutet zu viele Anfragen pro Minute, concurrency bedeutet zu viele gleichzeitig. Bei temporärer Überlastung gibt die API auch 429 mit einem Retry-After: 5-Header zurück.

Das gibt dir eine einfache Retry-Regel: bei 429 warte auf Retry-After, wenn es vorhanden ist, andernfalls nutze exponentielles Backoff mit Jitter und begrenze die Versuche.

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")

Wenn du Batch-Jobs ausführst, begrenze deinen Worker-Pool auf 8 bei einem vollen Schlüssel. Acht Worker, die jeweils eine Anfrage halten, sind die Obergrenze, und ein neunter bringt dir nur 429er mit dem Code concurrency. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, also kostet dich ein Retry kein Geld.

Gewohnheiten, die Zeit in der Produktion sparen

Einige Praktiken zahlen sich schnell aus, sobald die erste Anfrage funktioniert. Speichere den Schlüssel in einer Umgebungsvariable oder einem Secrets-Manager und gib jeder Umgebung ihren eigenen Schlüssel, damit du einen rotieren kannst, ohne die anderen zu berühren. Logge den X-Request-Id-Wert neben deiner eigenen Trace-ID; wenn in einer Antwort etwas falsch aussieht, solltest du diese ID angeben.

Setze einen Timeout auf den Client. Lange Generierungen sind normal, wenn du eine große Vervollständigung erlaubst, also wähle einen Timeout, der zu deiner längsten erwarteten Antwort passt, und nutze Streaming für alles, worauf eine Person wartet. Begrenze max_tokens in benutzergesichteten Pfaden, obwohl der Parameter optional ist, da eine Begrenzung eine Obergrenze für Latenz und Ausgaben setzt.

Halte den gesendeten Gesprächsverlauf unter Kontrolle. Das Fenster umfasst 100.000 Token, aber Input wird bei jeder Anfrage berechnet, also ist das Kürzen alter Gesprächsrunden oder das Zusammenfassen die günstigste Optimierung, die du hast. Fixiere schließlich deine Sampling-Einstellungen. Das Setzen von seed zusammen mit einer festen Temperatur gibt dir reproduzierbarere Läufe, wenn du Prompt-Varianten vergleichst, obwohl du es nicht als Garantie für identische Ausgaben behandeln solltest.

Was es kostet

Die Preise betragen $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token, aus Prepaid-Guthaben. Es gibt kein Abonnement und das Guthaben verfällt nie. Ein durchgerechnetes Beispiel macht es konkret. Nimm eine Anfrage mit 2.000 Input-Token und 500 Output-Token:

  • Input: 2.000 / 1.000.000 × $0,15 = $0,0003
  • Output: 500 / 1.000.000 × $0,50 = $0,00025
  • Gesamt: $0,00055 pro Anfrage, also kosten 1.000 solcher Anfragen $0,55.

Das $0,50 Testguthaben deckt daher etwa 900 Anfragen dieser Größe ab. Aufladungen laufen von $20 bis $500 in beliebigen ganzen Beträgen, mit einem Bonus von 5 % ab $50, 10 % ab $100 und 15 % ab $200. Eine Aufladung von $100 schreibt zum Beispiel $110 gut. Die Zahlung erfolgt auf dieser Seite nur mit Krypto: USDT auf TRC20 oder USDC auf Base. Die Preisseite hat die aktuelle Tabelle.

Prompts werden nicht zum Training verwendet. Wenn du dies gegen einen anderen Endpunkt abwägst, behandelt der bestehende Artikel über Bezahlung pro Token und das 100k-Kontextfenster, wie das Abrechnungssystem in langen Gesprächen funktioniert.

Wenn eine andere Option besser passt

Sei ehrlich bezüglich der Passform. Wenn du Bildgenerierung, Embeddings, Sprache oder ein feinabgestimmtes Modell benötigst, bietet diese API sie nicht. Wenn dein Vertrags- oder Compliance-Team einen Erstanbieter-Vendor erfordert, nutze diesen Vendor. Wenn du eine garantierte Modellidentität von einem bestimmten Labor benötigst, ist dies das falsche Produkt, da es ein einzelnes Open-Weight-Modell von einem unabhängigen Anbieter ausführt.

Wo es passt, ist eine Anwendung, die bereits das OpenAI-Protokoll spricht und ein Textmodell benötigt, das legale Erwachsenenanfragen beantwortet, ohne sie abzulehnen: Schreibwerkzeuge, Roleplay- und Companion-Apps für Erwachsene, Datenbeschriftung, die schwierige Themen berührt, und Test-Harnesses. Richte deinen bestehenden Client auf die neue Base URL und vergleiche Ausgaben auf deinen eigenen Prompts, bevor du Guthaben festlegst.

Fragen und Antworten

uncensoredgrok.comFragen und Antworten
Ist dies die offizielle Grok-API?

Nein. Es ist eine unabhängige, OpenAI-kompatible API vor einem Open-Weight-Modell. Sie wird nicht von xAI betrieben und ist kein Router über mehrere Anbieter hinweg.

Welche Modell-ID verwende ich?

Verwende uncensored als Modellwert in jeder Anfrage. Eine GET-Anfrage an /v1/models listet auf, was der Schlüssel sehen kann.

Unterstützt es Streaming und Function Calling?

Ja. Streaming läuft über SSE mit stream: true, und Function Calling unterstützt tools, tool_choice und gestreamte tool_calls, wobei Ergebnisse als role tool Nachrichten zurückgesendet werden.

Wie zahle ich?

Auf dieser Seite lädst du nur mit Krypto auf, USDT auf TRC20 oder USDC auf Base, in beliebigen ganzen Beträgen von $20 bis $500.

Was sind die Ratenlimits?

Ein voller Schlüssel erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute. Ein Testschlüssel erlaubt 2 und 60. Über dem Limit erhältst du HTTP 429.

uncensoredgrok.com2026-10-06

Dein Schlüssel ist nur ein Formular entfernt

Erstelle ein Konto, kopiere den Schlüssel, ändere die Base URL. Das ist die gesamte Einrichtung.

API-Schlüssel erhalten