Contents
- Verdict
- API pricing
- The long-context economics that make Grok interesting
- What Grok costs on two real automations
- Agent reliability, and what the research says about long context
- A lineup actually shaped for agent work
- The procurement problem you have to solve first
- How to access
- Privacy and residency
- What we build
- FAQ
- Price sources
Grok is the value play on long context. Grok 4.3 lists at $1.25 in and $2.50 out per 1M tokens for prompts under 200K, with a million-token window, which is the cheapest million-token option among the US providers as of August 2026. The output price in particular is well under half what comparable US flagships charge. The reservation is not the models, it is the paperwork: we could not reach an official xAI page setting out API data retention and training policy, and for a business automation that is a gap you should close directly with the vendor before you build.
Best for
Long-context workloads on a budget: reading large document sets, long conversation histories, and multi-step agent runs that accumulate context.
Not for
Businesses that need a documented, linkable data-handling policy before they can approve a vendor.
xAI Grok API pricing per 1M tokens
xAI uses tiered long-context pricing: every listed model doubles its input, cached-input and output rates once a prompt reaches 200K tokens. That is unusually transparent and it changes how you design an agent, because keeping working context under the threshold is worth exactly half your unit cost. Cached input is published as a separate per-model rate. We could not reach a prompt-caching guide in xAI's documentation when we checked in August 2026, so how the cache is populated and how long it lives is something to confirm with xAI rather than assume. No batch or off-peak discount is published, though the Chat API does support deferred completions through a deferred parameter, which is an asynchronous mechanism rather than a discount. Knowledge cutoff across the line is stated as 1 February 2026. Prices below are list prices as of August 2026.
| Model | Context | Input / 1M | Output / 1M |
|---|---|---|---|
| grok-4.5 (flagship)Doubles to $4.00 / $12.00 on prompts of 200K+; cached input $0.30, $0.60 above the threshold | 500K | $2.00 | $6.00 |
| grok-4.3Doubles to $2.50 / $5.00 on prompts of 200K+; cached input $0.20 | 1M | $1.25 | $2.50 |
| grok-4.20-0309-reasoningReasoning variant; same tiered structure | 1M | $1.25 | $2.50 |
| grok-4.20-0309-non-reasoningNon-reasoning variant of the same line | 1M | $1.25 | $2.50 |
| grok-4.20-multi-agent-0309Dedicated multi-agent variant; same rates | 1M | $1.25 | $2.50 |
| grok-build-0.1 (coding and agents)Doubles on prompts of 200K+; cached input $0.20 | 256K | $1.00 | $2.00 |
List prices as of August 2026, taken from the provider's published pricing page on August 5, 2026. Model prices move fast - check the source links before you budget.
The long-context economics that make Grok interesting
Most cost discussions focus on the headline input price, but for agent workloads the thing that actually inflates a bill is carried context. Every turn of an agent loop resends the conversation so far, so a twenty-step agent pays for its early context twenty times over. Providers with cheap input pricing and large windows change the arithmetic of what is affordable to build.
Grok 4.3 at $1.25 in and $2.50 out per million with a million-token window, as of August 2026, is the cheapest way to get that combination from a US provider. The output price is the striking part: at $2.50 per million it is a fraction of what comparable US flagship tiers charge, which makes generation-heavy work - drafting long documents, producing many variants, writing detailed reports - meaningfully cheaper here than almost anywhere else with a US corporate entity behind it.
The tiered pricing above 200K tokens is worth designing around rather than ignoring. Rates roughly double once a prompt crosses that threshold, so an agent that lets its context grow unchecked can silently double its own unit cost mid-run. Building in a summarisation or compaction step that keeps working context under 200K is a straightforward change that pays for itself immediately.
Cached input is published as a separate rate on every model, at $0.20 per 1M on grok-4.3 against a $1.25 base, which is a saving of roughly six times rather than the ten times most rivals offer. We could not reach a caching guide in xAI's documentation when we checked in August 2026, so whether the cache is automatic on a repeated prefix, how long it lives, and what invalidates it are questions to put to xAI before you build a cost model around it. The rate exists on the price list; the mechanism is not documented where we could read it.
What Grok costs on two real automations
We price every provider on this site against the same two workloads. Workload A is an inbox agent: 1,500 runs a month at about 3,000 input tokens each, of which 2,400 are a stable prefix, plus 400 output tokens. Workload B is document extraction: 4,000 documents a month at 6,000 input and 300 output tokens each. Neither comes near the 200K threshold, so both run at the lower tier rates.
On grok-4.3 at $1.25 in and $2.50 out per 1M, Workload A costs about $7.13 a month and Workload B about $33.00. If the cached-input rate of $0.20 applies to the stable prefix, Workload A drops to roughly $3.35. On grok-build-0.1 at $1.00 and $2.00 they are about $5.70 and $26.40. On the grok-4.5 flagship at $2.00 and $6.00 they are about $12.60 and $55.20.
Read those numbers honestly and Grok's position is specific rather than general. Workload B on Grok's cheapest model costs about $26 a month; the same job on OpenAI's budget tier is about $6.24, or $3.12 batched, and on Gemini 2.5 Flash-Lite about $2.88. Grok is not the cheap option for high-volume routine extraction and there is no batch discount to close the gap. Where it wins is the shape of workload where output volume and carried context dominate, because $2.50 per 1M output with a million-token window is a combination nobody else at a US corporate entity matches.
Budget for the threshold as a step change rather than a slope. An agent whose context creeps from 190K to 210K tokens does not get 10 percent more expensive, it gets 100 percent more expensive on every token in that request. Put a hard compaction step in the loop and alert on prompt size. That single control is worth more than any model choice on a long-running agent.
Agent reliability, and what the research says about long context
Grok's pitch for agent work is a million-token window at a low price, so the published research on long-context behaviour matters more here than for most providers. LOCA-bench, released in early 2026, grows an agent's context under controlled conditions while holding the task semantics fixed, and reports that most models including frontier and open-source ones degrade sharply as context length rises, with the spread between models widening at the long end. Cheap long context is an invitation to build the exact thing that benchmark says fails.
Read together with xAI's own 200K pricing threshold, this points to a clear design rule: keep the working context under 200K, both because it halves the token price and because accuracy is better there. A compaction or summarisation step that runs whenever context approaches the threshold is doing two jobs at once. That is a rare case where the cheap design and the reliable design are the same design.
AgentCE-Bench, from April 2026, injects tool-call failures at rates from zero to 0.3 and finds even a 10 percent failure rate visibly degrades agent performance across every task horizon and difficulty tested. Since xAI publishes a dedicated multi-agent variant and a coding model aimed at exactly this kind of long-horizon work, the same discipline applies: retry and backoff, idempotency on writes, hard step limits, and an escalation path to a human rather than an infinite loop.
One practical note in Grok's favour: because the API is OpenAI-compatible in request format, running your own twenty-case eval against it costs almost nothing. Point an existing integration at the xAI base URL with a new key, run your real cases, grade the outputs. That low switching cost is itself an argument for testing rather than theorising, and it also means adopting Grok does not lock you in, which is the right way to try a vendor whose data-handling documentation you have not been able to read.
A lineup actually shaped for agent work
One thing xAI does that most providers do not is ship distinct models for distinct jobs rather than one general model at three sizes. There is a flagship, a cheaper long-context model, a reasoning line that includes a multi-agent variant, and a separate coding and agent model. For someone building automations that is a more useful shape than a single quality ladder, because agent work and chat work genuinely want different things.
The coding and agent model in particular is priced low, at $1.00 in and $2.00 out per million with a 256K window as of August 2026, which makes it plausible for the kind of continuous background engineering automation that would be too expensive on a flagship - dependency upgrades, test backfilling, routine refactors run nightly.
We are deliberately not quoting benchmark scores. Agent benchmarks turn over monthly, vendors pick the ones that flatter them, and none of them measure whether a model can correctly triage your inbox against your business rules. Run twenty of your own real cases through Grok and through whatever you use today, have someone who knows the right answers grade both, and you will have a better decision than any leaderboard could give you.
Because the API is OpenAI-compatible in request format, that test is cheap to run: for most integrations it is a base URL and an API key, not a rewrite. That low switching cost is itself an argument for trying it.
The procurement problem you have to solve first
We are going to be blunt about the weak spot, because pretending otherwise would not serve you. As of August 2026 we could not reach an official xAI documentation page setting out how API data is retained and whether it is used for training. A data-retention guide path in the docs returned a 404, and x.ai/legal/privacy-policy returned a 403 from this environment. The API reference does state that Responses API responses are stored for 30 days before permanent deletion, that a store parameter controls retention, and that a delete endpoint exists, which is a partial answer about one endpoint, not a policy document.
That matters more than it might sound. For most small businesses, adopting an AI vendor means adding a subprocessor that will see customer data, and the minimum bar is a linkable policy plus a data processing agreement you can file. Competing providers publish both. If you cannot produce that document, a cautious client, an insurer or an auditor can reasonably object, and you will not have an answer.
None of this is an allegation about how xAI actually handles data. It is a statement about what we could and could not verify from public sources, which is the standard we hold every provider on this site to. The fix is straightforward: contact xAI, ask for the current API data processing terms and retention policy in writing, and read them. If they are satisfactory, the pricing case for Grok on long-context and generation-heavy work is genuinely strong.
Until then, our practical recommendation is to use Grok for workloads with low data sensitivity - public research, content drafting from non-confidential inputs, internal engineering automation on your own code - and hold off on putting customer records through it.
Strengths for agent workloads
- The cheapest million-token context option among US providers as of August 2026
- Output pricing well under half that of comparable US flagship tiers, which matters on generation-heavy work
- Distinct models for distinct jobs: a flagship, a long-context tier, reasoning and non-reasoning variants, a multi-agent variant and a dedicated coding model
- Cached input published per model, at roughly a sixth of the base input rate
- Transparent tiered pricing above 200K tokens, so long-context cost is predictable rather than surprising
- OpenAI-compatible request format, so trialling it is usually a base URL and key change rather than a rewrite
- A store parameter and a delete endpoint on the Responses API, so you can control and remove stored responses yourself
Weaknesses
- We could not reach an official xAI page documenting API data retention and training policy, and x.ai/legal/privacy-policy returned a 403 from this environment in August 2026
- No batch or off-peak discount is published, so a workload that another vendor would run at half price overnight pays full rate here
- No prompt-caching guide was reachable in the documentation, so the cache mechanism and TTL are undocumented from where we sit
- The cheap tiers are not cheap by budget-model standards: grok-build at $1.00 in is five times OpenAI's current budget tier and ten times Gemini 2.5 Flash-Lite
- A smaller ecosystem than OpenAI or Google in no-code automation platforms
- Brand association with the consumer Grok product, which has different and more permissive data defaults, causes avoidable internal objections in some businesses
How to access xAI Grok
- Direct API from x.ai, which is the primary and best-documented route.
- OpenRouter and similar aggregators, useful for testing Grok against other models on the same workload before committing.
- OpenAI-compatible request format on the API, which means most existing integrations work with a base URL and key change rather than a rewrite.
Data privacy and residency
- Stated plainly: as of August 2026 we could not reach an official xAI documentation page setting out API data retention and training policy. A data-retention guide path in the docs returned a 404, and x.ai/legal/privacy-policy returned a 403 from this environment. We are not going to reproduce a policy from memory in place of a source we could read.
- What the API reference does document is useful and narrow. Responses created through the Responses API are stored for 30 days and then permanently deleted. A store parameter controls whether the input messages and model response are retained for later retrieval, and there is a delete endpoint so you can remove a stored response before the window expires. That is real, checkable control over one endpoint, and it is not the same thing as a retention policy for the whole API.
- Secondary reporting suggests the consumer Grok product trains on conversations by default with an opt-out, while API and enterprise use operates under separate terms with a data processing agreement available. We have not been able to verify that against an xAI-official page and you should not treat it as settled.
- The practical advice is simple: if you are considering Grok for a business workload, ask xAI directly for their current API data processing terms and retention policy in writing before you send any customer data. That is good practice with any vendor and it is necessary here.
- Do not reason from the consumer product to the API. The defaults are usually different, in both directions, and assuming either way is how businesses end up with the wrong terms.
What we build on xAI Grok
- Long-context research and document synthesis where the whole corpus goes in one call rather than through a retrieval layer
- Agent runs with long accumulated histories, where the per-token cost of carrying context is the dominant expense
- Generation-heavy work such as bulk content drafting, where the low output price is decisive
- Coding and repository automations using the dedicated build model
- Cost-sensitive experiments where you want to know whether a cheaper model does the job before paying flagship rates
Model choice is a line item, not a strategy. If you want the workflow designed, built and handed over with a plain-language report of what it ran and what it saved, start with a free AI automation audit or see the full done-for-you automation services.
xAI Grok FAQ
How much does the Grok API cost?
As of August 2026, grok-4.5 lists at $2.00 in and $6.00 out per 1M tokens for prompts under 200K, grok-4.3 at $1.25 and $2.50 with a million-token window, and the grok-build coding model at $1.00 and $2.00. Rates roughly double for prompts over 200K tokens. Cached input is priced separately, from $0.20 per 1M.
Is Grok cheap enough to be worth switching to?
On long-context and generation-heavy workloads, the pricing is genuinely competitive: grok-4.3 offers a million-token window at a fraction of comparable US flagship output prices. Because the API is OpenAI-compatible in request format, testing it usually means changing a base URL and key rather than rewriting an integration, so the cost of finding out is low.
Does xAI train on API data?
We could not verify this against an official xAI documentation page as of August 2026. The API reference states Responses API responses are stored for 30 days then permanently deleted. Secondary reporting suggests API and enterprise use runs under separate terms from the consumer product, but we cannot confirm it. Ask xAI directly for their current terms in writing before sending customer data.
Why does the price double on long prompts?
xAI uses tiered long-context pricing: rates roughly double once a prompt exceeds 200K tokens. It is unusually transparent about this, and it is worth designing around. Adding a summarisation or context-compaction step that keeps an agent's working context under the threshold is a small change that directly halves the unit cost of long runs.
Is Grok good for coding automation?
xAI ships a dedicated coding and agent model priced at $1.00 in and $2.00 out per 1M with a 256K window as of August 2026, which is cheap enough to make continuous background engineering work viable - nightly dependency upgrades, test backfilling, routine refactors. Whether it matches alternatives on your codebase is something to test with real tasks from your own repository.
Does Grok have a batch discount?
No batch or off-peak discount is documented in the public xAI API reference as of August 2026, so we are not going to claim one exists. The Chat API does support deferred completions through a deferred parameter, which returns a request ID you poll later, but that is an asynchronous mechanism rather than a price break. If a large share of your workload can run overnight, that absence is worth weighing against providers publishing a 50 percent batch discount.
What would a real Grok automation cost per month?
A 1,500-run inbox agent at about 3,000 input and 400 output tokens per run costs roughly $7.13 a month on grok-4.3, or about $3.35 if the published cached-input rate applies to the stable prefix. A 4,000-document extraction job at 6,000 input and 300 output tokens each is about $33.00 on grok-4.3 and about $26.40 on grok-build-0.1. For comparison, the same extraction job is a few dollars on the cheapest OpenAI and Gemini tiers, so Grok is not the volume-work bargain.
How does Grok's prompt caching work?
We cannot tell you, and we are not going to guess. Every model publishes a cached-input rate, typically about a sixth of the base input rate, so caching plainly exists and is billed. But we could not reach a prompt-caching guide in xAI's documentation in August 2026, so whether it triggers automatically on a repeated prefix, how long the cache lives, and what invalidates it are open questions. Confirm them with xAI before you build a cost model that assumes cache hits.
Which model should I pick from the Grok lineup?
grok-4.3 is the default for most automation work: a million tokens of context at $1.25 in and $2.50 out. grok-4.5 is the flagship at $2.00 and $6.00 with a 500K window, for the judgement steps. grok-build-0.1 is the cheapest at $1.00 and $2.00 with 256K, aimed at coding and agent work. The 4.20 line offers reasoning, non-reasoning and multi-agent variants at grok-4.3 rates if you want to control that behaviour explicitly.
