Grok 4.6 via API: benchmarks, pricing and the 200K token cliff

xAI shipped Grok 4.6 on August 12. In production a model update is not news, it is a ticket: change one line in the config and figure out what moves after that. Below — a minimal request that runs as is, benchmark numbers without rounding in anyone's favour, and three places where Grok 4.6 costs more than the price list suggests.

The minimal request

The GPTunneL API is OpenAI-compatible, so migrating to Grok 4.6 means a base_url and a model name:

curl https://gptunnel.ru/v1/chat/completions \
  -H "Authorization: <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.6",
    "messages": [
      {"role": "user", "content": "Analyse this stack trace and suggest a patch"}
    ]
  }'

The same thing with the official OpenAI client:

from openai import OpenAI

client = OpenAI(
    api_key="<YOUR_API_KEY>",
    base_url="https://gptunnel.ru/v1",
)

resp = client.chat.completions.create(
    model="grok-4.6",
    messages=[{"role": "user", "content": "Analyse this stack trace and suggest a patch"}],
)
print(resp.choices[0].message.content)

One detail that costs people half an hour: the model identifier is spelled differently everywhere. In the GPTunneL catalogue it is grok-4.6, in the direct xAI API it is grok-4-6, on OpenRouter it is x-ai/grok-4-6. If your code talks to two providers at once, keep the mapping in config, not in string literals scattered across the codebase.

What changed since Grok 4.5

Grok 4.6 is not a new base model. xAI says plainly that this is post-training on the same 1.5T-parameter base as Grok 4.5: a supplemental training run, regenerated SFT trajectories and agentic RL across coding, web development, CAD and kernel optimisation. The model did not get bigger.

Technical boundaries:

• context — 500,000 tokens;
• knowledge cutoff — February 1, 2026; anything newer only through web search and tools;
• stated focus — long-running agents, work across a large codebase, interactive and visual tasks.

The behavioural change you actually notice is self-verification. The model runs the code before moving on with the plan and re-reads a file after editing it instead of trusting its own diff. For an agent that means a higher share of tasks carried to completion — and a hit to the budget: the same task takes more steps, and you pay for tokens, not for results.

Benchmarks

Numbers from the xAI and Artificial Analysis tables, with the best competitor result on the same test alongside:

Here is how to read it. On the composite index Grok 4.6 pulled level with GPT-5.6 Sol in its maximum reasoning mode and sits one point behind Fable 5 Max — meaning the gap in raw intelligence between the frontier models is now within noise. Where you have to chew through a pile of documents and structure the result, 4.6 leads: it beats both competitors on AA-Briefcase and on the legal Harvey LAB eval. Where you have to live in a terminal, it clearly loses: 26% against 34–35%.

The line the whole release was built for is CursorBench 3.2: 70.8% at $2.81 per task against 70.5% for Fable 5 at $17.32 and 70% for Opus 5 at $8.23. Same quality, a 3–6x difference on the bill.

The 200K token cliff that doubles your bill

The real trap of this release is not in quality, it is in the rate card. xAI splits Grok 4.6 pricing into two bands:

The catch is that the doubled rate applies to every token in the request, not to the overage. A 201,000-token request pays double for all 201,000, not for the extra thousand. A 199K prompt and a 201K prompt differ by 1% in content and by exactly 2x in cost.

Hence a simple rule: count the prompt before sending it and make the call deliberately.

LONG_CTX_BAND = 200_000

def will_double(prompt_tokens: int) -> bool:
    return prompt_tokens >= LONG_CTX_BAND

# inside the agent: either compact the history, or accept 2x knowingly
if will_double(estimated):
    history = compact(history, target=180_000)

The second thing is cached input. It is the only column where 4.6 is more expensive than 4.5: $0.50 against $0.30 per million. If you keep a large system prompt on cache and hit it thousands of times a day, bumping the version alone raises the bill even if nothing else changes.

In the GPTunneL catalogue grok-4.6 has a single rate per 1K tokens, with no bands — current numbers are on the model card next to this text and on the pricing page.

Streaming

Long agentic answers without streaming look like a hung request, and the first thing to notice is not the user but the proxy timeout. A minimal Node stream:

const res = await fetch("https://gptunnel.ru/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: process.env.GPTUNNEL_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "grok-4.6",
    stream: true,
    messages: [{ role: "user", content: "Draft a refactoring plan for the auth module" }],
  }),
});

for await (const chunk of res.body) {
  for (const line of chunk.toString().split("\n")) {
    if (!line.startsWith("data: ")) continue;
    const payload = line.slice(6);
    if (payload === "[DONE]") break;
    process.stdout.write(JSON.parse(payload).choices[0]?.delta?.content ?? "");
  }
}

What breaks in production

• Timeouts. Agentic runs on 4.6 take longer than on 4.5 — self-verification costs time. The default 60 seconds in an HTTP client cuts the answer in half; set 600 and turn streaming on so the connection is never silent.
• Retries. Exponential backoff with jitter on 429 and 5xx, no retries on 4xx. A 400 complaining about an unknown model is not a network blip, it is grok-4.6 versus grok-4-6, and retrying it is pointless.
• The budget is per task, not per token. A model that double-checks itself burns more tokens and finishes more tasks. Measure the cost of a completed run, the number of human interventions and the time to a shippable result — pick by price per million and you will pick the wrong model.
• 500K is less than the neighbours have. GPT-5.6 Sol offers 1.05M, Fable 5 offers 1M. A RAG pipeline designed around a million tokens of context has to be trimmed for Grok 4.6, and preferably trimmed below 200K (see above).
• Fresh data. The cutoff is February 2026. Anything later the model only knows from web search and the tools you hand it.

Grok 4.6 in Cursor and elsewhere

The model is live in Cursor and Grok Build, and available through the xAI API, OpenRouter, Vercel and Cloudflare. For the first week after launch, until August 19, xAI doubles the included Grok 4.6 usage in Grok Build and Cursor — if you want to compare it against Composer or Fable on your own repository, that is the cheapest window you will get.

A sane way to wire it into Cursor is not to make 4.6 the default, but to hand it the long jobs: reading a large repository, migrations, carrying a feature from issue to PR. Short edits are cheaper on fast models, and the router handles that split for you.

Try it yourself

Grok 4.6 is already in the GPTunneL catalogue: it works both in the chat and through the same OpenAI-compatible API as every other model — one key, one balance, no subscriptions, pay per use. Grab a key in your account, switch model to grok-4.6 and run it on a real scenario of yours: issue → plan → patch → tests. Endpoints, limits and parameters are in the documentation; the rest of the family lives on the Grok page.