Major

Grok Pricing 2026: Plans, API Rates and Free Credits

Grok price plans, per-model API rates, how X API spend earns xAI credits, and the 200k context cliff that reprices a whole request. Plus how Major keeps recurring agent spend flat.

Jason BaoUpdated
Person at a wooden desk reviewing usage stats on a laptop, representing Grok API cost tracking

How much does Grok cost in 2026?

Grok is priced two ways. Consumer plans (a free tier, paid SuperGrok plans, and Team or Enterprise quotes from xAI) buy access to the app. The API is billed per token, with separate input, cached-input and output rates for every model, and there is no general free API tier. A subscription includes no API credit, so anyone building on Grok budgets from the API rate card.

The rate card is the easy part. What you pay for a recurring agent depends on how many times it repeats the same reasoning and whether its prompt crosses the 200k-token threshold. Major is the enterprise platform where agents build the software they run on, so the repeatable part of an agent's work becomes a deterministic app instead of a billed model call. That is the lever the Grok price plans do not show you, and it is covered in the Major section below. API figures here were checked against xAI's documentation on November 6, 2026. Confirm them before you budget.

Grok API pricing by model

Rates are per million tokens, listed as input, cached input, output, for prompts under 200k tokens.

  • grok-4.7 and grok-4.6: $2.00 input, $0.50 cached, $6.00 output.
  • grok-4.5: $2.00 input, $0.30 cached, $6.00 output.
  • grok-4.3 and the grok-4.20 variants: $1.25 input, $0.20 cached, $2.50 output.
  • grok-build-0.1: $1.00 input, $0.20 cached, $2.00 output.

Live numbers sit at docs.x.ai/developers/pricing. xAI changes its lineup often, and older roundups still quote models it no longer leads with.

Three modifiers move the effective rate. The Batch API takes a discount on eligible models. Priority processing bills at a multiplier. Server-side tools such as Web Search, X Search and Code Execution bill per call on top of tokens. Check the pricing page for the current figures on each.

Grok subscription plans (SuperGrok and Team)

xAI lists a free tier, SuperGrok Lite, SuperGrok and SuperGrok Heavy for individuals, plus Business or Team seats and Enterprise by quote. The paid tiers buy higher usage limits and access to current flagship models. Dollar amounts for these plans change and render only in a logged-in view of x.ai/pricing, so read them there rather than from a third-party roundup.

If you are one person chatting with Grok, the plan is the whole decision. If you are building an agent, the plan is the wrong product, because API usage is billed separately against prepaid credits.

Can you earn free xAI API credits by spending on the X API?

Yes, with conditions. X's developer docs say X API spend earns xAI API credits once you link your xAI team to your X developer account in the Developer Console. The reward rate depends on cumulative X API spend in a billing cycle:

  • $0 to $199: 0%.
  • $200 to $499: 10%.
  • $500 to $999: 15%.
  • $1,000 or more: 20%.

The rate applies to your full cycle spend, you receive the added reward as you cross each tier, and the counter resets every cycle. So $1,000 of X API spend earns $200 of xAI credit. Source: X API pricing docs.

This is a spend rebate, not a free tier. It helps if you already pay for X API data, for example an agent that reads X posts and sends them to Grok. It does nothing for a team with no X API bill. Separately, X offers new-account X API credits that are not Grok credits.

The 200k context cliff

xAI states that when a prompt reaches 200k tokens, the higher rate applies to all tokens in that request. All of them, not only the overage. On grok-4.6 the rates double: $4.00 input, $1.00 cached and $12.00 output.

A chat product rarely gets there. An agent that carries its own history forward walks toward the threshold on every run, and nothing announces the crossing. Token volume grows with the history, and the doubled rate multiplies it. Both effects compound, so a workflow that cost pennies per run in week one can cost many times that in month three with no change in the task.

Per-token rate is the least predictive number in an agent's bill. Repetition and context growth decide it.

How to control Grok API spend

xAI ships better cost instrumentation than most providers. Every response carries cost_in_usd_ticks in the usage object, the exact billed amount for that request. API keys can be scoped by ACL to specific endpoints or models. The invoiced billing limit defaults to $0, so requests are rejected once prepaid credits run out. Usage Explorer groups spend by key.

Use all four. They make a climbing bill legible and give you a hard stop. They do not change why it climbs. A triage agent that has classified 40,000 tickets is not discovering anything on ticket 40,001, and caching only makes the re-reading cheaper. The model still re-derives the conclusion every time.

