Grok 4.6: API pricing, benchmarks, context, and where it fits
Grok 4.6 is xAI's new flagship model for coding and knowledge work. Here is the practical API contract, cost structure, benchmark evidence, and evaluation plan.

Grok 4.6 is xAI's flagship model for coding, agentic tasks, and general knowledge work. The API model ID is grok-4.6. xAI documents a 500,000-token context window, text and image input, text output, configurable reasoning, function calling, structured outputs, and server-side search and code tools. Standard API pricing starts at $2 per million input tokens, $0.50 per million cached input tokens, and $6 per million output tokens; prompts at or above 200,000 tokens use higher long-context rates. The benchmark figures below are xAI-reported release results, not independent Kendr measurements.
What xAI released
xAI announced Grok 4.6 on 12 August 2026. The release positions it for long-running agents, codebase work, research, information analysis, and interactive or visual artifacts. xAI says the model received longer supplemental training, including curated reasoning, technical and engineering data, regenerated supervised fine-tuning trajectories, and agentic reinforcement learning across knowledge work, coding, kernel optimization, web development, and CAD. These are the provider's descriptions of its training and intended strengths, not a guarantee for every workload.[1]
For API users, the exact identifier is grok-4.6. It is available through the Responses API and Chat Completions API. xAI's model guide lists a 500,000-token context window and a knowledge cutoff of 1 February 2026. That combination makes large repositories and document collections plausible inputs, but context capacity alone does not establish retrieval accuracy or instruction retention at every position.[2][3]
The API contract in practical terms
The documented input modalities are text and images, while output is text. The model supports function calling, structured outputs, and reasoning. xAI's Grok 4.6 guide also lists web search, X search, and code execution as tools. Those server-side tools can add invocation charges on top of token usage, so an evaluation should record both token cost and tool-call cost.[2][3][4]
Reasoning effort can be set to low, medium, high, or xhigh, with high documented as the default for Grok 4.6. Lower effort is a candidate for latency-sensitive or simpler steps; higher effort is a candidate for difficult analysis. Treat that as a tuning control to test, not an automatic quality ladder: measure task success, latency, output tokens, and total cost at each setting.[2][6]
xAI documents no separate text-output limit for Grok 4.6. Production applications should still impose their own response-length, timeout, and spend limits. Long generated answers can increase latency and output-token cost even when the provider does not publish a smaller standalone output ceiling.[2]
- Use Responses when you need the newer response object and agent-oriented controls; retain Chat Completions when that contract matches an existing integration.
- Use structured outputs for machine-consumed results, then validate the returned schema in your application.
- Log the exact model ID, reasoning effort, tool configuration, latency, token counts, cached tokens, and final accepted result.
- Keep external actions behind permission checks and application-level validation even when function calling works correctly.
Grok 4.6 pricing has a long-context step-up
xAI lists the following US-dollar rates per one million tokens. Once a prompt reaches the 200,000-token threshold, the long-context rates apply to the request, including its cached and non-cached prompt tokens. This makes prompt size a pricing boundary, not only a capacity question.[3][4]
Priority Processing does not require a made-up fast-model name: the request still uses grok-4.6 and adds service_tier: priority. xAI prices successfully served priority requests at twice the applicable standard token rate and says the response reports which service tier was actually used. The premium applies to cached, input, output, and reasoning tokens; confirm the returned tier when reconciling cost.[4][5]
| Request condition | Input / 1M | Cached input / 1M | Output / 1M |
|---|---|---|---|
| Standard, prompt below 200K tokens | $2.00 | $0.50 | $6.00 |
| Standard, prompt at least 200K tokens | $4.00 | $1.00 | $12.00 |
| Priority processing, either context band | 2x applicable input rate | 2x applicable cached rate | 2x applicable output rate |
The complete Grok 4.6 High benchmark table
The table below reproduces every Grok 4.6 High score in xAI's launch post. These are xAI-reported release results; Kendr has not independently rerun them. xAI also cautions that third-party comparison scores in its announcement are the best of self-reported or public results and that benchmark configurations differ. For that reason, do not treat small cross-model gaps as controlled head-to-head evidence.[1]
| Benchmark | Grok 4.6 High |
|---|---|
| AA Intelligence Index | 61 |
| GDPVal-AA v2 | 1753 |
| CursorBench v3.2 | 69.9% |
| DeepSWE v1.1 | 65.9% |
| FrontierCode v1.1 (Extended) | 61.3% |
| APEX-Agents | 57.5% |
| Terminal-Bench v3.0 | 26% |
| APEX-SWE | 56.4% |
| AA-Briefcase | 1577 |
| Harvey LAB (Vals) | 15.8% |
How to read the release scores
A launch table is useful for deciding what to test next. It is not a universal ranking. The scores span different units: some are percentages, while AA Intelligence Index, GDPVal-AA v2, and AA-Briefcase use index-style values. Averaging them would erase what each benchmark measures. Even two percentage scores cannot be combined safely when their datasets, tools, time budgets, and graders differ.
The phrase Grok 4.6 High also matters. It identifies a reasoning configuration, so a production request using another effort level may occupy a different cost, latency, and quality point. Before making a routing or procurement decision, preserve the full evaluation configuration and compare candidates on identical application tasks.
- Verify the exact model ID and reasoning effort used for every run.
- Record tool access, prompt template, context size, sampling settings, retry policy, and judge.
- Repeat stochastic tasks and inspect the errors, not only the average score.
- Add production constraints such as p95 latency, accepted-answer cost, structured-output validity, and severe failure rate.
- Re-run the suite when the model, prompt, toolchain, or provider behavior changes.
Where Grok 4.6 is worth evaluating
The strongest first candidates follow the release's stated focus: repository-scale coding, multi-step technical investigation, research over large evidence packets, information analysis with tools, and generation of polished applications or artifacts. Image input also makes it relevant to workflows that begin with diagrams, screenshots, charts, or visual references and end in text or code.[1][2]
For a coding agent, test issue resolution across real repositories, tool-call correctness, regressions, and review effort. For research, test citation support, source coverage, contradiction handling, and whether the final answer separates evidence from inference. For long-context analysis, place decisive facts at different positions and measure retrieval as the prompt approaches and reaches the 200K pricing threshold.
The model is a weaker default choice when the task is short, high-volume, easily verified, and adequately served by a cheaper or faster system. It may also be the wrong deployment choice where text-only output, provider-hosted tools, or the available data boundary does not match the application's requirements. Model selection should follow the workload, not the release date.
A production-shaped evaluation plan
Build a holdout of representative tasks and define acceptance before looking at outputs. Run Grok 4.6 at low, medium, high, and—where the task justifies it—xhigh reasoning effort. Compare the same prompts with the alternatives already used by your application. For agentic tasks, evaluate the complete trajectory: tool selection, arguments, recovery from errors, final answer, and side effects.
Separate prompt bands below 200K and at or above 200K tokens because the price changes at that boundary. Measure uncached and repeated-prefix traffic separately, and confirm cached-token counts rather than assuming a cache hit. If latency matters, test standard and priority processing with the same model ID, log the returned service tier, and compare p50 and p95 latency against the two-times token premium.[4][5]
Promote the model only for task slices where it improves an agreed outcome. A useful release decision records quality, severe-error rate, latency, accepted-answer cost, operational reliability, and the date of the test. That record will remain more useful than a permanent claim that one model is simply 'best.'
Find the model in Kendr
Kendr's public Grok 4.6 profile brings the model identity, capabilities, context, pricing references, benchmark evidence, and source dates into one inspectable page. The broader model directory supports discovery, while Rankings provides comparison context and the developer area explains how model identifiers and managed routes fit the compatible API.
Grok 4.6 is currently a reference-only profile in Kendr, not a callable Kendr-hosted alias. Connector discovery and a successful inference check must happen before hosted availability can be claimed. Use the profile for research and query the live catalog or your authenticated model list before selecting any model in production.
- Open the Grok 4.6 reference profile.
- Browse the model directory and comparison evidence in Rankings.
- Use the developer documentation to distinguish public knowledge profiles from models returned by the live API.
Frequently asked questions
What is the Grok 4.6 API model ID?
The official API model ID is grok-4.6. Priority Processing uses the same model ID with service_tier set to priority; there is no need to invent a separate fast-model identifier.
How large is the Grok 4.6 context window?
xAI documents a 500,000-token context window and a 1 February 2026 knowledge cutoff. Prompts at or above 200,000 tokens use the higher long-context pricing band.
How much does Grok 4.6 cost?
xAI lists standard rates of $2 per million input tokens, $0.50 per million cached input tokens, and $6 per million output tokens below the long-context threshold. At 200,000 prompt tokens and above, the listed rates are $4, $1, and $12 respectively. Priority Processing is billed at twice the applicable standard token rates when the response confirms that tier.
Does Grok 4.6 accept images?
Yes. xAI documents text and image input with text output. It also lists function calling, structured outputs, web search, X search, and code execution.
Are the Grok 4.6 benchmark scores independently verified by Kendr?
No. The scores in this article reproduce xAI's launch announcement and are labeled as vendor-reported. Use them to select evaluation candidates, then test the model on your own held-out tasks.
Sources and evidence
Primary and authoritative sources used for factual claims. Company research and executive forecasts are labeled as such in the article.
- 1Introducing Grok 4.6xAI · 2026-08-12
- 2Grok 4.6 developer guidexAI · 2026-08-12
- 3Grok 4.6 model referencexAI · 2026-08-12
- 4API pricingxAI
- 5
- 6ReasoningxAI