xAI released Grok 4.7 on September 21, 2026. The public xAI API model is grok-4.7, with a 500,000-token context window, text and image input, text output, and four reasoning-effort levels. The launch also introduced Grok 4.7 Fast, but that faster product is currently documented for Cursor and Grok Build rather than as a direct public xAI API model.
That distinction matters. Developers choosing an API should price grok-4.7 from xAI’s API documentation. Cursor or Grok Build users can separately evaluate Grok 4.7 Fast inside those products. Do not assume the Fast price or endpoint exists in the direct xAI API merely because the name appears in an IDE.
Grok 4.7 at a glance
| Item | Grok 4.7 |
|---|---|
| API model ID | grok-4.7 |
| Status | Available in the xAI API |
| Context window | 500,000 tokens |
| Input and output | Text and images in; text out |
| Reasoning effort | low, medium, high (default), xhigh |
| Published rate limits | 150 requests/second; 50 million tokens/minute |
| Input price below 200K | $2.00 per million tokens |
| Cached input below 200K | $0.50 per million tokens |
| Output below 200K | $6.00 per million tokens |
The rate limits are xAI’s published model limits, not a promise that every account receives identical practical throughput. Check your console and agreement before sizing production capacity.
Grok 4.7 API pricing
xAI uses two price tiers based on request input length. Requests below 200,000 input tokens use the standard tier. Requests at or above 200,000 input tokens use the long-context tier.
| Input length | Input | Cached input | Output |
|---|---|---|---|
| Below 200K input tokens | $2.00/M | $0.50/M | $6.00/M |
| 200K input tokens or more | $4.00/M | $1.00/M | $12.00/M |
The higher tier applies once the request reaches the threshold. It is not simply an extra charge on tokens beyond 200K. Prompt size is therefore an architectural cost decision. Retrieval, summarization, and prompt-cache reuse can be more economical than repeatedly sending an entire repository or document collection.
xAI also documents a 1.1x United States regional multiplier. With that option, rates are $2.20 input, $0.55 cached input, and $6.60 output below 200K; and $4.40 input, $1.10 cached input, and $13.20 output at or above 200K. Confirm whether regional processing is required before treating the lower global rate as your production cost.
For a broader comparison, see our AI API pricing table. For authentication and code examples, use the xAI API setup guide.
What is Grok 4.7 Fast?
Grok 4.7 Fast is a separate low-latency option documented for Cursor and Grok Build.
| Fast input length | Input | Cached input | Output |
|---|---|---|---|
| Below 200K input tokens | $4.00/M | $1.00/M | $12.00/M |
| 200K input tokens or more | $6.00/M | $1.50/M | $18.00/M |
Those rates are higher than standard Grok 4.7. The tradeoff is speed inside supported coding environments, not a lower-cost API tier. As of publication, xAI does not list Grok 4.7 Fast as a direct public API model. If you need a stable API integration, use grok-4.7 unless xAI later documents a Fast endpoint.
This is also different from gateway access. xAI confirms Grok 4.7 distribution through OpenRouter, Vercel, and Cloudflare, but gateway pricing, routing, retention, and regional behavior can differ from a direct xAI account.
Reasoning levels and cost control
Grok 4.7 supports low, medium, high, and xhigh, with high as the documented default. A higher effort setting does not change the listed per-token rate, but it can increase generated reasoning and output tokens. The invoice can still rise.
Use low or medium for extraction, classification, routine code edits, and simple tool selection. Reserve high or xhigh for difficult debugging, architecture decisions, and long agent runs. Measure success rate and total cost per completed task rather than comparing token prices alone.
For agent systems, combine effort selection with rate limiting, retry and fallback handling, and an AI gateway. A model upgrade does not remove the need for bounded retries or cost ceilings.
Images, context, and output
The model accepts text and image input and returns text. That supports code screenshots, UI inspection, charts, and mixed visual-text analysis. It does not make Grok 4.7 an image-generation endpoint.
The 500K context window can hold large repositories or long evidence sets, but capacity is not the same as useful recall. Long prompts increase latency and can trigger the higher price tier. Production systems should select relevant files, preserve source references, and evaluate whether answers remain grounded as context grows.
xAI does not document a separate text-output token limit on the model page. That should not be read as unlimited output. API, account, latency, and practical response constraints still apply.
GitHub Copilot availability
GitHub says Grok 4.7 is available in Copilot for Pro, Pro+, Max, Business, and Enterprise users, with a gradual rollout across supported surfaces. Organization administrators may need to enable it through model policy.
Copilot availability does not provide direct xAI API access, and Copilot usage follows GitHub’s plans. Keep three decisions separate: using Grok through Copilot, calling grok-4.7 through xAI, and using a gateway. Our GitHub Copilot App guide tracks the model-selection context.
Grok 4.7 vs Grok 4.6
Grok 4.6 remains useful historical context, but 4.7 is the current model to evaluate for new xAI integrations. Both use a 500K context window and expose low through xhigh reasoning. Current xAI documentation also shows long-context pricing tiers. Older wording that treated Grok 4.6 as a flat $2/$6 model at every prompt length is no longer accurate.
See the Grok 4.6 guide for generation-specific details, and verify current billing before migrating a large-context workload.
Practical migration checklist
- Change the model ID in a staging environment.
- Test tool calls and structured outputs your application depends on.
- Measure output length at each reasoning level.
- Test requests just below and above the 200K pricing threshold.
- Verify retry logic does not duplicate consequential actions.
- Set cost and latency alerts before increasing traffic.
- Keep a tested fallback until evaluation results are stable.
Use LLM regression testing rather than relying on a few impressive prompts. Agent workflows also need idempotency when retries can trigger writes, messages, or purchases.
My take
Grok 4.7 is compelling for teams that want a large-context reasoning model with direct xAI access and broad coding-tool distribution. The normal tier is competitive, but the 200K threshold can double token rates. Prompt design and caching matter for repository-scale agents.
Grok 4.7 Fast is not universally better. It is a higher-priced, latency-oriented option inside Cursor and Grok Build. Benchmark whether faster responses improve completed-task economics enough to justify the premium.
FAQ
How much does Grok 4.7 cost?
Below 200K input tokens, it costs $2/M input, $0.50/M cached input, and $6/M output. At 200K input tokens or more, those rates become $4, $1, and $12.
Does Grok 4.7 have a 500K context window?
Yes. xAI documents 500,000 tokens. Requests reaching 200K input tokens enter the higher price tier.
Can I call Grok 4.7 Fast through the xAI API?
Not according to the launch documentation reviewed here. Fast is documented for Cursor and Grok Build, while grok-4.7 is the direct public API model.
Is Grok 4.7 available in GitHub Copilot?
Yes, for Pro, Pro+, Max, Business, and Enterprise, subject to rollout and organization policies.
Does Grok 4.7 accept images?
Yes. It accepts text and image input and produces text output.