Creating an API Key Here Instead of a Grok Key

First, what this key is and is not

A key from this site opens exactly one thing: the API at https://api.grokkey.com/v1. It does not work on xAI's endpoints, and a key from any other vendor does not work here. The service is not the official API of xAI, OpenAI, Meta, Mistral, Qwen, DeepSeek, Google or Anthropic, and it is not a router that forwards your request to those companies.

What you get is an OpenAI-compatible text API with a single model ID, uncensored, tuned to answer without content refusals for lawful adult use. If you need a key for Grok itself, use xAI's own console and documentation. If you want a hosted model for fiction, roleplay, companion apps or frank text work with no refusal layer, keep reading.

Steps: from sign-up to a working key

1. Open the key page. Go to the API key page and sign up with Google, or with an email and password.
2. Claim the trial. After sign-up, a single click on that page gives you $0.50 of trial credit. It is one per person, valid for 7 days, and needs no card.
3. Copy the key. It is shown on the same page. Treat it like a password.
4. Store it outside your code. Put it in an environment variable, for example export API_KEY="paste-your-key-here".
5. Make a test call. Use one of the snippets below. A reply means the key works.

The whole path takes a few minutes, and none of it involves a project, a billing profile or a console setup. Once the trial credit is gone you top up with prepaid credit (see the section on billing below).

Test the key with curl

Copycurl https://api.grokkey.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "Say hello in five words."}]
  }'

If the key is valid you get a JSON completion back. Look at the response headers too: X-Balance-USD shows your remaining credit, and X-Request-Id is useful when you contact support about a specific request. You can also check the balance directly with GET /v1/balance.

Copycurl https://api.grokkey.com/v1/balance \
  -H "Authorization: Bearer $API_KEY"

Call it from Python or Node

Any OpenAI SDK works once you change the base URL and key. In Python:

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.grokkey.com/v1",
    api_key=os.environ["API_KEY"],
)

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Give me three names for a fantasy tavern."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

And in Node with the official openai package:

Copyimport OpenAI from "openai";

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

const res = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Give me three names for a fantasy tavern." }],
});
console.log(res.choices[0].message.content);

Streaming uses server-sent events and reports usage at the end. Tool calling, JSON mode and the usual sampling parameters also work. Details are on the documentation page.

In a chat front-end

If you do not plan to write code, many chat and roleplay front-ends accept an OpenAI-compatible provider. SillyTavern, for example, lets you add an OpenAI-compatible endpoint. The setup is the same three fields in any such app: the base URL https://api.grokkey.com/v1, your key, and the model name uncensored. Some apps ask you to pick a model from a list; if the list is empty, type the name in by hand, or fetch it with GET /v1/models.

Once the connection test passes, the app sends the same requests as the snippets above. Streaming is supported, so replies appear word by word. If the app has a field for context size, 100,000 tokens is the window, shared between prompt and reply.

How this key differs from a vendor console key

Vendor consoles vary, so check each one's documentation for the current details. A few differences are specific to this service and we can state them with confidence.

• Self-service reissue. On the API key page you can regenerate your key whenever you like. The old key stops working immediately. You do not need to contact anyone to replace a key that leaked.
• Several keys after a top-up. Accounts that have topped up can hold up to 5 keys, give each a label (one per app or per environment, for example) and revoke any of them.
• One model, one name. There is no model catalogue to choose from. Every call uses uncensored, and GET /v1/models lists it.
• Prepaid, not postpaid. Credit is loaded first and drawn down per token. Failed or refused requests are not charged, and credit never expires.

The trial key is limited to 2 concurrent requests and 60 requests per minute. A full key (after a top-up) allows 8 concurrent requests and 300 requests per minute. If you exceed a limit, the API returns HTTP 429 with the error code rate_limited or concurrency, so a simple retry with a short pause is the right response.

Billing after the trial

Pricing is $0.15 per 1M input tokens and $0.50 per 1M output tokens. The $0.50 trial credit therefore buys about 3.33 million input tokens or 1 million output tokens, or a mixture of the two. A request with 2,000 input tokens and 500 output tokens costs $0.00055, so the trial covers about 909 of them, enough to build and test a small tool.

When you are ready to continue, top up any whole amount from $20 to $500, with a bonus of +5% from $50, +10% from $100 and +15% from $200. Payment is in crypto only, USDT on TRC20 or USDC on Base. The pricing page has the details. If you are weighing this against a Claude key, the article on Claude API key versus GrokKey covers that comparison.

Keeping your key safe

An API key is a bearer credential: whoever holds it can spend your balance. A few habits keep it out of trouble.

• Keep it out of source control. Load it from an environment variable or a secrets manager, and add any local .env file to .gitignore.
• Never ship it to a browser. If a web page calls the API directly, anyone can read the key from the page. Put a small server of your own between the page and the API, and keep the key there.
• Use one key per app. After a top-up you can create up to 5 keys and give each a label, such as the name of the app or the environment. When one is misused, you revoke it without disturbing the rest.
• Watch the balance header. A sudden drop in X-Balance-USD that you cannot explain is the earliest sign of a leaked key. Regenerate at once on the key page, and the old key stops working immediately.
• Redact logs. If you log request headers, mask the Authorization line.

Prompts sent through the API are not used for training, but that does not make a leaked key harmless. Treat the key as you would a database password.

Common problems

401 or invalid key

Check that the header reads Authorization: Bearer followed by the key, with no extra quotes or spaces, and that you are sending it to api.grokkey.com and not another vendor's host. If you regenerated the key, the old value no longer works.

Model not found

The only model ID is uncensored. Names from other vendors are not valid here.

429 errors during testing

On the trial key, 2 concurrent requests is the limit. A streamed request holds its slot until the stream ends, so two open streams plus a third call will be rejected. Wait for one to finish, then retry.

Slow or cut-off replies

Long generations take time. Use stream: true so text appears as it is produced, and set a client timeout that suits the length you ask for. The completion may use the rest of the 100,000-token window, and max_tokens is optional, so set it when you want to cap the length yourself.

More guides

• API Key Pricing: Free Tiers vs Pay per Token
• Claude API Key vs. GrokKey: The Uncensored Alternative