Grok does not run on one universal memory limit. The number of tokens you get depends entirely on which model you call, and the spread across the current lineup is wide: a 256,000-token ceiling on the coding-focused Build tier, all the way up to a 2,000,000-token window on the flagship multi-agent model.
If you pick the wrong model for a long document, you will either see the request rejected or watch your bill jump once you cross a pricing threshold you didn’t know existed. Matching the length of what you’re feeding Grok to the model actually built for that job is the difference between a clean run and a wasted API call.
Grok Context Window Limits by Model
SpaceX acquired xAI in February 2026 at a valuation of roughly $250 billion, and the company completed its rebrand to SpaceXAI that July, which is why the current model documentation now lives under the SpaceXAI name at docs.x.ai.
Six model tiers are active on that platform right now, each tuned for a different balance of speed, reasoning depth, and memory.
| Grok Model | Context Window | Standard Input Rate | Standard Output Rate | Notes |
| Grok 4.20 | 2,000,000 tokens | $1.25 / 1M tokens | $2.50 / 1M tokens | Reasoning, non-reasoning, and multi-agent variants |
| Grok 4.3 | 1,000,000 tokens | $1.25 / 1M tokens | $2.50 / 1M tokens | Cost-effective workhorse for everyday chat |
| Grok 4.6 | 500,000 tokens | $2.00 / 1M tokens | $6.00 / 1M tokens | Current default flagship, coding and agent work |
| Grok 4.5 | 500,000 tokens | $2.00 / 1M tokens | $6.00 / 1M tokens | Predecessor to 4.6, still served on request |
| Grok Build 0.1 | 256,000 tokens | $1.00 / 1M tokens | $2.00 / 1M tokens | Developer preview, code completion |
Grok 4.6 carries the same 500,000-token context window as Grok 4.5, priced at $2.00 per million input tokens, $0.50 per million cached input tokens, and $6.00 per million output tokens. It has now taken over as the model xAI points new API projects and every consumer Grok plan toward by default.
If your work still runs on Grok 4.5, nothing breaks, but 4.6 is what you’ll get unless you pin a specific model ID.
Why Grok Models Have Different Context Limits
The lineup doesn’t follow a simple rule where each newer release automatically gets a bigger memory. Flagship models trade context depth for reasoning quality and speed. Holding high attention accuracy across millions of tokens takes enormous compute, and every extra token in the window competes with the GPU budget that would otherwise go toward sharper instruction-following or faster generation.
SpaceXAI’s engineering choices reflect that split directly. The coding and agent-focused models, Grok 4.5 and Grok 4.6, deliberately cap their window at 500,000 tokens so the architecture can stay fast and precise on multi-step software tasks.
The long-context specialists, Grok 4.20 and Grok 4.3, go the other direction and prioritize raw retrieval depth over top-end reasoning speed. Neither approach is objectively better. It comes down to whether your task needs to see more or think harder.
Grok 4.20 Has the Largest Current Context Window
At 2,000,000 tokens, Grok 4.20 still holds the top spot for raw memory capacity in the active SpaceXAI lineup. Grok 4.20 launched in beta on February 17, 2026 and became fully available through the API on March 10, 2026, with a native multi-agent architecture, two operational modes for reasoning and non-reasoning work, and real-time integration with X data.
In practice, developers route work across three configurations:
- Grok 4.20 reasoning: built for multi-step math, scientific evaluation, and structured architectural analysis where the model needs to work through a problem before answering.
- Grok 4.20 non-reasoning: a direct-completion mode for straightforward tasks where speed matters more than deliberation.
- Grok 4.20 multi-agent: coordinates parallel agents on research and tool-calling workloads, though it carries its own billing profile worth checking before you scale it up.
A common point of confusion is comparing 4.20 against Grok 4.3. The two names look close, but Grok 4.3’s window tops out at 1,000,000 tokens, exactly half of 4.20’s ceiling.
The version numbering here reflects a model family split rather than a strict release timeline, so don’t assume the higher-sounding number always wins on capacity. If your workload genuinely needs the largest window SpaceXAI ships today, 4.20 is the one to reach for.
What You Can Fit Into a 2 Million Token Context
A 2,000,000-token window works out to roughly 1.5 million words, which is enough room for several thousand pages of text in a single pass.
For engineering teams, that means loading an entire application codebase into one prompt: backend services, frontend components, and the dependency tree included, so Grok can trace a bug across hundreds of interconnected files without losing the thread between them.
For research and legal work, it means dropping in hundreds of technical papers or full regulatory filings at once, instead of chunking documents through a vector database and hoping the retrieval step didn’t drop the one paragraph that mattered.
For long-running agents, it’s what keeps a multi-hour coding or research session coherent. Every tool call, every intermediate log, and every file edit stays inside the active window instead of getting truncated halfway through a task.
Grok 4.5’s 500K Context Window
Grok 4.5 is SpaceXAI’s model built for coding, agentic tasks, and knowledge work, trained in the company’s Memphis data centers on datasets spanning science, engineering, and math. It ships with a 500,000-token window rather than the multi-million-token ceiling of 4.20.
That’s a deliberate trade: less raw memory in exchange for faster, more disciplined output on software tasks. It was publicly released on July 9, 2026, priced at $2.00 per million input tokens, $0.50 per million cached input tokens, and $6.00 per million output tokens.
The catch developers need to watch for is the pricing cliff. Cross roughly 200,000 tokens in a single prompt and Grok 4.5’s rate jumps from $2/$6 to $4/$12 per million tokens, and that higher rate applies to the entire request, not just the overage.
Before you dump a massive file into Grok 4.5 or its successor Grok 4.6, ask whether the task actually needs that model’s agentic strengths, or whether a million-token model like Grok 4.3 would finish the same job for less.
Context Window Size Is Not the Same as Output Limit
One mistake developers make early on is assuming a 1M-token context window means Grok can generate a 1M-token reply. It can’t. The context window is shared memory that covers both what goes in and what comes out.
Everything on the input side, including your system instructions, uploaded files, image metadata, and the full rolling conversation history, eats into that shared pool. Every extra turn in a conversation leaves less room for whatever gets generated next.
Output generation runs under its own separate cap, typically somewhere around 4,096 to 8,192 tokens per response depending on how the request is configured. A model can happily read a 500,000-token prompt in one shot, but the reply it hands back is still bound by that much smaller ceiling.
Large Contexts Can Increase API Costs
Pushing toward the top of a large context window changes your billing profile fast. Charges are per token, so every call carries the full cost of everything you sent, not just the new content.
Send a 1,000,000-token prompt three times to ask three quick follow-up questions, and you’re billed for 3 million input tokens plus whatever the model generates each time, even though most of that payload was identical across all three calls.
Prompt caching is the fix. When static content like a system prompt, boilerplate code, or a reference document sits at the front of your prompt, SpaceXAI caches those tokens for reuse. Cached-input rates run dramatically lower than standard input pricing, cutting recurring costs by a wide margin on any workflow that resends the same context repeatedly.
The 200,000-token threshold matters here too. Once a prompt reaches 200K tokens, the request is billed entirely at the long-context rate: $4.00 per million input tokens, $1.00 per million cached input tokens, and $12.00 per million output tokens on the flagship coding models.
That’s double the standard rate across the board, so a 199K-token prompt and a 201K-token prompt can end up costing meaningfully different amounts even though the actual content barely changed.
API Context Windows vs. Grok’s Consumer App
The token ceilings covered above apply to the SpaceXAI REST API, Grok Build, and IDE integrations like Cursor. They do not carry over one-to-one into the consumer chat experience on X or grok.com.
Consumer access is split by subscription tier:
- Free users: get dynamic, noticeably smaller context windows with strict rate limits, tuned to keep the service stable at scale. Free-tier users work with roughly 128,000 tokens regardless of what the underlying API specs allow.
- X Premium subscribers: get higher hourly message caps and a larger working context for daily chat use.
- SuperGrok subscribers: get access to features like DeepSearch and expanded memory suited to heavier day-to-day use.
Consumer platforms also quietly truncate or summarize older parts of a conversation to manage server load, something the API never does on its own. If you need exact, predictable control over token counts, that only comes through the API.
Older Grok Models and the 2M-Token Confusion
Search results on this topic are unusually inconsistent, and it’s worth knowing why. Earlier model iterations, including Grok 4.1 Fast, shipped 2,000,000-token windows at aggressive price points well before the current lineup existed, and a lot of that older coverage is still indexed and circulating.
The lineup has also moved fast in the other direction. Grok 4.6 launched on August 12, 2026, keeping the same 500,000-token window as Grok 4.5 while sharpening its coding and agent performance, and it’s now the model served by default on every Grok plan, including Free.
SpaceXAI describes it as trained alongside Cursor on coding, science, engineering, and math tasks, and reports it using roughly 4.2 times fewer output tokens than a comparable Opus 4.8 model on SWE-Bench Pro, averaging around 15,954 tokens against 67,020.
That’s a meaningful efficiency claim if it holds up in your own testing, but it doesn’t change the context window math: 4.6 is still a 500K-token model, not a long-context one.
If you’re building anything production-facing, treat older articles citing legacy models as historical rather than current, and check the model’s own page on docs.x.ai before locking in a number for a budget or an integration.
Does a Bigger Context Window Improve Grok’s Responses?
A larger window lets Grok ingest more raw material, but it doesn’t automatically make the output better. Quality depends on how well the model retrieves and reasons over everything you gave it, not just how much you were able to stuff in.
This is where the needle-in-a-haystack problem shows up. Facts buried in the middle of a 500-page document can get overlooked even when the model technically read every token. Models built with dedicated long-context attention, like Grok 4.20, tend to hold onto mid-document details more reliably than a smaller model simply scaled up to accept more input.
How you structure the prompt matters just as much as the model you pick. Putting core instructions at the very start or end of a long prompt, separating raw source material with clean formatting, and switching to a reasoning variant like Grok 4.20 reasoning for anything genuinely complex will all noticeably improve how accurately the model uses everything inside that window.
Getting better results from Grok also depends on choosing the right model, understanding its capabilities, and managing your account and API access. These related articles cover the next steps:
- How to Cancel a Grok Subscription on Any Device
- How to Delete Your Grok xAI Account
- How to Get a Grok API Key from xAI
- Does Grok xAI Have Video Generation? Features and Limits
Frequently Asked Questions
What is Grok’s context window size in 2026?
There’s no single number. Context windows across the current SpaceXAI lineup range from 256,000 tokens on the Grok Build developer preview up to 2,000,000 tokens on Grok 4.20, with 1,000,000 on Grok 4.3 and 500,000 on both Grok 4.5 and the newer Grok 4.6 sitting in between.
Which Grok model has the largest context window?
Grok 4.20 holds the largest window at 2,000,000 tokens across its reasoning, non-reasoning, and multi-agent configurations. It’s worth noting that this isn’t the same as the newest or most-used model. Grok 4.6, released in August 2026, is now the default flagship for everyday and agentic work, but it runs on a smaller 500,000-token window by design.
How many tokens does Grok 4.5 support?
Grok 4.5 supports a 500,000-token context window, purpose-built for agentic workflows, coding tasks, and structured reasoning rather than long-document ingestion.
Is Grok 4.3’s context window 1 million tokens?
Yes. Grok 4.3 offers a 1,000,000-token context window at $1.25 per million input tokens, making it one of the more cost-effective options for processing large documents without paying flagship-tier pricing.
Does Grok 4.20 support 2 million tokens?
Yes, natively, across all three of its operational modes. That capacity is what makes it the right choice for full codebase ingestion or long, multi-turn agent sessions that need to stay coherent in a single prompt.
Can free Grok users access the 2 million token context window?
No. The 2,000,000-token window is a developer-API capability. The free consumer interface on grok.com and X caps out at a much smaller working context, roughly 128,000 tokens in practice, regardless of which model is running underneath.
Does a larger context window make Grok more accurate?
Not by itself. A bigger window lets you supply more source material, but the actual accuracy of the response depends on the model’s retrieval capability, how well the prompt is structured, and whether you’re using a dedicated reasoning variant for anything that requires multi-step thinking.