Grok API Pricing 2026: Grok 4.5, 4.3, 4.20, and Build Costs
Current xAI API pricing for Grok 4.5, Grok 4.3, three Grok 4.20 endpoints, and Grok Build 0.1, including cached input, long-context rates, limits, and migration notes.
xAI’s current language-model API lineup has six canonical model IDs: Grok 4.5, Grok 4.3, three Grok 4.20 endpoints, and Grok Build 0.1. The headline prices are only the standard rates. Once a request exceeds 200,000 context tokens, input, cached-input, and output rates all double.
Current Grok API Prices
All prices below are in USD per 1 million tokens. These standard rates apply to requests that do not exceed the 200K long-context threshold.
| Model | Canonical API ID | Input | Cached Input | Output | Context | Status |
|---|---|---|---|---|---|---|
| Grok 4.5 | grok-4.5 | $2.00 | $0.50 | $6.00 | 500K | Active; launched July 8, 2026 |
| Grok 4.3 | grok-4.3 | $1.25 | $0.20 | $2.50 | 1M | Active |
| Grok 4.20 Reasoning | grok-4.20-0309-reasoning | $1.25 | $0.20 | $2.50 | 1M | Active |
| Grok 4.20 Non-Reasoning | grok-4.20-0309-non-reasoning | $1.25 | $0.20 | $2.50 | 1M | Active |
| Grok 4.20 Multi-Agent | grok-4.20-multi-agent-0309 | $1.25 | $0.20 | $2.50 | 1M | Beta |
| Grok Build 0.1 | grok-build-0.1 | $1.00 | $0.20 | $2.00 | 256K | Public beta |
The three Grok 4.20 endpoints have identical token prices but different execution behavior. Use the dated canonical IDs when reproducibility matters instead of a moving -latest alias.
Pricing Above 200K Context
If a single request exceeds 200,000 context tokens, xAI applies the following higher rates:
| Model | Input | Cached Input | Output | Maximum Context |
|---|---|---|---|---|
| Grok 4.5 | $4.00 | $1.00 | $12.00 | 500K |
| Grok 4.3 | $2.50 | $0.40 | $5.00 | 1M |
| Grok 4.20 Reasoning | $2.50 | $0.40 | $5.00 | 1M |
| Grok 4.20 Non-Reasoning | $2.50 | $0.40 | $5.00 | 1M |
| Grok 4.20 Multi-Agent | $2.50 | $0.40 | $5.00 | 1M |
| Grok Build 0.1 | $2.00 | $0.40 | $4.00 | 256K |
The threshold is evaluated per request, not against your daily or monthly aggregate. Sending 1 million input tokens as ten separate 100K requests uses standard rates. Sending more than 200K context in one request activates long-context pricing for that request.
What Each Grok Model Is For
Grok 4.5
Grok 4.5 is xAI’s strongest current model for coding, agentic tasks, and knowledge work. It accepts text and images, supports function calling and structured outputs, and offers low, medium, and high reasoning effort. The API defaults to high reasoning. It has a 500K context window and is also the current default model in Grok Build.
Grok 4.3
Grok 4.3 is the lower-cost general-purpose option with a 1M context window. Its configurable reasoning levels are none, low, medium, and high, so one model can cover fast non-reasoning requests and deeper reasoning workloads.
Grok 4.20 Reasoning and Non-Reasoning
The two single-agent Grok 4.20 endpoints separate reasoning and non-reasoning behavior at the model-ID level. Both accept text and image input and support function calling and structured output. Their 1M context and token pricing match Grok 4.3.
Grok 4.20 Multi-Agent
The multi-agent beta coordinates multiple agents in parallel for deep research and multi-step analysis. Its token rates match the other Grok 4.20 endpoints, but a multi-agent run can consume substantially more tokens. xAI-provided Web Search, X Search, code execution, and other server-side tools are billed separately when invoked.
Grok Build 0.1
Grok Build 0.1 is a coding model trained for agentic software engineering, web development, debugging, and MCP workflows. It has a 256K context window. Current xAI model documentation lists both text and image input, reasoning, function calling, and structured outputs. It remains a public-beta API model.
Context Window Is Not Maximum Output
xAI publishes each model’s context window, but its current model pages do not publish a maximum output-token value for these six endpoints. A 500K or 1M context window must not be presented as the maximum output size. Set an explicit output budget in your application and treat any maximum-output figure not documented by xAI as unverified.
Cost Examples
For daily traffic distributed across requests of 200K context or less, with no cache hits:
| Daily Usage | Grok 4.5 | Grok 4.3 / Grok 4.20 | Grok Build 0.1 |
|---|---|---|---|
| 100K input + 50K output | $15/month | $7.50/month | $6/month |
| 1M input + 500K output | $150/month | $75/month | $60/month |
| 10M input + 5M output | $1,500/month | $750/month | $600/month |
For comparison, one request with 210K input tokens and 20K output tokens crosses the threshold. It costs about $1.08 on Grok 4.5, $0.63 on Grok 4.3 or Grok 4.20, and $0.50 on Grok Build 0.1 before tool charges.
Prompt caching is most useful for repeated system prompts, tool schemas, and stable repository context. Cached tokens still count toward tokens-per-minute limits even though their billing rate is lower.
Current API Rate Limits
xAI now documents spend-based API tiers rather than a fixed free-model limit. Tier 0 is the default tier; it is not a promise of free token usage.
| Model | Tier 0 RPS | Tier 0 TPM |
|---|---|---|
| Grok 4.5 | 150 | 50M |
| Grok 4.3, both single-agent Grok 4.20 endpoints, and Grok Build 0.1 | 37 | 10M |
| Grok 4.20 Multi-Agent | 9 | 2.5M |
Tier 1 through Tier 4 unlock at $50, $250, $1,000, and $5,000 of cumulative API spend since January 1, 2026. xAI does not currently document a guaranteed $25 signup API credit. That offer belonged to the API public beta through the end of 2024 and should not be used for current cost planning.
Retired Grok IDs
xAI’s May 15, 2026 retirement notice explicitly covers grok-3, grok-4-0709, the Grok 4 Fast and Grok 4.1 Fast reasoning/non-reasoning endpoints, and grok-code-fast-1. Retired language-model requests redirect to Grok 4.3, while the old code endpoint redirects to Grok Build 0.1. Billing follows the replacement model, so historical prices no longer describe the actual request path.
For new integrations, select one of the six canonical IDs in the current pricing table rather than using a retired identifier as a cost anchor.
Which Model Should You Use?
- Choose Grok 4.5 for the hardest coding, agentic, and knowledge-work tasks.
- Choose Grok 4.3 for lower-cost general agents, configurable reasoning, and 1M context.
- Choose a Grok 4.20 single-agent endpoint when you want reasoning behavior encoded in the model ID.
- Choose Grok 4.20 Multi-Agent for deep research where parallel agents justify higher total token use.
- Choose Grok Build 0.1 for a lower-cost coding-specific public-beta model.
Grok does not have access to current events unless server-side search tools are enabled. Real-time Web and X retrieval can improve freshness, but tool invocation charges must be included in the budget.
Use the AI Model Pricing Calculator to compare current USD-priced models.
Official sources checked July 14, 2026: xAI pricing, model directory, Grok 4.5 model page, Grok 4.20 multi-agent documentation, API rate limits, release notes, and the May 15 retirement notice.
Related Posts
AI API Pricing Comparison (July 2026): 50+ Models Side-by-Side Table
2026-02-19
GPT-5.6 API Pricing Guide 2026: Sol, Terra & Luna Token Costs
2026-07-14
GPT-5.6 in Codex: Credit Pricing, Multi-Agent, and Weekly Limit Facts
2026-07-14