TL;DR
- Grok 4.7 (
grok-4.7) on HiAPI is billed per token: $0.84 input and $2.52 output per million tokens — 42% of the official price ($2.00/$6.00), a 58% discount. - A 2K-in / 1K-out request costs about $0.0042; $10 runs roughly 1,190 medium requests.
- It's live on HiAPI — open the model page to try it, and new signups get 200 free credits.
Grok 4.7 API price table
| Tier | Item | HiAPI | Official | You save |
|---|---|---|---|---|
| Standard (prompt <200K) | Input | $0.84 | $2.00 | 58% |
| Standard | Output | $2.52 | $6.00 | 58% |
| Standard | Cached read | $0.21 | $0.50 | 58% |
| Long-context (prompt ≥200K) | Input | $1.68 | $4.00 | 58% |
| Long-context | Output | $5.04 | $12.00 | 58% |
| Long-context | Cached read | $0.42 | $1.00 | 58% |
HiAPI rates, verified October 28, 2026. All figures per million tokens.
The billing rule in one line: input tokens × input rate + output tokens × output rate, and reasoning tokens bill as output. The long-context tier applies to the whole request once input reaches 200K tokens. Context window is 500K tokens, with four reasoning efforts (low / medium / high / xhigh, default high) over an OpenAI-compatible Chat Completions API.
What your usage actually costs
One request. 2K input + 1K output ≈ 0.002 × $0.84 + 0.001 × $2.52 ≈ $0.0042. The same request at official pricing is $0.010 — 2.4× more.
What $10 buys. At a medium request — 1K input + 3K output (~$0.0084 each), $10 covers roughly 1,190 requests. The same $10 at official pricing covers about 500.
Monthly budgets.
| Usage | Per request | Monthly (30 days) |
|---|---|---|
| 10 medium requests/day | $0.0084 | ~$2.5 |
| 100 medium requests/day | $0.0084 | ~$25 |
| 1,000 medium requests/day | $0.0084 | ~$250 |
One third-party number worth knowing for agent workloads: traictory.com (September 22, 2026) reports grok-4.7 output of roughly 81K tokens per task, about 2× grok-4.6, putting its real per-task cost near 2× as well. Per-token rates are identical — budget per task, not per token.
Real tasks, real costs (measured on HiAPI production). The same batch of live calls, billed at HiAPI rates:
| Task | Input tok | Output tok | Cost |
|---|---|---|---|
| Debug a stuck concurrent crawler, with fix | 3,572 | 7,301 | $0.021 |
| Code review with strict JSON output | 3,576 | 2,734 | $0.010 |
| pandas data analysis | 3,440 | 1,427 | $0.007 |
A full-context debugging session runs about two cents; a code review about one. All nine test calls together cost roughly $0.092 — the balance drain is visible to the cent.
How to spend less
- Cache your system prompt. Cached reads cost $0.21, a quarter of the input price. Put fixed instructions and background context up front; 100 requests with a 30K cached prefix cost ~$0.63 instead of $2.52.
- Set reasoning effort explicitly. Four tiers default to high. Drop to low or medium for simple tasks and output tokens shrink immediately. See the Grok 4.7 API guide for the parameter details.
- Cap max_tokens. A hard ceiling on output keeps long reasoning runs from blowing past budget; combined with effort control, per-request cost stays predictable.
Same series: grok-4.6 costs exactly the same
grok-4.6 sells at identical rates ($0.84/$2.52, long-context $1.68/$5.04) and remains on sale. The difference is capability: 4.7 is the vendor's current default recommendation, with an official-reported Terminal-Bench 4.0 score of 38.0% versus 20.3% for 4.6, while third-party data puts its per-task token burn at roughly 2×. For simple tasks, or when you want a steadier token budget, fall back to grok-4.6. For complex coding and agentic work, 4.7 earns its keep at the same rate. Full breakdown in Grok 4.7 vs Grok 4.6.
Competitor comparison
| Model | Input $/M | Output $/M | Context |
|---|---|---|---|
| grok-4.7 | $0.84 | $2.52 | 500K |
| grok-4.6 | $0.84 | $2.52 | 500K |
| gpt-6.1-sol | $0.50 | $2.50 | 1.05M |
| claude-opus-5-5 | $2.02 | $10.08 | 1M |
HiAPI rates, verified October 2026.
In this tier, gpt-6.1-sol is cheaper on input and claude-opus-5-5 is far pricier. If you want a 500K context window with four reasoning efforts at this price, 4.7 is the pick.
FAQ
How much does the Grok 4.7 API cost? $0.84 input and $2.52 output per million tokens (standard tier) — 42% of official on HiAPI.
How much cheaper is it than official? 58% across every tier, standard and long-context alike.
How is billing handled above 200K input tokens? The entire request bills at the long-context tier: $1.68 input, $5.04 output, $0.42 cached read per million tokens.
Can I reduce reasoning cost? Yes. Pick low or medium effort explicitly to cut output tokens, and stack a max_tokens cap on top. Prompt patterns are in Grok 4.7 Prompt Recipes.
Run your own numbers now: estimate daily requests and per-request input/output tokens, find your row in the monthly budget table above, then open the Grok 4.7 model page and send a real request — new signups get 200 free credits, so your first test costs nearly nothing.
