Quickstart for Unhinged Grok users

Authentication and Base URL

Our API is OpenAI compatible, meaning you do not need a new library. You only need to update two values in your existing configuration: the base_url and the api_key. Your API key is generated immediately upon signup via Google or email. Keep this key secure; it is the only credential required for authentication.

Replace the standard OpenAI base URL with our endpoint. This change directs all subsequent requests to our uncensored model servers. No other code changes are required for basic text generation.

Configuration Example

• Base URL: https://api.unhingedgrok.com/v1
• API Key: Your unique key from the dashboard

Verify your connection by listing available models. This confirms your authentication is working correctly before sending generation requests.

First Request

Start by sending a simple text completion request. This example uses curl to demonstrate the raw HTTP structure. The request targets the /v1/chat/completions endpoint with the model ID uncensored. The response returns generated text in the choices array.

This direct approach works for any language or tool that supports standard OpenAI HTTP formats. You can test this immediately after generating your key.

Direct HTTP Request

Copycurl https://api.unhingedgrok.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "Write a blunt product review of a cheap VPN."}]
  }'

Python SDK Integration

Use the official OpenAI Python library to integrate our API. Install the package via pip. Initialize the client with your key and the custom base URL. The rest of the SDK methods, such as chat.completions.create, work exactly as documented for OpenAI.

This method is ideal for backend services, data processing scripts, or automated workflows. The SDK handles JSON serialization and response parsing automatically.

Python Code Example

Copyfrom openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Summarise this thread without softening it."}],
)
print(resp.choices[0].message.content)

Node.js SDK Integration

For JavaScript or TypeScript environments, use the official openai npm package. Configure the client with the same base URL and key. The Node SDK supports both callback and promise-based patterns.

This setup allows you to embed uncensored text generation directly into web applications, serverless functions, or Node-based automation tools. Error handling remains consistent with standard OpenAI SDK behavior.

Node.js Code Example

Copyimport OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Draft a villain monologue for my game." }],
});
console.log(resp.choices[0].message.content);

Streaming Responses

Enable real-time token generation by setting stream: true. The API returns a Server-Sent Events (SSE) stream. Each chunk contains a partial response. The final chunk includes token usage statistics.

Streaming reduces perceived latency for end-users. It is essential for chat interfaces and interactive applications. Handle each chunk incrementally to update the UI immediately.

Streaming Code Example

Copystream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Tell the story in second person."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Limits, Errors, and Context

Understand the operational constraints to avoid service interruptions. The context window supports 100,000 tokens total, and if max_tokens is unset, the response can run to the end of the window.

Rate limits allow 300 requests per minute per key. Concurrent requests are capped at 8. Request bodies must not exceed 8 MB. Handle standard HTTP error codes: 401 indicates an invalid key, 402 signals insufficient credit, and 429 denotes rate limiting. Errors do not consume credit.