· 15 min · 3,500 words
Grok API Pricing 2026: Per-Model Costs
Current Grok API list prices per 1M tokens for every live model, what Grokified charges (half), how cached input and the 200K tier change a bill, and how the Grok app's subscriptions differ from API billing.
Ravi Kumar
Co-founder
Last updated: 2 October 2026. Original publish: 24 June 2026. List prices were checked against the publisher's pricing page on the update date, and the app plan prices against grok.com/plans the same day.
Short answer. As of 2 October 2026 the Grok API lists grok-4.7 at $2.00 per 1M input tokens, $0.50 cached input and $6.00 output; grok-4.3 at $1.25 / $0.20 / $2.50 (input / cached / output); and grok-build-0.1 at $1.00 / $0.20 / $2.00. Through Grokified every one of those is half: grok-4.7 is $1.00 / $0.25 / $3.00. The Grok app's SuperGrok plans ($10 to $300 a month) are a separate product with separate billing, so a subscription does not pay for API tokens.
"Grok pricing" is two searches wearing one name. One is what the Grok app subscriptions cost. The other is what the API charges per token. This guide covers both, starting with the per-model token prices, then subscription versus API, cached input, how third-party access compares, and tool, voice and image costs.
What does the Grok API cost in 2026?
Quick answer: list prices run from $1.00 to $2.00 per 1M input tokens and from $2.00 to $6.00 per 1M output tokens, depending on the model. Each model name below links to its own page. The last column is what the same request costs through Grokified, at 50% of list.
| Model | Context | Input | Cached input | Output | Long context, 200K+ (in / cached / out) | Via Grokified, under 200K (in / cached / out) |
|---|---|---|---|---|---|---|
| grok-4.7 | 500K | $2.00 | $0.50 | $6.00 | $4.00 / $1.00 / $12.00 | $1.00 / $0.25 / $3.00 |
| grok-4.6 | 500K | $2.00 | $0.50 | $6.00 | $4.00 / $1.00 / $12.00 | $1.00 / $0.25 / $3.00 |
| grok-4.5 | 500K | $2.00 | $0.30 | $6.00 | $4.00 / $0.60 / $12.00 | $1.00 / $0.15 / $3.00 |
| grok-4.3 | 1M | $1.25 | $0.20 | $2.50 | $2.50 / $0.40 / $5.00 | $0.625 / $0.10 / $1.25 |
| grok-4.20-0309-reasoning | 1M | $1.25 | $0.20 | $2.50 | $2.50 / $0.40 / $5.00 | $0.625 / $0.10 / $1.25 |
| grok-4.20-0309-non-reasoning | 1M | $1.25 | $0.20 | $2.50 | $2.50 / $0.40 / $5.00 | $0.625 / $0.10 / $1.25 |
| grok-4.20-multi-agent-0309 | 1M | $1.25 | $0.20 | $2.50 | $2.50 / $0.40 / $5.00 | $0.625 / $0.10 / $1.25 |
| grok-build-0.1 | 256K | $1.00 | $0.20 | $2.00 | $2.00 / $0.40 / $4.00 | $0.50 / $0.10 / $1.00 |
Prices are USD per 1M tokens, from the publisher's models and pricing page, checked 2 October 2026. The long-context rates apply to the whole request once its prompt reaches 200K tokens, cached tokens included. The Grokified rate is half of every column, including the 200K+ tier (grok-4.7 is $4.00 / $1.00 / $12.00 list and $2.00 / $0.50 / $6.00 on Grokified).
Three things in that table decide most bills:
- Output costs more than input. Output is 3x input on grok-4.7 and 2x on grok-4.3, so long replies drive the total more than long prompts.
- The 200K cliff. A 250,000-token prompt with no cache bills $1.00 of input on grok-4.7, twice the $0.50 it would cost at the under-200K rate, because the higher rate applies to every token in the request.
- Retired names. Older identifiers such as grok-3 and grok-4-fast stopped being listed on May 15, 2026; requests that name them redirect to a current model, so do not price from a 2025 tutorial.
How do I estimate a monthly Grok API bill?
Multiply tokens by the rate for each token type:
monthly_cost =
(input_tokens / 1_000_000) * input_rate
+ (cached_input_tokens / 1_000_000) * cached_rate
+ (output_tokens / 1_000_000) * output_rate
Worked example (not a measurement): 10M fresh input tokens and 5M output tokens a month, no caching, at the rates above.
| Model | At list price | Via Grokified |
|---|---|---|
| grok-4.7 | $50.00 | $25.00 |
| grok-4.3 | $25.00 | $12.50 |
| grok-build-0.1 | $20.00 | $10.00 |
For your own token counts, use the Grok API cost calculator.
How much does Grok 4.5 cost per million tokens?
grok-4.5 lists at $2.00 per 1M input tokens, $0.30 cached input and $6.00 output ($1.00 / $0.15 / $3.00 on Grokified), with a 500K context window. Its cached rate is lower than grok-4.7's $0.50, which makes it the cheaper pick for prompts that repeat a long prefix. See grok-4.5.
Is the Grok API cheaper than the ChatGPT API?
It depends on your token mix, so compare cost per finished task, not the headline rate. Grok's output-to-input ratio is 2x on grok-4.3 and 3x on grok-4.7, which favours output-heavy work, and Grokified halves the result. This guide does not quote OpenAI's rates, because they change often and should be read from OpenAI's own pricing page on the day you decide. Put both sets of numbers into the calculator, and see Grok 4.7 API pricing and Grok vs Claude API pricing for per-task comparisons; Grok vs ChatGPT lines Grok's rates up against OpenAI's current models with the same worked example.
Is the Grok API free?
New Grokified accounts get $5 of free credit with no card to sign up, unlocked by your first payment and then spent at the same 50% rate. Free accounts are capped at 32,000 input tokens per request. The limits and what the credit covers are in Grok API free tier.
Which model should you pay for?
Quick answer: use grok-4.3 as the cheap general default, grok-4.7 when quality matters more than cost, and grok-build-0.1 for code.
| Workload | Model | Why |
|---|---|---|
| General agents, chat, long documents (1M context) | grok-4.3 | $1.25 in, $2.50 out; the lowest rates on a 1M window |
| Hardest reasoning, flagship quality | grok-4.7 | 500K context; needs a Basic plan or above on Grokified |
| Codegen, repo tools, SWE agents | grok-build-0.1 | $1.00 in, $2.00 out, 256K context |
| Pinned snapshots for reproducibility | grok-4.20-0309-reasoning, grok-4.20-0309-non-reasoning | Same rates as grok-4.3, fixed model version |
| Long agent loops across 1M tokens | grok-4.20-multi-agent-0309 | Same rates as grok-4.3, built for orchestration |
| Repeated long prefixes | grok-4.5 | Lowest cached rate of the $2.00 models |
Pick the model first, then trim tokens: a cheaper model with a sloppy prompt can cost more than a flagship with a tight one.
Three ways to pay less than Grok list price
Prompt caching. Automatic. Input tokens that repeat the start of a recent request bill at the cached rate, 75% to 85% below the fresh rate depending on the model. It costs nothing to enable, but it only hits when your prompt prefix is stable. Details in the next section.
Batch processing. The publisher's Batch API takes 20% off the standard rate on grok-4.3 and the three grok-4.20 models, and nothing off the others, as of 2 October 2026. Results arrive within about 24 hours on a best-effort basis, so it suits evaluations and overnight jobs, not chat. Grokified does not currently offer batch jobs.
Prepaid third-party access. 50% off all usage, on every request, for the life of the account. It applies to every account automatically. No seat, no code, no claim step. Grokified is an OpenAI-compatible API, so the change is one base URL. The comparison below shows the alternatives.
How cached input pricing works on Grok
Quick answer: a request is billed at the cached rate for the part of its prompt that exactly matches the start of a recent request. On grok-4.7 that is $0.50 per 1M tokens instead of $2.00, a 75% cut on those tokens.
Caching is not a setting. It is a property of how your prompt overlaps a previous one. The match starts at the first message and stops at the first difference, so a stable system prompt and tool schema at the front of every call become cache hits, while a changed first line, a reordered tool list or a timestamp near the top breaks the match from that point on. Fresh content, such as the newest user turn, never gets the discount because it was never sent before. Setting a routing key (a conversation id) helps requests reach the same cache. The setup and the reasons a cache reads zero are in Grok prompt caching: why cached_tokens is 0.
Worked example (not a measurement): a 10,000-token prompt on grok-4.7, of which 8,000 tokens are a repeated prefix and 2,000 are new, with 500 output tokens.
| Per 1,000 requests | No cache hit | With the prefix cached | Saving |
|---|---|---|---|
| At list price | $23.00 | $11.00 | 52% |
| Via Grokified | $11.50 | $5.50 | 52% |
The first request in a conversation has nothing to match, so it bills at the fresh rate. Cached tokens also count toward the 200K threshold, so a long cached prompt can still land on the higher tier. Check usage.prompt_tokens_details.cached_tokens in the response to see what you actually got.
Grok subscription vs API: which price do you mean?
Quick answer: the Grok app (grok.com and its mobile apps) sells flat monthly subscriptions for chatting. The API sells per-token usage for code. They are billed separately, and a subscription does not include API tokens.
As of 2 October 2026 the Grok app's plans, from grok.com/plans, are:
| Grok app plan | Per month | Per year | What it adds |
|---|---|---|---|
| SuperGrok Lite | $10 | $100 | Longer chats, Expert mode, basic image and video creation |
| SuperGrok | $30 | $300 | Higher limits, HD image and video, longer voice chats, coding tools |
| SuperGrok Plus | $100 | $1,000 | Much higher usage, 1080p video, priority at peak times |
| SuperGrok Heavy | $300 | $3,000 | Highest usage, a larger team of agents, X Premium+ included |
How much is Grok per month?
From $10 for the app's entry plan to $300 for the top one, as the table shows. Those prices buy chat, image, video and voice features inside the Grok app, with usage limits rather than a token meter.
Does a Grok subscription include API access?
No. The publisher's accounts FAQ says the account is shared but the billing is separate: manage app billing on grok.com and API billing in the xAI console (accounts FAQ). Budgeting a production app on a $30 SuperGrok plan mixes up the two products.
Which should you pay for?
If you want to talk to Grok yourself, buy the app plan. If your code calls a model, pay per token. Worked example (not a measurement): $30 of API usage at list price covers more than the 10M-input, 5M-output month priced above on grok-4.3 ($25), and it costs nothing in a month you do not use it. Through Grokified the same grok-4.3 month costs $12.50.
Is a Grokified plan a Grok subscription?
No. Grokified plans are API credit, not a chat subscription. Basic is $4.99 a month for $7.49 of credit, Pro is $9.99 for $19.99, and Max is $49.99 for $120.00; each comes in a larger size too. The credit then spends at 50% of list, so $9.99 on Pro buys about $39.98 of list-price usage (a worked example from the plan numbers). grok-4.7 needs Basic or above.
Does $10 a month on Grokified get me the same web interface as Grok?
No. A Grokified plan gives you an API key and a browser playground for chat, images and video, plus the credit to spend on any OpenAI-compatible tool. It does not unlock grok.com or the Grok app, or the app's subscription features. If you only want a chat window on Grok, the app plan is the right product. If you want to call Grok from code, an editor or an agent, API credit is.
How third-party Grok access compares
Third-party access means paying someone other than the publisher for Grok API calls. The two relevant models are a discount on list price and a pass-through with a fee. Facts about OpenRouter are from its pricing page, as of 2 October 2026.
| Grokified | OpenRouter (Standard) | |
|---|---|---|
| Grok token price | 50% of list on every request (grok-4.7 input $1.00 per 1M) | The provider's list price on every plan (grok-4.7 input $2.00 at list) |
| Fee | No platform fee is listed. Minimum top-up $5 | 5.5% charged when you buy credits (8% on Business). No minimum spend or lock-in |
| Models | Grok text, image, video and voice models only | 500+ models from 80+ providers behind one key |
| Free option | $5 credit at signup, unlocked by a first payment, no card to sign up | Free plan with 25+ free models, 50 requests a day |
| API shape | OpenAI-compatible | OpenAI-compatible |
Worked example (not a measurement): $100 of list-price Grok usage costs about $105.50 on OpenRouter Standard if the 5.5% fee is added to a $100 credit purchase, and $50 on Grokified. OpenRouter wins when you want one key across many providers, with no Grok-only lock-in. Grokified wins when the workload is Grok and the bill is what matters. Other resellers exist; the checklist below applies to any of them.
What to check before buying Grok access from a reseller
- The discount on your actual bill. Ask whether it applies to cached input, the 200K+ tier and tool fees, or only to the headline input rate. On Grokified it applies to everything billed.
- Refund terms. Grokified refunds unused prepaid credit within 30 days of the top-up; consumed usage and bonus credit are not refundable (refund policy).
- Data handling. Read the privacy policy and whether the Grok API trains on your data.
- A status page. Grokified's is at /status.
- A spend ceiling. A prepaid balance caps the worst case if an agent loops.
- Gaps. Grokified does not offer batch jobs, and it serves Grok models only.
- Who operates it. Grokified is operated by DEEPORAX AI LTD, UK company 17293947, and is independent of xAI.
Tool calls, voice and images are billed separately
Server-side tools add a fee per call on top of tokens. As of 2 October 2026 the publisher lists web search and code execution at $5 per 1,000 calls, and X search at $5 per 1,000 posts and $10 per 1,000 profiles; the Grokified rate is $2.50 and $5.00 for the same units. The full list and how to read a tool bill are in Grok API tool pricing.
Voice and media use their own meters. Realtime voice lists at $0.08 per minute plus $0.004 per text message, text-to-speech at $15.00 per 1M characters, and speech-to-text at $0.10 per hour. See Grok Voice API pricing and the Grok Imagine API for image and video. Keep text, voice and media as separate lines in a budget.
Check your own numbers
Use the Grok API cost calculator with your token counts, then test with the free credit in Grok API free tier. To call Grokified, change the base URL of any OpenAI SDK. Prepaid and free accounts can call every model except grok-4.7, so this example uses grok-4.3:
from openai import OpenAI
import os
client = OpenAI(
api_key=os.environ["GROKIFIED_API_KEY"], # gk_live_ key
base_url="https://api.grokified.cyou/v1",
)
completion = client.chat.completions.create(
model="grok-4.3",
messages=[{"role": "user", "content": "Summarize Grok API pricing in 3 bullets."}],
)
print(completion.usage) # prompt_tokens_details.cached_tokens shows cache hits
Need a key first? See how to get a Grok API key. For more ways to cut a bill, read how to reduce LLM API costs.
Editorial methodology and disclosures
List prices come from the publisher's models and pricing page and plan prices from grok.com/plans, both checked on 2 October 2026. The model table is generated from Grokified's own model catalog, so it moves with the catalog rather than being retyped. OpenRouter figures come from its pricing page on the same date. Worked examples use published rates and stated token counts; they are not measurements and not guarantees of your results.
Disclosure: Grokified is an independent product, not affiliated with xAI, that powers developer IDEs and AI agents, with 50% off list on every request for the life of the account. We show list-price maths so you can compare fairly. DEEPORAX AI LTD, UK company 17293947, operates Grokified. We revisit this guide after model launches, retirements and price changes.
References
Official
- Models and pricing: https://docs.x.ai/developers/models
- Prompt caching: https://docs.x.ai/developers/advanced-api-usage/prompt-caching/how-it-works
- Batch API: https://docs.x.ai/developers/advanced-api-usage/batch-api
- Account and billing FAQ: https://docs.x.ai/console/faq/accounts
- Grok app plans: https://grok.com/plans
Third party
- OpenRouter pricing: https://openrouter.ai/pricing
Grokified
- Pricing and signup: https://grokified.cyou/pricing
- Economics of discounted LLM API access: https://grokified.cyou/blog/economics-of-reselling-llm-capacity
FAQ
Q: How much does the Grok API cost per token in 2026?
Quick answer: Grok 4.3 is $1.25 per million input tokens and $2.50 per million output tokens as of October 2026.
Detailed explanation: Cached input on eligible prefixes bills at $0.20/M. Grok Build 0.1 is $1.00/M in and $2.00/M out. Voice and Imagine use separate meters. See the tables in the "What does the Grok API cost" section and xAI Docs for authoritative numbers.
Q: Is Grok API cheaper than OpenAI?
Quick answer: It depends on your traffic shape; Grok is often competitive on output-heavy workloads because output is only 2x input.
Detailed explanation: Compare your measured input/output ratio and cache eligibility against your current vendor's list or contract rates. TokenRate (2026) explains the 2x multiplier advantage. Enterprise discounts may change the winner.
Q: What happened to Grok 3 and Grok 4 Fast pricing?
Quick answer: xAI retired several legacy slugs on May 15, 2026; they redirect to current models priced like Grok 4.3.
Detailed explanation: AI Cost Check (2026) documents the retirement. Update configs and cost models that still reference old identifiers.
Q: What is the cheapest Grok model for coding?
Quick answer: Grok Build 0.1 at $1/$2 per million tokens with a 256K context window.
Detailed explanation: Use Grok 4.3 when you need 1M context or general reasoning on non-code tasks. See the model selection table above.
Q: Does Grok charge for prompt caching?
Quick answer: Cached input is billed at $0.20/M, not the full input rate, when prefixes qualify.
Detailed explanation: Architecture matters more than checkout. Stable system prompts and tool schemas improve hit rate. Measure cached tokens in usage logs.
Q: How do I estimate my monthly Grok API bill?
Quick answer: Sum input, cached input, and output using the formula in this guide.
Detailed explanation: Export a week of staging traffic, apply rates from the current table, multiply by 4.3 for a conservative monthly forecast, then add headroom.
Q: Can I use the OpenAI Python SDK with Grok?
Quick answer: Yes. xAI exposes an OpenAI-compatible HTTPS API at https://api.x.ai/v1.
Detailed explanation: Change base_url and model. Grokified uses the same pattern with a different endpoint and access key.
Q: What is Grok 4.20 Multi-Agent pricing?
Quick answer: Same $1.25/$2.50 text rates with a 1M context window on the Multi-Agent variant listed in xAI Docs (2026).
Detailed explanation: Choose it when agent orchestration genuinely needs longer context, not by default.
Q: Are Grok consumer plans the same as API pricing?
Quick answer: No. SuperGrok subscriptions are consumer products with different limits than token-metered API usage.
Detailed explanation: Budget production separately from personal chat subscriptions.
Q: How fast do Grok API prices change?
Quick answer: Major changes correlate with model launches or slug retirements; xAI announced May 2026 retirements explicitly.
Detailed explanation: Pin model versions for reproducibility and subscribe to xAI developer announcements.
Q: What rate limits apply to Grok API?
Quick answer: xAI publishes tier documentation separately from the models pricing page; limits vary by account tier.
Detailed explanation: Test canary traffic before full cutover. Rate-limit errors affect cost per successful request.
Q: How does Grokified pricing relate to list?
Quick answer: Grokified bills prepaid credit at 50% off list on every request, for the life of the account.
Detailed explanation: 50% off all usage, on every request, for the life of the account. It applies to every account automatically. No seat, no code, no claim step. See the economics post for how that rate stays sustainable. Billing is on Grokified prepaid credit.
Q: Should I use direct xAI or Grokified?
Quick answer: Direct xAI is simplest for compliance-minimal tests; Grokified adds a signup credit, unified billing for your IDE or agents, and Grok model access.
Detailed explanation: Validate compatibility on streaming, tools, and error shapes before migrating production.
Q: How do I debug a sudden Grok bill spike?
Quick answer: Sort requests by output tokens and check for runaway agent loops or missing max_tokens caps.
Detailed explanation: Compare p95 completion length week-over-week. Spikes often trace to prompt changes, not rate changes.
Q: Where can I get a Grok API key?
Quick answer: Create one in the xAI console or sign up for a Grokified access key if you want prepaid credit at 50% off list.
Detailed explanation: Store keys in a secrets manager and rotate on engineer offboarding.