Grok 4.7 is available through the xAI API as grok-4.7, with a 500,000-token context window. Standard API pricing starts at $2 per million input tokens, $0.50 per million cached input tokens, and $6 per million output tokens. The model’s consumer-plan availability is a separate question, and Grok 4.7 Fast is not sold through the public xAI API.
That distinction matters because “Grok 4.7 access” can mean three different things: chatting in the Grok app, calling a metered API from software, or using the faster variant inside another product. The model name alone does not tell you which product you are paying for.
Official API sources reviewed October 6, 2026. The headline rates are only the starting point: the endpoint, full prompt, cache hits, reasoning and service tier determine the token estimate. This guide also shows how to reconcile that estimate with a completed request’s reported cost. No provider account, paid inference or model-quality test was performed for this review.
Connecting a third-party client? Start with the client-compatibility checks for rejected settings, silently ignored parameters and conversation storage.
Grok 4.7 access: API, app, and Fast are separate routes
| Route | What is confirmed | What to check |
|---|---|---|
| xAI API | Model ID grok-4.7; billed by token usage. |
Confirm the endpoint and its model list, then check the team’s limits and billing. |
| Grok consumer app and X plans | These are consumer products with plan-specific features and usage limits. | Whether your account’s model picker actually shows Grok 4.7. An API release does not prove that a named X plan includes it. |
| Grok 4.7 Fast | The same model on faster infrastructure: 2× standard short-context rates, but 1.5× standard long-context rates. | The official pricing page lists it for Cursor and Grok Build, not the public xAI API; Grok Build’s free tier excludes it. |
If you only want to chat, check the consumer product’s own plan and model picker; our SuperGrok vs X Premium+ guide addresses that decision. An app subscription does not establish an API credit balance. This API guide does not verify an individual consumer account’s model entitlement.
Grok 4.7 API prices, including the 200K context threshold
These are Standard global API rates in USD per million tokens, not a monthly plan or a Fast-mode quote.
| Prompt length for one request | Uncached input | Cached input | Output |
|---|---|---|---|
| Below 200K tokens | $2.00 / 1M | $0.50 / 1M | $6.00 / 1M |
| 200K tokens or more* | $4.00 / 1M | $1.00 / 1M | $12.00 / 1M |
*The main pricing table labels the long tier ≥200K; the model detail and some other sections use “exceed” or “above.” We use the main-table boundary for budgeting, as does our calculator. At exactly 200,000 input tokens, reconcile with the provider’s recorded request cost rather than assuming the cheaper tier. This wording difference is not an account test.
The published context window is 500,000 tokens. That is capacity, not a promise of short-context pricing. The tier follows one request’s full prompt, including cached input—not monthly volume, and not only the latest message. Previous turns, system instructions and tool results can all make that prompt longer.
Estimate a bill using your own request pattern
For standard requests under the threshold, use this estimate:
Estimated token cost = uncached input × $2/M + cached input × $0.50/M + output × $6/M.
Divide each token count by 1,000,000 before multiplying. Here, output means all billed generated tokens, including reasoning, not just the visible answer. This is a token subtotal; it excludes tool fees, separate storage, media, retry attempts, taxes, endpoint premiums and intermediary markups. The API Cost Calculator has distinct Grok 4.7 Standard global and US-route choices; its manual source dates are not a live invoice connection.
Example: a small monthly coding assistant
Hypothetical workload: 200 requests a month, each with 10,000 prompt tokens and 1,000 total billed output tokens, reasoning included. Every request uses Standard global service below the threshold, with no cache hits or tools:
- Input: 200 × 10,000 = 2,000,000 tokens → 2 × $2 = $4.00
- Output: 200 × 1,000 = 200,000 tokens → 0.2 × $6 = $1.20
- Estimated total: $5.20
This is not a monthly subscription price. It is a worked example for the stated volume and token sizes. If users paste longer files, the model repeats a large history, or the application retries failed requests, actual usage changes.
What prompt caching can change
xAI says matching message prefixes are cached automatically on consecutive requests. In the example above, if 75% of the 2 million input tokens were actually reported as cached, the estimate would be: 0.5 million uncached × $2 = $1.00; 1.5 million cached × $0.50 = $0.75; plus $1.20 output = $2.95.
That lower figure is conditional. A cache hit is not guaranteed just because two prompts look similar. Keep the shared opening messages identical, append new turns instead of rewriting old ones, and use the documented conversation or cache key for your API endpoint. Then inspect the response’s cached-token count. Budget using your observed cache rate, not the best-case rate.
For Chat Completions, inspect usage.prompt_tokens and usage.prompt_tokens_details.cached_tokens; for Responses, inspect usage.input_tokens and usage.input_tokens_details.cached_tokens. Cached input is a part of total input. Subtract it to get uncached input; do not add it on top again. These paths are documented in xAI’s cached-usage reference. If a client drops the field, the cache share is unknown, not a verified 0% or 100%.
Why long-context requests cost more
A hypothetical Standard global request with 250,000 uncached prompt tokens and 10,000 billed output tokens costs $1.12: $1.00 input plus $0.12 output. The higher rates cover the entire request, not just its last 50,000 input tokens.
This makes context management a cost decision as well as a product-design decision. Keep only useful history, summarize older turns where appropriate, and measure the size of the full prompt sent on every request.
A cache hit does not reset the context tier
Suppose that same 250,000-token prompt now has 100,000 cached tokens and 150,000 uncached tokens. The full prompt is still 250,000; it remains long-context. With 10,000 billed output tokens, the hypothetical subtotal is $0.82: 0.15M × $4 + 0.10M × $1 + 0.01M × $12. Using short-context prices because the uncached portion is under 200K would incorrectly produce $0.41. On the US route the Standard token subtotal would be $0.902 before non-token costs.
That is budgeting arithmetic, not a measured cache hit or bill. For reasoning, the current reasoning guide gives Grok 4.7 low, medium, high and xhigh settings, with high the default and reasoning not disableable. Changing effort may change generated-token consumption; it does not make the visible answer a complete usage record.
Fast mode and regional pricing
Grok 4.7 Fast: use 2× the standard short-context rates and 1.5× the standard long-context rates—not 2× at every prompt length. The official Fast pricing table lists input / cached input / output at $4 / $1 / $12 per million tokens below 200K prompt tokens, and $6 / $1.50 / $18 above 200K. Its wording is “above” and “exceeds” 200K; for a request exactly at the boundary, confirm the applicable tier in your platform’s billing documentation. Fast remains a Cursor or Grok Build option, not a public xAI API model or Grok Build free-tier benefit.
US regional endpoint: Standard Grok 4.7 token rates are 10% above global: $2.20 / $0.55 / $6.60 for the short tier and $4.40 / $1.10 / $13.20 for long. The same whole-prompt boundary applies. This is a billing route for the same model, not another capability ranking.
The regional documentation says the global base is https://api.x.ai/v1, while https://us.api.x.ai/v1 serves Grok 4.7 and 4.6 to all teams with their existing keys. If another globally available model returns 404 on US, check that route’s model list before assuming your subscription failed. Cross-endpoint cache reuse is not guaranteed.
The US guarantee covers request handling, inference, moderation and retained request data. Files, Collections, hosted tools and your network path are outside that guarantee; image, video and voice generation are not served there. Changing the base URL does not establish an end-to-end residency guarantee for an entire workflow.
Priority is not Grok 4.7 Fast
Priority Processing is a public text-API service tier, selected with service_tier: "priority". Fast is the separately billed Cursor/Grok Build route above. Requesting Priority is not proof it was granted: check the response’s service_tier. The pricing page lists 2× Standard token rates only when the returned tier is priority; if it returns default, Standard applies. Cache discounts precede that multiplier.
A theoretical $0.82 global Standard token subtotal would therefore become $1.64 if those same tokens were actually billed at Priority. Do not apply the Fast long-context multiplier to a public Priority request, or blanket-multiply an entire invoice’s storage and tool charges. The site’s Standard calculator is not a Priority quote. Neither route’s name establishes a measured latency improvement on your tasks.
Tool use can add costs beyond the model tokens
If you enable xAI’s hosted search or other server-side tools, your bill can include both token usage and tool charges. Different tools do not necessarily use the same billing unit. The official tool-price table lists these search rates:
| Search component | Unit to count | Additional fee |
|---|---|---|
| Web Search | Tool calls | $5 / 1,000 calls |
| X Search: posts | Fetched posts | $5 / 1,000 posts |
| X Search: profiles | Fetched user profiles | $10 / 1,000 profiles |
For an estimate, count model input, cached input, output and reasoning tokens first. Then add the tools your application actually invokes. Keep a small test budget, set account alerts or limits where available, and inspect usage after a realistic pilot. A per-million-token headline is not a complete cost estimate for an agent.
X Search: budget fetched items, not searches
Search-billing documentation checked October 8, 2026. The X Search usage reference counts fetched posts, including thread, parent and quoted posts, and fetched profiles. Counts accumulate across the request; repeat retrievals are not deduplicated. Ten citations in an answer do not establish ten billed posts.
Use usage.server_side_tool_usage_details.x_posts_fetched and usage.server_side_tool_usage_details.x_users_fetched, not just x_search_calls. If a wrapper omits these counters, the item fee is unknown. Do not invent a zero from an absent field.
Hypothetical example: two X searches fetch 50 posts and 4 profiles in total. The X fee is 50 × $0.005 + 4 × $0.01 = $0.29, not two calls × $0.005 = $0.01. Three additional Web Search calls add $0.015, making the combined search fee $0.305 before model tokens or other charges. These are chosen quantities, not a HiseHub request or invoice.
If each of the 200 requests in the earlier $5.20 monthly token example used that search pattern, the additional search estimate would be 200 × $0.305 = $61.00, for $66.20 combined. This does not predict your agent’s behavior: measure its actual fetched-item counts. Date and handle filters can narrow the query, but do not guarantee a fixed fee. Our API Cost Calculator deliberately quotes the token subtotal; it does not include these search fees.
When auditing a completed request, use the provider’s final charged cost below. Do not add this separate search estimate on top of a final request cost that already includes its hosted tools.
Check the bill against one completed response
xAI’s Cost Tracking reference documents usage.cost_in_usd_ticks as the request’s charged cost, including token discounts and server-side tool invocations. Convert ticks to USD by dividing by 10,000,000,000. This provider-reported value is different from our advance token estimate; adding the request’s tool fees to it a second time double-counts them.
Three bookkeeping rules matter: take one final cost per completed request; sum costs across turns yourself; and do not sum the running totals from successive xAI SDK streaming chunks. For REST Chat Completions streaming, the documentation places usage in the final chunk when usage is requested. If your wrapper does not expose the final field, mark that record unknown, not free. The documented Vercel wrapper currently omits that cost metadata; retain a provider receipt through a supported path instead of fabricating it from answer length.
To diagnose an unexpected bill, take one already-recorded request and work outward: endpoint → returned model → full input and cached subset → generated usage → returned service tier → provider cost. Then reconcile unique requests with the Console’s time window and account. A logical task can contain several separate client calls or retries; a request receipt is not automatically the cost of the whole task, a storage invoice, tax or a reseller’s bill.
A sanitized request record
Use this blank record locally for a completed request you already own. It is an editorial worksheet, not an example API response, measured test or request to spend money. Keep API keys, raw prompts, personal identifiers and private response contents out of support posts.
| Record | What to keep | What it helps distinguish |
|---|---|---|
| Request identity | Local attempt label, timestamp/timezone and billing account | One task versus several calls; mismatched billing periods |
| Route and model | Configured endpoint; returned model identity | Global/US pricing; a wrapper routing to another model |
| Prompt and cache | Full input count; cached subset; missing-field note | Whole-prompt tier; cache counted twice or guessed |
| Generation and tier | Reported output/reasoning fields; returned service tier | Visible answer versus billed work; Priority versus Default |
| Charged request cost | One final integer tick value, or “unknown” | A request subtotal versus a running streaming total |
| Task accounting | Other client attempts/calls; result accepted or rejected | Request cost versus the cost of a usable result |
For a hypothetical reconciliation, two distinct final receipts of 8,200,000,000 and 1,000,000,000 ticks total $0.92. A repeated copy of the first receipt is not a third request. An attempt with no final receipt cannot be assumed to cost $0, so the task total remains incomplete until it is reconciled. Preserve integer ticks while aggregating and round the displayed dollars at the end.
Before connecting an OpenAI-compatible client
Targeted integration review — October 10, 2026. A client accepting an xAI key does not prove that every model option, response item or discount is supported. Check the actual endpoint, outgoing settings and retained response—not just the client’s model dropdown.
| What you see | Documented distinction | What to check |
|---|---|---|
| A penalty or stop-setting error | The reasoning guide rejects presencePenalty, frequencyPenalty and stop for reasoning models. |
Inspect the client’s serialized request. Remove unsupported inherited controls; repeatedly sending the same payload does not diagnose an access problem. |
| Success, but no token probabilities | The model index says logprobs and top_logprobs are silently ignored by Grok 4.20 and newer. |
A missing probability is unknown, not zero. A successful request does not validate a confidence-scoring feature. |
| An export contains only answer text | Grok 4.7 Responses returns reasoning items with encrypted_content; Chat Completions has no ciphertext field. |
Confirm which endpoint the adapter uses and whether it preserves Responses items when managing a conversation locally. |
| A projected Batch discount | The Grok 4.7 model page lists Batch API as unsupported. | Do not apply another model’s Batch discount. A client queue named “batch” is not evidence of provider Batch billing. |
The parameter names above follow xAI’s reasoning documentation. SDK option names and their serialized wire names can differ; inspect the payload your particular adapter emits rather than pasting those names into an arbitrary request format.
For manually managed Responses history, preserve the returned reasoning items unchanged and send them in the next request’s input, as described in xAI’s continuation guide. Do not replace them with their printed text or treat the opaque blob as a readable explanation. Grok 4.7 returns this content even without an explicit include; clients that ignore it can still work under the documented server-side rehydration behavior. This is a history-handling check, not evidence that your client is broken or that continuity improves answer quality.
Encryption is not a retention setting. store: false controls Responses conversation storage; it is not proof of team-level Zero Data Retention. The API security FAQ separately describes default 30-day audit retention and ZDR, with its status reported in x-zero-data-retention. Check the actual team and response evidence before making a privacy claim. If an adapter hides that header, the status is unverified—not automatically active. Do not change a team’s retention policy just to fix an integration error.
Start with an existing sanitized request record: identify Responses versus Chat Completions; compare outgoing settings with the relevant model docs; then check the original response before blaming the wrapper. A local export-format check can reveal dropped fields without sending a new paid request. It cannot establish endpoint access, actual billing, retention compliance or model quality. If a later live test is needed, use non-sensitive sample content and an explicitly approved budget; keep keys, prompts and ciphertext out of public bug reports.
What changed from Grok 4.6?
The standard token prices shown for Grok 4.7 are the same as those listed for Grok 4.6, including the long-context tier. That makes switching a quality and compatibility decision more than a simple per-token discount. xAI positions 4.7 for coding, agentic tasks and knowledge work; those are provider descriptions, not an independent guarantee that it will improve every workflow.
HiseHub’s AI Model Release Tracker separates provider release facts from its independent comparison feed. Benchmark rows can differ by reasoning effort, task and measurement date. Treat them as evidence for a particular test, not a universal winner. For a practical migration, run the same representative tasks through both model IDs and compare correctness, latency, tool errors and total cost.
A short pre-purchase and pre-deployment checklist
- Choose the product route first: consumer Grok app, direct API, Cursor, or Grok Build.
- For an API integration, confirm the intended endpoint’s model list.
- Estimate full input and billed generated tokens, including history and reasoning; record the cached subset.
- Use the full prompt to choose the tier; treat the exact 200K wording discrepancy conservatively.
- Check the returned service tier; do not conflate Priority, Fast and US routing.
- Separate an advance token estimate from final provider receipts and any other account costs.
- Review existing completed-request records before increasing a workload or approving a new budget.
- If you need a consumer subscription, verify its actual entitlement in that product’s account UI.
Frequently asked questions
Is Grok 4.7 included with X Premium or SuperGrok?
An API model release does not establish which consumer plan includes that model. Check the current Grok app model picker and the plan’s own help page for your account and region. HiseHub’s AI Model Access Map tracks plan and API signals separately.
Does an xAI API key let me use Grok 4.7 Fast?
No. xAI’s current documentation lists Fast through Cursor and Grok Build and says it is not available on the public xAI API.
Does xAI charge for reasoning tokens?
Yes. Reasoning is billed at the completion-token rate. Include it when estimating billed generation, but do not add a reported reasoning subset on top of a total that already includes it. Check the usage schema for your endpoint. Grok 4.7’s documented default is high, and reasoning cannot be disabled.
Can I compare it with other models before switching?
Use the AI Model Comparison and Release Tracker as dated reference points, then test your own representative tasks. A benchmark score does not measure your tool configuration, prompt, latency target or failure cost.
Sources and update note
Targeted integration review — October 10, 2026: added rejected versus ignored parameter checks, endpoint-specific encrypted-history handling, Batch eligibility and the distinction between conversation storage and ZDR. This is a primary-document review, not a client compatibility test, new model release, price change or whole-provider re-review. The core October 6 and search-billing October 8 scopes below remain separate.
Targeted search-billing review — October 8, 2026: clarified Web Search calls versus X Search fetched posts and profiles, repeated retrievals, documented counters and original budgeting arithmetic. The core API review below remains dated October 6; this targeted addition is not a new model launch, whole-provider re-review, paid tool test or live price feed.
API documentation review — October 6, 2026: core Grok 4.7 pricing/access, cache usage, reasoning, Standard/Priority/Fast distinctions, US-route scope and per-request reconciliation were checked against primary references. Calculations and the blank record are editorial examples. No account purchase, endpoint access, billing statement, model output or comparative latency was tested. Consumer-plan entitlements remain account-specific checks; this article is a manual snapshot, not an automatic price feed or a new release announcement.
- xAI: Grok 4.7 model documentation
- xAI: API release notes
- xAI: API pricing, tools, Fast and regional rates
- xAI: Prompt caching
- xAI: Cached usage and token billing
- xAI: Regional endpoints and their scope
- xAI: Priority Processing
- xAI: Reasoning settings
- xAI: Final request costs and streaming accounting
- xAI: Model compatibility and unsupported probability fields
- xAI: Responses history and encrypted continuation items
- xAI: API retention and how to verify ZDR status
Practical takeaway: choose the route first, budget the whole prompt and billed generation, then reconcile one final cost per request. For the broader purchasing decision, see Subscription vs API; for your own workload, use the Standard API estimate and its usable-result worksheet. Those are decision aids, not a claim that we have tested your account or bill.