PRICING · 8 MIN READ
Grok 4.3 API Pricing: What the 1M Token Context Window Actually Costs
Grok 4.3 is xAI's cost workhorse: $1.25/$2.50 per million tokens with a 1M context window. But a billing cliff at 200k prompt tokens can double a request's cost. Here's the full math, and how to cut the bill in half.
Ravi Kumar
Co-founder ·
Grok 4.3 API Pricing: What the 1M Token Context Window Actually Costs
Grok 4.5 gets the headlines, but Grok 4.3 is the model most cost-conscious teams should be looking at first. It runs $1.25 per million input tokens and $2.50 per million output tokens, carries a 1M token context window (double Grok 4.5's 500k), and still supports function calling, structured outputs, reasoning, and image input. On output tokens alone it is less than half the price of Grok 4.5.
The catch is that the pricing has a cliff in it. Cross 200k prompt tokens in a single request and every token in that request, not just the overflow, bills at double the rate. If you are budgeting Grok 4.3 for long-context work, that one rule matters more than anything else on the price sheet. This post walks through the full official pricing, the 200k threshold math, how 4.3 compares to the rest of the xAI lineup, and how to take 50% off the whole bill without changing your code beyond one line.
The Official Grok 4.3 Price Table
Straight from xAI's model docs, Grok 4.3 bills at two tiers depending on the size of the prompt in each request:
| Type | Under 200k prompt tokens | 200k prompt tokens and above |
|---|---|---|
| Input | $1.25 / 1M tokens | $2.50 / 1M tokens |
| Cached input | $0.20 / 1M tokens | $0.40 / 1M tokens |
| Output | $2.50 / 1M tokens | $5.00 / 1M tokens |
A few more facts that belong in any cost model:
- Context window: 1,000,000 tokens
- Batch API: 20% discount on standard rates for async workloads
- Rate limits: 37 requests per second and 10M tokens per minute
- Capabilities: function calling, structured outputs, reasoning, and image input, so the low price does not lock you out of agentic workloads
The threshold rule is the part most people misread, so it is worth stating precisely: a request whose prompt reaches 200k tokens is billed at the higher rate for all tokens in the request. It is not marginal pricing. There is no cheap first 200k inside a big request.
The 200k Cliff: One Chunk Can Double a Request's Cost
Because the long-context rate applies to the entire request, the difference between a 199k prompt and a 201k prompt is not 2k tokens of extra cost. It is a repricing of everything.
Run the numbers on a request that generates 2,000 output tokens:
- 199k prompt tokens: 199,000 x $1.25/M is about $0.249 of input, plus 2,000 x $2.50/M of output. Total: roughly $0.254.
- 201k prompt tokens: 201,000 x $2.50/M is about $0.503 of input, plus output now at $5.00/M. Total: roughly $0.513.
Two thousand extra prompt tokens doubled the request cost. If your RAG pipeline pads context "because the window is huge," or your agent framework never trims history, you can drift across this line without noticing, and your per-request cost silently doubles. The fix is boring but effective: measure your prompt sizes, and if your p95 request sits near 200k, either trim aggressively to stay under it or accept the long-context tier deliberately and budget for it. The worst place to be is straddling the line at random.
Note that the same doubling applies to cached input ($0.20 to $0.40). Caching softens the cliff but does not remove it.
What Filling the 1M Window Actually Costs
The 1M context window is the reason to pick Grok 4.3 over 4.5 for document-heavy work, so price the extreme case honestly. A single request with a full 1,000,000 token prompt bills entirely at the long-context tier: $2.50 of input per call. Ask for 5,000 output tokens on top and you add about $0.025. Call that $2.53 per fully loaded request.
That sounds steep until you compare it to the alternative. Grok 4.5 cannot hold that prompt at all (500k window), and its long-context tier is $4.00 input / $12.00 output. For repeated queries against the same giant context, prompt caching changes the economics completely: a stable 1M token prefix rebilled at the cached long-context rate of $0.40/M costs $0.40 per call instead of $2.50. An 84% cut for structuring your prompts so the prefix stays byte-identical between calls.
Grok 4.3 vs Grok 4.5 vs grok-build-0.1
The xAI lineup now has three distinct price points for text work:
| Model | Context | Input / cached | Output | Long-context tier |
|---|---|---|---|---|
| grok-4.5 | 500k | $2.00 / $0.30 | $6.00 | $4.00 / $0.60 / $12.00 |
| grok-4.3 | 1M | $1.25 / $0.20 | $2.50 | $2.50 / $0.40 / $5.00 |
| grok-build-0.1 | 256k | $1.00 / $0.20 | $2.00 | $2.00 / $0.40 / $4.00 |
The headline gap is output pricing. Grok 4.5 charges $6.00 per million output tokens; Grok 4.3 charges $2.50. For output-heavy workloads (summarization, report generation, verbose agent traces), 4.3 cuts the dominant line item by 58% while keeping tool calling and structured outputs. Grok 4.5 earns its premium on frontier coding and agentic tasks where output quality compounds. grok-build-0.1 is the budget coding option when 256k of context is enough.
A sane default routing policy: grok-4.3 for extraction, classification, summarization, long-document Q&A, and high-volume agent steps; grok-4.5 for the hard reasoning and final code generation; grok-build-0.1 for cheap drafting. Because all three sit behind the same OpenAI-compatible API, routing is a string change per request.
Cached Input at $0.20: The Quietly Cheapest Rate on the Sheet
Grok 4.3's cached input rate is $0.20 per million tokens, an 84% discount against its own standard input rate. Caching is automatic and prefix-based: keep your system prompt, tool schemas, and conversation history byte-for-byte stable at the front of the request and repeated calls bill the matched prefix at the cached rate. Agent loops that append turns instead of rebuilding the message array are the best case, because each call's prompt is the previous prompt plus a suffix.
At $0.20/M, a 100k token knowledge base re-sent on every call costs $0.02 per call instead of $0.125. Across a million calls a month, that is the difference between $20,000 and $125,000 of input spend. Prompt discipline is not glamorous, but at these volumes it is a salary.
Pointing Your SDK at a 50% Discount
Everything above is xAI list price. Grokified resells every Grok model, including grok-4.3, at 50% off list for your first $10,000 of usage (up to $5,000 saved), then 3% off for life after that. Same models, same API shape, no subscription. You get $5 of free credits on signup and top up from $10.
The migration is a base URL swap that works with any OpenAI SDK:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_GROKIFIED_API_KEY",
base_url="https://api.grokified.com/v1",
)
response = client.chat.completions.create(
model="grok-4.3",
messages=[
{"role": "system", "content": "You are a contract analysis assistant."},
{"role": "user", "content": "Summarize the indemnification clauses in the attached agreement."},
],
)
print(response.choices[0].message.content)
Prompt caching, function calling, structured outputs, and streaming all pass through unchanged, because Grokified is a transparent proxy in front of xAI's own infrastructure. Your cache hit rates and your prompt structure work exactly as they would against the direct endpoint. The only thing that changes is the number on the invoice.
A Worked Monthly Bill
Take a realistic mid-size workload on grok-4.3, all requests under the 200k threshold: 500M input tokens a month, of which 400M hit the cache, plus 60M output tokens.
| Line item | Volume | List rate | List cost |
|---|---|---|---|
| Standard input | 100M | $1.25/M | $125.00 |
| Cached input | 400M | $0.20/M | $80.00 |
| Output | 60M | $2.50/M | $150.00 |
| Total at xAI list | $355.00 |
Routed through Grokified inside the discount window, the same month costs about $177.50. Over the full $10,000 discount allowance, that workload banks roughly $2,400 a year in savings for one line of configuration.
A Short Cost-Control Checklist for Grok 4.3
- Watch the 200k line. Log prompt token counts and alert when requests approach the threshold. Crossing it doubles the whole request, not the overflow.
- Stabilize your prefixes. No timestamps or request IDs at the top of the prompt; append conversation turns, never rebuild them.
- Use the Batch API for async work. Anything that can wait gets a further 20% off standard rates.
- Route by task, not by habit. Reserve grok-4.5's $6.00 output rate for work that needs it; let 4.3 carry the volume.
- Budget throughput, not just tokens. 37 requests per second and 10M tokens per minute is generous, but bursty batch jobs should pace themselves against it.
The Bottom Line
Grok 4.3 is the strongest price-per-token offer in the current xAI lineup: 1M tokens of context, full tool support, $1.25/$2.50 list pricing, and a $0.20 cached input rate that rewards disciplined prompt structure. The only real trap is the 200k long-context cliff, and now you know exactly where it is.
If you are already spending real money on Grok models, there is no reason to pay list price while you optimize. Sign up at Grokified, get $5 in free credits with no subscription, swap your base URL to api.grokified.com/v1, and pay 50% less for the same tokens on your first $10,000 of usage.
Ravi Kumar
Co-founder, Grokified
Previously built billing infrastructure for two developer platforms. Writes about the unglamorous parts of running an API business.