Grok 4.7 costs $2 per million input tokens, $0.50 per million cached input tokens, and $6 per million output tokens on the public xAI API, for prompts under 200,000 tokens. Those three numbers, and the long-context row of $4 / $1 / $12, match Grok 4.6 on the API pricing page checked September 22, 2026. The list price did not move. The bill still does.
On the same launch page, xAI's CursorBench 4.0 chart prices one Grok 4.7 task at $1.58 on Low and $6.01 on Extra High. That is a 3.8× swing with no change to the token card. A Cursor Ultra user running one task at extra high, with fast mode off, put the practical version in one sentence: "Grok 4.7 is about 2.5 times as expensive as 4.6." (r/cursor, September 21, 2026). Later, Tabbit is one place to try a route after the budget is clear. First, the card.
Key takeaways
The sticker matches Grok 4.6. Short context is $2 / $0.50 / $6 per million tokens. At 200,000 input tokens the whole request reprices to $4 / $1 / $12.
Effort is the number that moves. xAI's CursorBench points show $1.58, $3.49, $4.69, and $6.01 per task from Low to Extra High. Default reasoning effort on the API is high.
Fast is a second card, not a slogan. Printed Fast rates are $4 / $1 / $12 below 200k and $6 / $1.50 / $18 above it. Fast is Cursor and Grok Build only, and it is off the public API.
Cursor's cliff is 256k, not 200k. Cursor's model page doubles standard on-demand rates after 256,000 input tokens and prices 500k Fast at $6 / $1.50 / $18. Cache writes are a dash, not a separate fee.
There is no Batch discount on grok-4.7. The model page says Batch API is not supported. Tool calls, the US endpoint's 10%, and a $0.05 pre-generation violation fee sit outside the headline rates.
Grok 4.7 pricing at a glance
Rates below are US dollars per million tokens from xAI's pricing page, captured September 22, 2026. The Grok 4.6 overview covers the previous model. This table is only the money.
| Model | Context | Short input | Short cached | Short output | Long input | Long cached | Long output | Long-context threshold |
|---|---|---|---|---|---|---|---|---|
| grok-4.7 | 500k | $2.00 | $0.50 | $6.00 | $4.00 | $1.00 | $12.00 | ≥ 200k tokens |
| grok-4.6 | 500k | $2.00 | $0.50 | $6.00 | $4.00 | $1.00 | $12.00 | ≥ 200k tokens |
| grok-4.5 | 500k | $2.00 | $0.30 | $6.00 | $4.00 | $0.60 | $12.00 | ≥ 200k tokens |
| grok-build-0.1 | 256k | $1.00 | $0.20 | $2.00 | $2.00 | $0.40 | $4.00 | ≥ 200k tokens |
Four short-context numbers on grok-4.7 are identical to grok-4.6. The page states the rule that makes the second row matter: models with long-context pricing bill the long-context rates for all tokens in a request once the prompt reaches the threshold. Crossing 200,000 does not reprice only the overflow.
The model detail page repeats the short-context card — input $2.00, cached $0.50, output $6.00 — and a switch labeled "Higher context pricing" replaces those figures with $4.00, $1.00, and $12.00. Context window is 500,000. Reasoning efforts are low, medium, high, and xhigh, with high as the default. Batch API is marked not supported. The checked region was us-east-1, with 150 requests per second and 50,000,000 tokens per minute on that page.
The one number: $1.58 to $6.01 per task
If you keep one figure, keep the spread, not the $2. The Grok 4.7 launch post says the model is "priced starting at $2 per million input tokens and $6 per million output tokens" and that a fast variant has "twice the output speed at twice the price." The same page's CursorBench 4.0 cost view, read from the chart controls on September 22, 2026, is:
| Grok 4.7 effort | CursorBench 4.0 score | Average cost per task |
|---|---|---|
| Extra High | 46.3% | $6.01 |
| High | 43.9% | $4.69 |
| Medium | 41.6% | $3.49 |
| Low | 33.1% | $1.58 |
Extra High costs 3.8× Low for 13.2 percentage points of score on this vendor chart. Sample size, harness, and which tokens make up the dollar figure are not printed on those controls. These are xAI's reported task costs, not an invoice from the API console, and they are not comparable to a raw million-token rate.
That is also why a flat "same price as 4.6" can still feel expensive. Default effort is high. High is already $4.69 on this chart, against $1.58 at Low. The agentic reasoning guide is the right place for when a loop should stop; the pricing lesson is narrower: set the budget per finished task, including the effort you actually leave on.
What "2.5 times as expensive" measured
Dynamix86 kept one task running for two days on Cursor Ultra, switched from Grok 4.6 to Grok 4.7 at 22:00 Central European Time, and timed how long each percentage point of plan usage lasted. Both runs were extra high and not on fast mode. The 4.7 slices were 34, 55, and 38 minutes per point. The earlier 4.6 slices that day were 133 and 101 minutes. From that, the author estimated about 2.5×. The post also reads an Artificial Analysis chart as $8.82 versus $3.53 per task. Treat those two dollar figures as the author's reading of a screenshot. This article did not re-measure that chart, and a Cursor quota percent is not an xAI API line item.
Two replies stay on the cost question:
Vegetable-Piano-5313 wrote, "so using standard grok 4.7 pretty much equals grok 4.6 in fast mode cost-wise i think." Dynamix86 answered, "25% more expensive than 4.6 fast mode even." Neither comment publishes the token log. They are a warning about plan burn, not a second rate card.
"Yep what an awful model release. Obviously benchmarks mean nothing anymore but the cost is clearly too high." That sentence is the sticker-shock reading. It does not name effort, fast mode, or token counts. The launch chart above is the part that can be checked without taking the comment's conclusion as a fact.
The lines that are not the headline $2
The 200k cliff applies to the whole request. A 199,000-token prompt stays on $2 / $0.50 / $6. A 200,000-token prompt moves every token, including output, to $4 / $1 / $12. There is no "only the excess" line on the pricing page.
Fast's printed long-context row is not double the long-context standard row. The pricing page says Grok 4.7 Fast is the same model on faster infrastructure, "at twice the standard token rates," only in Cursor and Grok Build, not on the public API, and not in Grok Build's free quota. The table under that sentence is:
| Prompt size | Fast input | Fast cached input | Fast output |
|---|---|---|---|
| Below 200k | $4.00 | $1.00 | $12.00 |
| Above 200k | $6.00 | $1.50 | $18.00 |
Below 200k, $4 / $1 / $12 is exactly 2× the short-context card. Above 200k, 2× the long-context card would be $8 / $2 / $24. The printed row is $6 / $1.50 / $18, which is 1.5× the long-context standard rates and 3× the short-context standard rates. Budget the printed row. Do not multiply the long-context standard row by two and call it Fast.
Cursor uses 256k, and Fast is the default speed on Pro and above. Cursor's Grok 4.7 docs, opened September 22, 2026, put standard on-demand usage at $2 input, $0.50 cached input, and $6 output per million. Fast is $4 / $1 / $12. After 256,000 input tokens, standard requests are 2× those standard rates and Fast requests are 3×, up to 500k. The table rows are Grok 4.7 at $2 / — / $0.50 / $6, Fast at $4 / — / $1 / $12, 500k at $4 / — / $1 / $12, and 500k Fast at $6 / — / $1.50 / $18. The cache-write column is a dash. Cursor also says Fast is the default speed tier on Pro and higher plans, while the Start plan (India only) locks Grok 4.7 to medium effort and standard speed. A 220,000-token prompt can be long-context on the xAI API and still standard inside Cursor.
Batch is not the discount lever. The pricing page gives a 20% batch discount to grok-4.3 and the grok-4.20 variants only, and says models not listed have no batch discount. grok-4.7's own page says Batch API is not supported. Waiting overnight does not halve this model.
Tools are a second meter. Requests that use xAI server-side tools pay tokens plus invocations. Web search (web_search) and code execution are $5 per 1,000 calls. Collections search is $2.50 per 1,000. File attachments (attachment_search) are $10 per 1,000. Starting September 21, 2026 at 12:00 PM PT, X Search is $5 per 1,000 posts fetched and $10 per 1,000 user profiles fetched, replacing $5 per 1,000 calls. view_image, view_x_video, and remote MCP tools have no invocation fee; they bill tokens. Image search is part of web search.
The US endpoint is 1.1×. Requests to https://us.api.x.ai/v1 are billed at 1.1× global token rates. For grok-4.7 the pricing page prints $2.20 / $0.55 / $6.60 below 200k and $4.40 / $1.10 / $13.20 above. Caching is applied before the multiplier. The page says this endpoint currently covers grok-4.7 and grok-4.6.
Priority processing is another 2×, and only when the response says so. Priority is billed at 2× standard rates on input, output, cached, and reasoning tokens, with caching applied before the multiplier. You pay the priority rate only when the response confirms "service_tier": "priority". It is not available for Batch, and Fast is a separate product from this API flag.
The family ladder, and the row that is actually cheaper
The counterintuitive row is not a new Grok 4.7 discount. Grok 4.5's cached input is $0.30, against $0.50 on 4.6 and 4.7, with the same $2 input and $6 output below 200k. If your loop is cache-heavy and 4.5 is good enough, the newer card is a cache-read increase, not a cut. grok-build-0.1 is half of 4.7 on every short-context number ($1 / $0.20 / $2) and its context window is 256k, not 500k. It is a different model id, not a reasoning tier of 4.7.
The other counterintuitive point is effort. Extra High does not have its own input price. It spends more of the same $6 output tokens. Cursor's docs say the gaps between xhigh, high, medium, and low are wider than on Grok 4.6, and that harder tasks think longer. Leaving the default on high is a purchasing decision.
What you still pay when the model refuses
A refusal is not a free line on this card.
If the system catches a usage-guideline violation before generation on the Responses API, xAI charges $0.05 per request.
If the request is judged in violation and generation still ran, you are charged for that generation as well.
Cached input is a discount ($0.50 instead of $2.00 below 200k). The text rate card has no separate cache-write price. Cursor's write column is a dash. Uncached input is the full input rate.
Retries and failed attempts that produced tokens are still token usage. The rate card does not waive them.
A Grok chat subscription, a Cursor plan allowance, and an API invoice are three different objects. This article does not convert a consumer plan's monthly price into API dollars; that subscription price was not re-checked as a live checkout figure on September 22, 2026.
One Hacker News comment quotes a page claiming Grok 4.7 (xhigh) is "$0.00 per 1M input tokens" and "$0.00 per 1M output tokens," then says the domain name is "appropriately descriptive." A zero on a third-party widget is not a price cut. The API card above is the one to budget.
Where the model actually runs
The Grok 4.7 docs list the public API (grok-4.7), the US regional endpoint, Grok Build as the default coding-agent model, Cursor on all plans, and the gateways OpenRouter, Vercel, and Cloudflare. Gateway list prices were not re-audited for this article; a search snippet that does not match $2 / $6 is not a reason to abandon the official card.
Cursor's pool for personal and team plans includes Grok 4.7, Grok 4.6, Grok 4.5, and Composer 2.5. That pool is an allowance, not a prepaid stack of API tokens. Fast as the default on Pro and above means a plan can burn at the Fast row without a separate opt-in on every turn.
Grok Build's free tier does not include Fast. The launch post also says you can try Grok Build at x.ai/build. "Try for free" on that page is not a statement that grok-4.7 API tokens are free.
Two worked API budgets
These use the xAI card only: no tools, no US 10%, no priority flag, no retries. They are arithmetic, not a forecast.
A short answer at the default card, under the cliff. 10,000 uncached input tokens and 2,000 output tokens:
(10,000 × $2 + 2,000 × $6) / 1,000,000 = $0.032The same shape on printed short-context Fast is $0.064. Output is 3× the input rate, so a long think dominates even when the prompt is small.
A cold agent prompt that crosses 200k. 250,000 uncached input tokens and 8,000 output tokens. Long-context rates apply to everything:
(250,000 × $4 + 8,000 × $12) / 1,000,000 = $1.096The same token counts priced as if they were still short-context would be $0.548. The cliff is the difference. At 90% cached input, still on the long-context row:
(25,000 × $4 + 225,000 × $1 + 8,000 × $12) / 1,000,000 = $0.421Printed Fast above 200k, cold, is (250,000 × $6 + 8,000 × $18) / 1,000,000 = $1.644. Doubling the long-context standard row instead would invent $2.192. Use $1.644.
Local calculation
Estimate a monthly API bill
Official xAI rates checked September 22, 2026. Output is priced once and is meant to include reasoning tokens. Nothing you type leaves this page.
Prompts of 200,000 input tokens or more use that model's long-context row for every token. Fast uses the printed Fast table, which is not a flat 2× of the long-context row. Excludes tool calls, the US 10% endpoint, priority processing, retries, and Cursor's separate 256k threshold. Verify the rate card
The calculator stays in the browser. It switches the whole request to long-context rates at 200,000 input tokens, and the Fast option uses the printed Fast table for grok-4.7 only. grok-4.6 and grok-4.5 stay on their standard rows so the cache gap on 4.5 remains visible. It does not model tool fees, the US 10%, priority, retries, or Cursor's 256k threshold. Re-open the official pricing page before you lock a budget.
After the rate card, a place to run the model
Knowing the card does not attach the model to the pages and files you already have open. Tabbit Browser is the client for that step: the model picker, the live page, and local files sit on one surface, so comparing a route is a selection rather than a new billing integration.
The boundary is the point of this section. Tabbit does not replace the xAI invoice, and it does not change Cursor's 256k rule. The Grok 4.7 model page lists the model and says availability in Tabbit depends on the account's live picker. The prompt notes and review notes are the source trail for how the API is called and how public benchmarks were read. They are not a measured Tabbit bill. This article did not run a timed Tabbit task, so it does not claim a Tabbit cost, latency, or success rate.
Tabbit BrowserIf the work is the browser session itself, start with the AI browser guide, the agentic browser overview, what an agentic browser is, and the browser automation guide. The 2026 browser comparison and the Tabbit usage notes cover the client choice separately from the token card.
Which bill you are actually choosing
| Workload | What dominates the bill | Start here | Watch |
|---|---|---|---|
| Short API calls | Output tokens at $6 / 1M | grok-4.7, low or medium effort | Default effort is high |
| Repeated prompts under 200k | Cached reads at $0.50 | Standard API with a stable cache key | 4.5 cached reads are $0.30 if quality allows |
| Prompts at or above 200k on the API | The whole-request cliff | Restructure, or budget $4 / $12 | Not "only the overflow" |
| The same prompt inside Cursor | Cursor's 256k line and Fast default | Standard speed unless latency requires Fast | Pro and above default to Fast |
| Latency over cost | Printed Fast card | Cursor or Grok Build Fast | Not on the public API; no Grok Build free quota |
| Tool-heavy agents | $5 / 1k calls plus tokens | Cap search and code execution | X Search billing changed September 21, 2026 |
Final verdict
Buy Grok 4.7 when the task is long enough that the extra effort earns its tokens, and buy the effort and the surface on purpose. The API card is still the Grok 4.6 card. Low effort on that chart is $1.58 a task; Extra High is $6.01. Keep prompts under 200,000 tokens on the API unless you have priced $4 / $12 for the entire request. Treat Fast as the printed $4 / $1 / $12 and $6 / $1.50 / $18 table, and remember Cursor flips at 256,000, not 200,000. Use grok-4.5 or grok-build-0.1 when the cheaper cache or the half-price row is enough. Do not wait for a Batch discount that the model page says does not exist.
The overview, review, and alternatives articles for this model are not published yet. Until they are, the Grok 4.6 article, the model notes, and the official pages below are the trail. Recheck the rate card before a monthly commit; the X Search change on this same pricing page is dated September 21, 2026.
Sources
xAI API pricing — text rates, Fast table, tools, batch list, US endpoint, priority, violation fee; checked September 22, 2026
grok-4.7 model page — $2 / $0.50 / $6, higher-context switch, Batch not supported, default effort high
Grok 4.7 docs — model id, Fast availability, US 10%, where it runs; last updated September 21, 2026
Introducing Grok 4.7 — starting price, fast-variant sentence, CursorBench cost points
Cursor Grok 4.7 docs — 256k threshold, Fast default, rate rows; opened September 22, 2026
Community records, with conditions in the captions: r/cursor 1wmswj9, HN 49789558
FAQ
How much does Grok 4.7 cost?
On the xAI API, checked September 22, 2026, grok-4.7 is $2 per million input tokens, $0.50 per million cached input tokens, and $6 per million output tokens when the prompt is under 200,000 tokens. At or above that threshold the whole request moves to $4, $1, and $12. The public API model id is grok-4.7.
Is Grok 4.7 the same price as Grok 4.6?
The short-context and long-context API rows match Grok 4.6: $2/$0.50/$6 below 200,000 input tokens and $4/$1/$12 at or above it. That is the list price. xAI's own CursorBench chart still shows Grok 4.7 Extra High at $6.01 per task and Low at $1.58, so effort changes the bill without changing the card. A Cursor Ultra user timing one task also reported about 2.5 times the quota burn versus Grok 4.6 at extra high, with fast mode off.
What is the Grok 4.7 long-context price?
On the xAI API, once a prompt reaches 200,000 tokens, every token in that request is billed at $4 input, $1 cached input, and $12 output per million. Cursor documents a different threshold: standard on-demand usage doubles only after 256,000 input tokens, up to a 500,000 context window. Do not mix the two cliffs.
How much does Grok 4.7 Fast cost?
xAI's pricing page lists Fast, available only in Cursor and Grok Build, at $4/$1/$12 per million below 200,000 prompt tokens and $6/$1.50/$18 at or above that line. The prose also says twice the standard token rates. The printed long-context Fast row is 1.5 times the long-context standard row, not double it. Fast is not on the public xAI API and is excluded from Grok Build's free quota.
Does the Batch API discount Grok 4.7?
No. The grok-4.7 model page lists Batch API as not supported. The pricing page gives a 20% batch discount only to older models such as grok-4.3 and the grok-4.20 variants, and says models not on that list have no batch discount.
Do tool calls and refusals cost extra?
Server-side tools are billed on top of tokens. Web search and code execution are $5 per 1,000 calls. From September 21, 2026 at 12:00 PM PT, X Search is $5 per 1,000 posts fetched and $10 per 1,000 user profiles fetched. A request caught as a usage-guideline violation before generation is charged $0.05. A generation that completes and then violates is still billed for the tokens.