Grok Build at $30/mo: Subscription or API, and When Each Wins

The decision now turns on usage volume and whether you want the first-party agent or your own CLI. A quick map:

Grok Build is no longer gated behind the $300 tier. The consumer ladder now looks like this:

So the line "you need $300 for Grok Build" is simply wrong now. The cheapest plan that includes the agent is $30 SuperGrok. That is genuinely cheap for a polished first-party terminal coding agent — same ballpark as Claude Code and Codex CLI subscriptions.

The $300 Heavy tier still exists, but its pitch has changed. It is no longer "the only way to get the agent" — it is the heavy-user tier: Grok 4 Heavy multi-agent reasoning, the highest rate limits, and priority during peak load. You step up to it for those specifics, not for the agent itself.

If you skip the subscription, the same intelligence is sold token-by-token on the xAI API as grok-build-0.1. The spec:

That is roughly 20% cheaper per token than the Grok 4.3 flagship ($1.25/$2.50), and it supports prompt caching — so repeated context drops to $0.20/M. For an agent that re-sends a large system prompt and the same files every turn, caching is where the real savings live. Pair the key with any open-source agent CLI that takes a custom OpenAI-compatible endpoint and you get most of the Grok Build experience for the cost of tokens you actually spend, with no subscription.

For an agent that re-sends the same context every turn, caching — not the headline rate — is where the savings live.

A typical agentic coding turn is about 30K input tokens (instructions plus a few files) and 3K output. Run the numbers and the subscription-vs-API question becomes a usage-volume question.

With no caching, a turn costs input 30,000 × $1.00/1M = $0.030 plus output 3,000 × $2.00/1M = $0.006, so about $0.036 per turn. With caching (25K cached + 5K fresh), cached 25,000 × $0.20/1M = $0.005, fresh 5,000 × $1.00/1M = $0.005, output $0.006, so about $0.016 per turn. Against the flat subscriptions that include the agent, caching on, break-even lands like this:

Read that slowly: to extract $30 of metered value with caching, you need about 85 agent turns per working day. A developer using Grok Build most days clears that easily, so the $30 sub is usually better for steady daily use. The API wins for lighter cases — occasional use, no-sub people, own-CLI people. Below about 85 turns/day, metered is cheaper. This flips the old assumption: when the only plan was $300, almost everyone was better off metered. Now that the agent starts at $30, the math tips the other way for regular users.

Below ~85 turns/day metered wins; above it, the $30 sub caps your spend.

If cheapest-capable tokens matter more than the coding-specialized build model, Grok 4.1 Fast sits underneath grok-build-0.1 on price:

Grok 4.1 Fast is 5x cheaper on input than grok-build-0.1 and carries a 2M-token context window. The headline "$0.20/M" is that input rate — the floor price for touching a Grok model at all in 2026. The tradeoff is that it is a general fast model, not the coding-specialized build model, so for heavy refactoring agents you may prefer grok-build-0.1's tuning. For batch summarization, retrieval over big documents, or cost-sensitive pipelines, Grok 4.1 Fast is the obvious call.

The xAI endpoint is OpenAI-compatible, so it is a two-line change in any existing OpenAI SDK setup. The grok-build-0.1 path goes straight to xAI — the only place that model lives today. General Grok pay-as-you-go can also route through an aggregator.

Python — grok-build-0.1 on the xAI API

from openai import OpenAI

client = OpenAI(api_key="XAI_API_KEY", base_url="https://api.x.ai/v1")
resp = client.chat.completions.create(
    model="grok-build-0.1",
    messages=[{"role": "user", "content": "Refactor this function for readability."}],
)
print(resp.choices[0].message.content)

Node — same shape

import OpenAI from "openai";

const client = new OpenAI({ apiKey: "XAI_API_KEY", baseURL: "https://api.x.ai/v1" });
const resp = await client.chat.completions.create({
  model: "grok-build-0.1",
  messages: [{ role: "user", content: "Write tests for this module." }],
});
console.log(resp.choices[0].message.content);

Drop the same key into an open-source agent CLI — Cline, Aider, OpenCode, and others all accept a custom base URL and model name — and you have a Grok coding agent that bills per token instead of per month.

This is not a "never subscribe" article. The $30 SuperGrok plan earns its keep in four concrete cases:

• Steady use past ~85 turns/day. Past that point the $30 SuperGrok plan is cheaper than metered and caps your spend, with no bill anxiety.
• First-party agent polish. A supported Grok Build install with zero glue code has real value when your time is expensive, and $30 is a low price for it.
• Grok 4 Heavy. The multi-agent reasoning model with parallel test-time compute is a SuperGrok Heavy ($300) inclusion, not an API line item you casually meter the same way.
• Max rate limits and priority. Heavy users hitting throttles on lower tiers pay the $300 tier for headroom and priority during peak load.

The mistake now is assuming you must pay $300 for the agent at all. You don't. Start at $30, and step up to Heavy only if you specifically need Grok 4 Heavy or the top rate limits. If your usage is light, skip the sub and meter the model.

Two cases where the Grok decision is the wrong question to be asking:

Don't anchor on Grok just because Grok Build made headlines. The coding-agent field is competitive, and brand headlines are not a selection criterion.

Brand headlines are not a selection criterion. Pick by cost-per-outcome.

Five routes, ranked by which kind of buyer each fits:

• xAI Docs, grok-build-0.1 model page: https://docs.x.ai/developers/models/grok-build-0.1
• xAI News, Grok Build CLI access expansion: https://x.ai/news/grok-build-cli
• xAI Docs, models index: https://docs.x.ai/developers/models
• OpenRouter, Grok 4.3 pricing and specs: https://openrouter.ai/x-ai/grok-4.3