How to Get a Grok (xAI) API Key & a Cheaper Way to Use It

Getting a Grok API key takes about two minutes: create one on the xAI console, point the standard OpenAI SDK at https://api.x.ai/v1, and you are calling Grok with your existing code. This guide walks the exact steps, lists the current Grok model ids and their published pricing (verified against xAI's July 2026 docs), and shows the OpenAI-compatible request in Python and JavaScript. Then it covers the honest trade-off: one xAI key locks you to one vendor, so we also show the gateway alternative — a single key that reaches Grok and 300+ other models with automatic failover, no per-provider signup.

Get a Grok API key in 4 steps

Create the key on the xAI console, then point the standard OpenAI SDK at https://api.x.ai/v1 — that is the whole flow. The short version:

1. Sign in to the xAI console API Keys page.
2. Create a new key, name it, and copy the value (shown once).
3. Export it as XAI_API_KEY in your environment.
4. Use the OpenAI client with base_url="https://api.x.ai/v1" and that key.

Every number and endpoint below is verified against xAI's official docs (July 2026); the rest of this guide expands each step, lists the current model ids and pricing, and covers the one thing xAI won't tell you — how to avoid locking your app to a single provider.

What a Grok API key actually is

It is a secret bearer token that authenticates your requests to xAI's Grok models over HTTPS. Grok is the family of large language models built by xAI; the API lets your own code send prompts to models like grok-4.3 and get completions back, the same way you'd call OpenAI or Claude. The key travels in the Authorization: Bearer <key> header on every request to the base URL https://api.x.ai/v1. Treat it like a password: anyone with the key can spend on your account, so keep it out of client-side code and source control. If you want the fastest possible path to trying Grok without any of the vendor-specific setup, skip to the gateway option, which uses one key for Grok and hundreds of other models.

Create the key on the xAI console

Keys are created on the xAI console's API Keys page — not in the Grok chat app. The exact steps, matching xAI's quickstart:

Set it in your shell so it never touches your code:

export XAI_API_KEY="xai-...your-key..."

Call Grok with the OpenAI SDK

The xAI API is OpenAI-SDK-compatible: change two lines — base_url and the key — and existing OpenAI code calls Grok. xAI documents this directly, with both Python and JavaScript OpenAI-SDK examples pointing baseURL at https://api.x.ai/v1. Python:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["XAI_API_KEY"],
    base_url="https://api.x.ai/v1",
)

resp = client.chat.completions.create(
    model="grok-4.3",
    messages=[{"role": "user", "content": "Explain the token bucket algorithm in one line."}],
)
print(resp.choices[0].message.content)

JavaScript is the same shape — only baseURL and the key change:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.XAI_API_KEY,
  baseURL: "https://api.x.ai/v1",
});

const resp = await client.chat.completions.create({
  model: "grok-4.3",
  messages: [{ role: "user", content: "Hello, Grok" }],
});
console.log(resp.choices[0].message.content);

Because the surface is OpenAI-compatible, anything already written against the OpenAI client — retries, streaming, tool calls — carries over. If you're curious about what "OpenAI-compatible" guarantees and where the edges are, our OpenAI-compatible API guide maps exactly which fields port cleanly.

Grok models, context & pricing

As of xAI's July 2026 docs, the Chat API exposes grok-4.3 and the grok-4.20 family at $1.25 / $2.50 per 1M tokens; the coding model is cheaper. The full verified table:

A few things to note: the four Chat models share one price, so model choice within the family is about behaviour (reasoning vs non-reasoning vs multi-agent), not cost. The 1M-token context window is generous — long documents and large codebases fit without chunking. And grok-build-0.1 is a separate coding-focused model on a distinct Code API, priced below the chat family. All figures are from xAI's official models page; see our fuller Grok 4 model page for the gateway view. If you're weighing Grok against the similarly-named Groq inference platform, that is a different company entirely — our Grok vs Groq piece untangles the two.

A worked cost example

At $1.25 in / $2.50 out, a typical RAG-style call costs a fraction of a cent — here is the arithmetic on grok-4.3. Say each request sends 8,000 input tokens (a system prompt plus retrieved context) and generates 800 output tokens:

So one request is about 1.2 cents, and 100k of them is roughly $1,200. Output tokens cost 2× input, so verbose responses dominate the bill faster than large contexts do — cap max_tokens and prompt for concision when you can. For a side-by-side of where Grok lands against other providers on price, see our cheapest LLM API comparison.

One key for Grok + 300 other models

A direct xAI key only reaches Grok — through an OpenAI-compatible gateway, one key reaches Grok and 300+ other models, with failover when xAI is rate-limited or down. The setup is identical to the direct call; you just swap the base URL and use your gateway key:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_DATALLMLAB_KEY",
    base_url="https://www.datallmlab.com/v1",   # one key, 300+ models
)

resp = client.chat.completions.create(
    model="x-ai/grok-4",                        # or any other model id
    messages=[{"role": "user", "content": "Hello"}],
)

Why route this way instead of holding a separate key per vendor:

• No per-provider signup. Grok, Claude, GPT and open models sit behind one account and one bill — no separate xAI, OpenAI and Anthropic keys to manage.
• Automatic failover. If xAI returns a rate limit or an outage, the request reroutes to an equivalent model so your users never see the error — the mechanics are in our routing & failover guide.
• Same OpenAI SDK. It's still the OpenAI-compatible surface, so you change one line versus your direct-Grok code. See what an LLM gateway is for the full picture.

You keep the exact ergonomics of the xAI call — you just stop tying your uptime to a single provider. When rate limits do bite, our rate-limit playbook covers the direct-provider fixes too.

When a single xAI key is the right call

If Grok is the only model you'll ever call and vendor uptime isn't business-critical, a direct xAI key is the simplest thing that works. A gateway earns its keep when you use more than one model, want failover, or need one bill and one dashboard across providers. If none of that applies — a hobby project, a single-model prototype, or a workload contractually pinned to xAI — the direct key skips a hop and keeps your dependency list short. The honest rule: direct key for single-model simplicity; gateway the moment you have two models or an uptime SLA. For choosing which model to standardise on in the first place, our best LLM API guide and best coding LLM roundup compare the current field.

FAQ