Two cheaper levers help at the margin. Put the system prompt and policy documents first in a fixed order so the cached rate applies, and use grok-4.3 for classification and extraction steps that do not need a flagship. The third lever is the largest.

Why Major is the best way to cut Grok agent spend

Major is #1 here for one reason: it is the only option on this page that removes work from the model instead of pricing it more cleverly. When an agent works out how to classify, route or reconcile a repeatable step, it builds an app for that step. The app runs in deterministic code, holds its own data in a managed database, and writes its own logs. The agent runs the app and spends Grok tokens only on decisions that need judgment.

That changes the cost shape. Spend is front-loaded while the agent figures the workflow out, then flat, instead of climbing with run count. State lives in the app, so prompts stay small and never drift toward the 200k cliff. Major does not eliminate model use, and it does not replace xAI's controls. Keep per-key scoping and cost_in_usd_ticks attribution on the Grok calls that remain.

Build the cost-flat Grok triage agent on Major

Here is a support-triage version using real connectors.

  1. Connectors. Connect Zendesk for tickets and Slack for escalations. Credentials are scoped per connector, so the agent only reaches what the workflow needs.
  2. The app that holds state. The agent builds a triage app with a managed database: tables for tickets, classifications, routing rules and decisions. Each Grok call starts from a small, fixed context.
  3. The deterministic path. Known categories, routing rules and SLA checks run as code. No tokens, same result every time.
  4. The judgment call. Grok handles only tickets the rules cannot place, such as an ambiguous complaint or a possible refund exception. The answer is written back to the app, which can promote a recurring pattern into a new rule.
  5. The trigger. A workflow fires on new Zendesk tickets, so work is event-driven instead of a polling loop that re-reasons on a schedule.
  6. Governance. Role-based access controls who changes routing rules, every action lands in the audit trail, and escalations reach a person in Slack with context attached.

Start building free on Major and point it at a workflow your Grok bill already includes.

For the wider cost picture, see our guides to AI agent cost, LLM cost optimization and LLM API pricing across providers. If you are weighing models, Grok vs Claude compares them directly, and AI agent governance covers the controls that apply whichever model you run.

Where Major does not change the math

Some Grok spend is plain consumer or one-off use, where a SuperGrok plan is the whole decision and no agent loop exists. Major does nothing for that. The case for it is a recurring workflow that runs hundreds or thousands of times, where repeated reasoning dominates the bill. Estimate yours first: runs per day, average prompt size, cached share, output tokens and tool calls, then run the arithmetic on both sides of the 200k threshold.

Start building on Major

If your Grok bill is mostly an agent re-deriving the same triage, routing or reconciliation decision, build that step once as a governed app with its own database and audit trail, and keep Grok for the calls that still need judgment.

Related articles

Frequently asked questions

How much is the Grok subscription?
Grok has a free tier with usage limits, paid individual SuperGrok plans (Lite, standard and Heavy), a Business or Team plan, and Enterprise pricing by quote. Dollar amounts change and appear in a logged-in view of x.ai/pricing, so check there for the current figure before you subscribe.
What are the Grok price plans?
xAI sells a free tier, SuperGrok Lite, SuperGrok and SuperGrok Heavy for individuals, Team or Business seats, and Enterprise by quote. Higher tiers raise usage limits and unlock current flagship models. None of them include API credit, which is billed separately per token.
Can you earn free xAI API credits by spending on the X API?
Yes. Link your xAI team to your X developer account and X API spend earns xAI credits per billing cycle: 0% under $200, 10% from $200, 15% from $500, and 20% from $1,000. For example, $1,000 of X API spend earns $200 in xAI credit. It is a rebate, not a free tier.
Is there a free Grok API?
There is no general free Grok API tier. API usage is billed per token against prepaid credits, and requests are rejected when credits run out. The main ways to get credit without paying directly are the X API spend reward program and any promotional credits xAI offers.
How much does the Grok API cost?
It is billed per million tokens with separate input, cached-input and output rates. As of November 2026, grok-4.6 is $2.00 input, $0.50 cached and $6.00 output for prompts under 200k tokens, and grok-4.3 is $1.25, $0.20 and $2.50. At 200k tokens the higher rate applies to every token in the request.
How do you keep Grok agent costs from climbing?
Use xAI's controls: scoped API keys, the default $0 billing limit and per-request cost reporting. Then reduce repeated reasoning. On Major, an agent builds a deterministic app for repeatable steps and uses Grok only for judgment calls, so cost is front-loaded and then flat rather than rising with each run.