Long Context: Up to 1 Million Tokens

What a One-Million-Token Window Means

Not all Grok text models share the same context capacity, and this difference is a key factor in your decision: grok-4.3 and the grok-4.20 generation support up to 1 million tokens, grok-4.5 accepts 500,000, and grok-build-0.1 256,000. To put that upper limit in perspective, 1 million tokens represents about 750,000 words—the equivalent of seven to ten novels, or a medium-sized codebase.

This capacity transforms how you use a language model. Instead of chopping your data into fragments and processing them separately, you can provide the entire context in a single request—and for these tasks, grok-4.3, the economical very-long-context option, often becomes the right choice rather than the flagship model.

Use Cases

Codebase Analysis

With 1 million tokens, you can load an entire codebase into the model’s context. A Python project spanning tens of thousands of lines fits comfortably within this window. The model can then answer questions about the overall architecture, identify cross-dependencies, or propose refactoring consistent with the entire code—something grok-build-0.1, limited to 256k, cannot do at this scale.

Long Document Processing

Annual reports, legal documents, technical manuals—these documents often run hundreds of pages. Instead of summarizing them in chunks and losing the global context, you can inject them entirely and ask precise questions about any section.

Long Conversations

In conversational applications, the context window determines the length of history the model can “remember”. With a one-million-token window, you maintain very long conversations without context loss—useful for extended work sessions or complex technical support.

Multi-Source Synthesis

Load multiple documents simultaneously—articles, reports, emails—to synthesize them across sources. The model can identify overlaps, contradictions, and complementary information between sources.

Limits and Considerations

The 200,000-Token Threshold

This is the point people too often discover on the bill: Grok pricing doubles beyond 200,000 context tokens. In other words, as soon as you truly leverage long context, you automatically switch to the high tier. A one-million-token input request on grok-4.3 is billed at the doubled rate—$2.50 per million instead of $1.25—meaning $2.50 for that single request. On grok-4.5, a 500,000-token request jumps to $4.00 per million input.

This threshold must factor into your design: an architecture that stays under 200,000 tokens costs half as much per token as one that overflows, at equal volume.

Latency

The longer the context, the longer the processing time. A request with one million input tokens will be significantly slower than one with 2,000 tokens. Plan for appropriate timeouts—xAI recommends a minimum of 3,600 seconds for complex requests.

Cost and Cache

Cost is directly proportional to the number of tokens processed, and cache is the only real counterweight: input tokens already seen are billed 75% to 85% cheaper depending on the model (84% on grok-4.3 and the 4.20 generation). A stable reference context, reused from request to request, therefore comes at a fraction of its initial price—hence the crucial importance of cache for long contexts.

Attention Quality

Even if the model accepts one million tokens, attention quality is not uniform. Information placed at the beginning and end of the context is generally better “retained” than that in the middle. For critical requests, place the most important information at the start of the context or directly before the question.

No Permanent Storage

The context window is ephemeral: it exists only during the request. If you need to store information between requests, use xAI Collections or your own database. The context window does not replace a persistent memory system.

Strategies for Effective Use

Structure Your Context

With very long context, structure becomes crucial. Use clear delimiters (XML tags, Markdown headings) to organize different sections. The model navigates better when the context is well-tagged.

Combine Long Context and Cache

The most powerful combination: a stable long context (reference documentation, source code) that benefits from cache, with short, dynamic additions (user question) at the end. You get the power of long context at cache prices.

Don’t Fill Context Unnecessarily

Just because you can inject one million tokens doesn’t mean you should do it systematically. Every token has a cost, potentially crosses the 200k threshold, and increases latency. Select the context relevant to the task at hand rather than sending everything by default—and remember that RAG often remains cheaper than long context for querying a large corpus.

Key Takeaways

• Windows vary by model: 1M for grok-4.3 and the 4.20 generation, 500k for grok-4.5, 256k for grok-build-0.1
• 1 million tokens represents about 750,000 words—ideal for code, long documents, and extended conversations
• Watch the threshold: beyond 200,000 context tokens, the per-token rate doubles
• Latency increases with context size—plan for appropriate timeouts
• Cache (75% to 85% reduction on input) is essential to make long contexts economical
• Attention quality varies: place critical information at the start or end of context