xAI Grok API Pricing Overview: Three Models for Different Use Cases

xAI’s Grok API lineup in 2026 is structured as a three-tier stack: a fast/cheap general-purpose model (Grok 4.1 Fast at $0.20/$0.50 per million tokens), a flagship reasoning model (Grok 4.20 at $2.00/$6.00 per million tokens), and a coding-optimized variant (Grok Code Fast 1 at $0.20/$1.50 per million tokens). All three use the same OpenAI-compatible REST API at https://api.x.ai/v1, meaning any codebase already integrated with the OpenAI Python SDK or TypeScript SDK can switch to Grok by changing the base_url parameter and swapping API keys — zero refactoring required. Grok 4.1 Fast and Grok 4.20 both carry a 2M-token context window, which is 10× larger than Anthropic’s 200K limit and twice the size of GPT-5.5’s 1M. Grok Code Fast 1 comes with a 256K context window, sized specifically for the large repository indexes that coding assistants need to maintain. Built-in real-time web search is available across all three models — a capability that competitors like GPT-5.5 and Claude charge extra for or require additional tooling to achieve. Prompt caching is supported on Grok 4.1 Fast and Grok 4.20, enabling significant cost reductions for applications that repeatedly send the same system prompt or document context across requests.

Grok 4.1 Fast: High-Volume Applications at $0.20 Per Million Tokens

Grok 4.1 Fast is xAI’s lowest-cost production model, priced at $0.20 per million input tokens and $0.50 per million output tokens — making it the go-to choice for applications where volume is high, latency matters, and per-request cost must stay under control. At those numbers, processing one billion tokens costs $200 on input and $500 on output, which is roughly what you spend on a single day of a mid-scale customer-support pipeline. The 2M-token context window — the same ceiling as the more expensive Grok 4.20 — means high-volume applications do not need to compromise on context depth to hit their cost targets. Grok 4.1 Fast is designed for background processing, batch classification, document summarization queues, and any workload where requests run in parallel at scale. Prompt caching is available on this tier: if your application repeatedly sends the same system prompt (say, a 10K-token instruction block), the cached portion is priced at a fraction of standard input cost, pushing effective input costs below $0.10 per million tokens for cache-heavy workloads. For developers running tens of millions of API calls per month, the difference between $0.20 and $2.00 per million input tokens is the difference between a manageable variable cost and a budget-busting line item.

Grok 4.1 Fast: Cost calculation examples

Assuming a 2:1 input-to-output ratio typical of classification and summarization tasks.

Grok 4.20: Flagship Reasoning at Competitive Pricing

Grok 4.20 is xAI’s flagship model, priced at $2.00 per million input tokens and $6.00 per million output tokens, targeting complex reasoning, long-document analysis, and research-grade synthesis tasks that require the full capability of a frontier model. Despite sitting at the top of xAI’s lineup, Grok 4.20 is priced 7.5× below Claude Opus 4.7 on input ($2.00 vs. $15.00) and 12.5× below it on output ($6.00 vs. $75.00) — a gap so large it restructures how teams think about deploying flagship-class intelligence. The 2M-token context window on Grok 4.20 enables use cases that are simply impossible on 200K-context models: ingesting an entire codebase for architecture review, loading a multi-year contract corpus for due-diligence analysis, or processing a full research dataset in a single prompt without chunking. Prompt caching is fully supported on Grok 4.20, which matters considerably at this tier — a repeated 100K-token system prompt costs $0.20 per uncached call; with caching, that same context might cost a fraction of that on subsequent requests. For reasoning-heavy pipelines that send the same long context repeatedly (legal review, compliance checking, codegen with a fixed spec), caching can cut monthly Grok 4.20 spend by 40–60%.

Grok 4.20: Cost calculation examples

For enterprise-scale reasoning workloads, compare to Claude Opus 4.7 at the same volumes: the 1M-token request above costs $15.00 + $1.50 = $16.50 with Opus 4.7 vs. $2.12 with Grok 4.20 — a 7.8× cost difference per request.

Grok Code Fast 1: Developer-Optimized Coding Model

Grok Code Fast 1 is priced at $0.20 per million input tokens and $1.50 per million output tokens, with a 256K context window tuned specifically for software development workloads: inline completions, code review, test generation, and coding-assistant backends where low latency and low cost-per-completion define success. The $0.20 input price matches Grok 4.1 Fast, but the $1.50 output price reflects the reality that code generation produces denser, higher-value tokens than general text — completions, function bodies, and test suites are consistently longer per request than summarization or classification outputs. The 256K context window is sufficient to hold a 50–100 file repository index, a full module with all its dependencies, or several hundred lines of accumulated conversation context from a coding session. For teams building IDE plugins, CI pipeline assistants, or autonomous coding agents, the combination of $0.20 input and $1.50 output makes Grok Code Fast 1 dramatically cheaper than GPT-5.5 ($5.00/$30.00) for the same coding throughput. A coding assistant generating 100M output tokens per month — roughly the volume of a mid-sized developer tool with several thousand active users — costs $150,000 per month with Grok Code Fast 1 vs. $3,000,000 per month with GPT-5.5 at full output pricing. That 20× cost advantage can be the deciding factor for early-stage developer tools trying to reach profitability before their next funding round.

Grok Code Fast 1: Cost calculation examples

The 2M Context Window Advantage: Real Cost Implications

A 2M-token context window is not just a benchmark number — it eliminates entire categories of infrastructure complexity that teams currently pay for in engineering time, vector database costs, and chunking pipeline maintenance. At 2M tokens, Grok 4.1 Fast and Grok 4.20 can ingest approximately 1,500 pages of text, a 200K-line codebase, or a year’s worth of customer support transcripts in a single API call, removing the need for retrieval-augmented generation (RAG) pipelines on most document-scale workloads. The direct cost implication: RAG pipelines require embedding models, vector stores, and retrieval logic that add $0.005–0.02 per query on top of LLM costs. For a pipeline running 1 million queries per month, eliminating RAG saves $5,000–$20,000 per month in infrastructure — partially or fully offsetting the LLM spend itself. Compare the 2M context ceiling to Anthropic’s 200K and OpenAI’s 1M (for GPT-5.5): a task that requires 800K tokens of context simply cannot run on Claude Opus 4.7 or Claude Sonnet 4.6 without chunking and multiple calls, which multiplies cost and introduces retrieval errors. Gemini 3.1 Pro matches Grok at 2M context but costs $3.50/$10.50 per million tokens — 75% more expensive on input and 75% more expensive on output than Grok 4.20. For teams whose bottleneck is context length rather than reasoning capability, Grok at the 2M tier is currently the most cost-efficient path to native long-context inference at scale.

Context window comparison across providers

Competitor Pricing Comparison: Grok vs Claude vs GPT-5.5 vs Gemini

The 2026 LLM API market has fractured into two pricing tiers: sub-$1 fast models and $2–15 flagship models — and Grok occupies an unusually strong position in both camps simultaneously. Grok 4.20, despite being xAI’s top-tier flagship model, is priced at $2.00/$6.00 per million tokens, landing it squarely in what other vendors price as mid-tier: Claude Sonnet 4.6 ($3.00/$15.00), Gemini 3.1 Pro ($3.50/$10.50), and GPT-5.5 ($5.00/$30.00) all cost more while offering smaller context windows. Claude Opus 4.7 at $15.00/$75.00 is in a different pricing bracket entirely — 7.5× more expensive on input and 12.5× more expensive on output than Grok 4.20. Whether Opus 4.7’s quality premium justifies that gap depends entirely on your task: for open-ended creative reasoning, instruction-following in complex multi-step pipelines, and tasks where subtle nuance matters, Opus 4.7 may produce measurably better outcomes. For bulk document analysis, long-context summarization, and structured data extraction, Grok 4.20 at 2M context will frequently match or exceed Opus 4.7 at 200K — at one-seventh the cost. Built-in real-time web search is a genuine differentiator for Grok: GPT-5.5 and Claude require separate tool-calling setups or subscriptions to access live web data, while Grok exposes it natively via the API with no additional per-search fee.

Full competitor pricing comparison

Cost to process 100M input + 50M output tokens:

Prompt Caching: How to Cut Grok API Costs by 50%+

Prompt caching on Grok 4.20 and Grok 4.1 Fast allows the API to reuse the KV-cache from a previous request when the prefix of a new request matches, charging a reduced rate for the cached portion instead of the full input token price. For applications with stable, long system prompts — a legal-review agent with a 50K-token jurisdiction and precedent block, a coding assistant with a 30K-token style guide, or a customer-support bot with a 20K-token product manual — caching eliminates the marginal cost of re-sending identical context on every call. The practical math: a 50K-token system prompt sent to Grok 4.20 without caching costs $0.10 per request; at 1,000 requests per day, that is $100/day or $3,000/month just for the system prompt. With caching, subsequent requests that hit the cache pay a fraction of the standard input rate — a saving that compounds quickly at scale. To trigger caching on xAI’s API, structure your requests so the stable, repeated content appears at the beginning of the prompt (system prompt, then static context, then dynamic content), as the cache key is prefix-based. Caching is not beneficial for fully dynamic requests where no prefix is shared across calls — only workloads with stable, repeated context above roughly 1,024 tokens see meaningful savings. When both factors align (long context + high request volume), caching can reduce effective Grok 4.20 input costs from $2.00 per million down to sub-$0.50 per million on the cached portion, cutting total API spend by 40–60%.

Caching savings example: Legal review agent

Getting Started: API Setup and First Request

The xAI API endpoint is https://api.x.ai/v1 — OpenAI-compatible, which means you can authenticate and call it using the standard openai Python package or TypeScript SDK by overriding the base_url and passing your xAI API key. No separate SDK installation is required: if you already use openai, you are one configuration change away from running Grok in production. API keys are provisioned at https://console.x.ai after creating an xAI account. Billing is usage-based with no monthly minimum, and the same account covers all three Grok models. The model name strings for API calls are grok-4-1-fast, grok-4-20, and grok-code-fast-1 — confirm the exact identifiers in the xAI console as naming conventions may evolve. Rate limits on new accounts default to conservative ceilings and can be raised by contacting xAI support with a description of your use case and projected monthly token volume. For teams moving from OpenAI or Anthropic, the most significant integration difference is that real-time web search does not require separate function-calling setup — it is available as a model capability flag in the request body rather than a tool definition. This simplifies the prompt design for search-augmented applications considerably compared to the tool-calling patterns required on GPT-5.5 or Claude.

Python quickstart using the openai SDK:

from openai import OpenAI

client = OpenAI(
    api_key="your-xai-api-key",
    base_url="https://api.x.ai/v1",
)

response = client.chat.completions.create(
    model="grok-4-20",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize the current state of LLM API pricing."},
    ],
    max_tokens=1024,
)

print(response.choices[0].message.content)

Switching models is a one-line change:

# Fast, cheap: $0.20/$0.50 per million tokens
model="grok-4-1-fast"

# Flagship reasoning: $2.00/$6.00 per million tokens
model="grok-4-20"

# Coding workloads: $0.20/$1.50 per million tokens
model="grok-code-fast-1"

Cost Optimization Strategies for Production Grok Deployments

Production Grok deployments achieve the lowest effective cost-per-task by combining model routing, prompt caching, output token discipline, and workload batching — each strategy compounding the savings from the others. The single highest-leverage decision is model routing: not every request in your pipeline needs Grok 4.20’s reasoning power, and sending every call to the flagship model when 60–70% of your workload is classification, extraction, or summarization is the most common source of inflated API bills. A routing layer that classifies incoming requests by complexity and directs simple tasks to Grok 4.1 Fast ($0.20/$0.50) and only genuinely complex reasoning to Grok 4.20 ($2.00/$6.00) typically reduces per-token blended cost by 50–70% at scale. Prompt caching addresses repeated context: audit your production system prompts and identify any prefix content that is stable across requests — instructions, policies, reference data, schema definitions — and ensure that content appears at the very start of the prompt to maximize cache hit rates. Output token discipline matters more than most teams realize: unnecessarily verbose completions are expensive at $6.00 per million on Grok 4.20; explicit max_tokens limits and prompt instructions to be concise on structured-output tasks (JSON extraction, classification labels, short summaries) can cut output spend by 20–40% with no quality loss. For batch workloads — document processing, data enrichment, nightly analysis jobs — use the largest feasible batch size to minimize API call overhead and maximize cache utilization across similar requests. Finally, monitor your token usage at the prompt component level (system prompt vs. user message vs. retrieved context) to identify which parts of your prompt are growing over time; unbounded context accumulation in multi-turn agents is one of the fastest ways to watch your Grok 4.20 bill climb unexpectedly.

Model routing decision framework:

A blended model routing strategy with 70% Grok 4.1 Fast and 30% Grok 4.20 (assuming a 2:1 input-to-output ratio) reduces effective blended input cost to $0.74/M and output cost to $2.15/M — a 63% reduction vs. using Grok 4.20 for all requests, and 85% cheaper than a GPT-5.5 equivalent deployment.

Frequently Asked Questions

1. Can I use my existing OpenAI SDK code with the Grok API without rewriting it?

Yes. The xAI API is fully OpenAI-compatible. You only need to change two things: set base_url="https://api.x.ai/v1" and replace your OpenAI API key with your xAI API key. Model name strings change (grok-4-20 instead of gpt-4o, for example), but all request/response structures, streaming behavior, and tool-calling conventions follow the OpenAI API spec.

2. Is real-time web search included in the standard per-token pricing, or is it an additional charge?

Real-time web search is a built-in model capability on all three Grok models and does not carry a separate per-search fee beyond the token cost of the search results returned in the response. When search results are included in the model’s context, they count toward your output token billing at the standard rate for that model.

3. Which Grok model should I use for a coding assistant with a large repository context?

Grok Code Fast 1 is the designed-for-purpose choice for most coding assistant workloads, offering a 256K context window at $0.20/$1.50 per million tokens. For tasks requiring analysis of extremely large codebases (over 256K tokens) — full monorepo architecture reviews or cross-repository impact analysis — Grok 4.20’s 2M context window is the correct tool, at the higher $2.00/$6.00 price point.

4. Does prompt caching work automatically, or does it require specific API parameters?

Prompt caching on xAI’s API is prefix-based: the API automatically reuses cached KV-state when a new request’s prompt begins with a prefix that matches a recently processed request. To maximize cache hits, structure your prompts with stable, repeated content (system instructions, document context, schemas) at the top and dynamic content (user messages, query variables) at the end. No special API flag is required to enable caching — it activates automatically when the cache key matches.

5. How does Grok 4.20 compare to Claude Opus 4.7 for tasks that need both long context and strong reasoning?

Grok 4.20 is 7.5× cheaper on input ($2.00 vs. $15.00) and 12.5× cheaper on output ($6.00 vs. $75.00), while supporting a 10× larger context window (2M vs. 200K tokens). For tasks that require both long context and reasoning — large codebase analysis, full-document contract review, multi-source research synthesis — Grok 4.20 is the only model in its price tier that can handle them without chunking. Claude Opus 4.7 remains the benchmark for subtle instruction-following and nuanced creative reasoning on shorter contexts; for long-context reasoning at scale, Grok 4.20’s cost and context advantages are decisive.

What Is Grok 4? xAI’s Flagship Reasoning Model Explained

Grok 4 is xAI’s Q2 2026 flagship large language model, successor to Grok 3, designed for advanced reasoning, coding, and multimodal tasks. It’s available via the xAI API (x.ai/api) with an OpenAI-compatible interface, through X Premium+ subscription, and on Grok.com. The architecture uses a mixture-of-experts (MoE) approach — not confirmed publicly by xAI, but consistent with the model family’s behavior patterns — enabling the 2M+ context window without proportional compute cost increases for shorter prompts. Grok 4 ships with two primary variants: the full Grok 4 for reasoning-intensive tasks, and grok-code-fast which uses a specialized tokenizer and inference optimization for programming work where latency matters more than maximal reasoning depth. Real-time web search is built-in to both variants — Grok has always had this capability as a differentiator, and Grok 4 maintains it. This matters for developer use cases: an agent asking “what’s the current Claude Opus 4.7 pricing?” gets a live answer rather than training-cutoff information.

Grok 4 vs grok-code-fast: Which Variant to Use?

The two Grok 4 variants target different developer use cases based on the tradeoff between reasoning depth and latency:

Grok 4 is the full model: maximum reasoning capability, 2M context window, real-time web search. Appropriate for complex architectural questions, detailed code review requiring deep understanding, explaining subtle bugs, and any task where the quality of the answer matters more than response time.

grok-code-fast is optimized for programming tasks requiring lower latency. The specialized tokenizer improves speed on code-heavy prompts. Appropriate for inline autocomplete-style completions, code generation from clear specifications, and any scenario where the developer is in an active edit loop and waiting 10+ seconds per response is disruptive. The quality ceiling of grok-code-fast is lower than full Grok 4 on complex reasoning, but it’s faster for the cases where it shines.

The selection decision is similar to choosing between Claude Sonnet and Claude Opus: use the fast variant when speed matters and the task is well-defined; use the full model when the task is ambiguous or requires reasoning across a large context.

API Setup: Getting Started with the xAI API

The xAI API is OpenAI-compatible, meaning you can use the OpenAI Python SDK with a base URL override:

from openai import OpenAI

client = OpenAI(
    api_key="xai-your-api-key-here",
    base_url="https://api.x.ai/v1",
)

response = client.chat.completions.create(
    model="grok-4",
    messages=[
        {"role": "system", "content": "You are a senior software engineer."},
        {"role": "user", "content": "Review this function for potential issues:\n\n```python\n...\n```"}
    ],
    max_tokens=4096,
)

print(response.choices[0].message.content)

For grok-code-fast:

response = client.chat.completions.create(
    model="grok-code-fast",
    messages=[{"role": "user", "content": "Write a TypeScript function to parse ISO 8601 dates"}],
    max_tokens=2048,
)

API keys are available at console.x.ai. The beta API includes generous free tier credits for initial evaluation. Production usage requires a paid account with per-token billing at $3.50/million input tokens for Grok 4 (grok-code-fast pricing differs — check the current pricing page as it changes).

Benchmark Results: Coding, Reasoning, and Math Performance

xAI publishes benchmark results for Grok 4, though independent third-party verification takes time after launch. Published and community-verified numbers as of Q2 2026:

Grok 4’s strongest showing is on math reasoning, where it competes with or exceeds Claude Opus 4.7. The SWE-bench Verified score is competitive but trails Claude Code (Opus 4.7 with Claude Code tooling at 80.9%). The gap on SWE-bench reflects that the benchmark tests autonomous multi-step software engineering workflows — an area where Claude Code’s tooling optimizations give it an edge beyond raw model capability.

The 2M context window benchmark matters for specific use cases: feeding an entire large codebase as context, processing full books or legal documents, or maintaining conversation history across a very long session without summarization. Most developers don’t regularly use 2M context, but for the use cases that do (codebase-wide refactoring, large document analysis), Grok 4’s window exceeds Claude Opus 4.7’s 200K and GPT-5.5’s 1M.

The 2M Context Window: Real-World Use Cases

The 2M token context window translates to roughly 1.5 million words or approximately 6,000 pages of text. For developers, the practical implications:

Large codebase analysis: A TypeScript monorepo with 500+ files can fit entirely within the context window. Instead of RAG chunking or sampling, you feed the entire codebase and ask “find all N+1 query patterns across the application.”

Long conversation agents: An agent running for hours with extensive tool call history doesn’t need context compression or summarization until it’s consumed millions of tokens — far beyond most session lengths.

Full document processing: Regulatory filings, legal contracts, or technical specifications that span hundreds of pages process in a single pass without chunking-induced context loss.

The practical ceiling: 2M tokens at $3.50/million means processing the full 2M context costs $7 in input tokens alone. For routine coding tasks, you’re not using anywhere near this capacity. The 2M window is a ceiling for exceptional cases, not the typical operating point.

Pricing Analysis: Grok 4 vs Claude Opus 4.7 vs GPT-5.5

Grok 4’s pricing is the clearest competitive advantage against Claude Opus 4.7. At $3.50/million input tokens, Grok 4 costs 4x less than Claude Opus 4.7’s $15/million input. For teams running high-volume API workloads where both models produce acceptable output quality, the savings are substantial. A team consuming 10 million input tokens per month saves $115 per month per developer switching from Opus 4.7 to Grok 4. The grok-code-fast variant at approximately $1.50/million makes it one of the more cost-effective options for code generation at scale. The 2M context window — significantly larger than Opus 4.7’s 200K — doesn’t add cost for shorter prompts; pricing is purely consumption-based.

Grok 4’s pricing is significantly more competitive than Claude Opus 4.7 — 4x cheaper on input tokens. For high-volume API usage where you’re choosing between Opus 4.7 quality and Grok 4 quality, the cost difference is substantial. The grok-code-fast variant at approximately $1.50/million input tokens makes it one of the cheaper options for high-throughput code generation.

The caveat: pricing is subject to change during beta, and the current numbers reflect introductory pricing. The long-term steady-state pricing may differ.

Real-World Coding Performance: Practical Assessment

Grok 4 performs most reliably on tasks with clear problem statements and quantifiable success criteria — a pattern consistent with its strong math benchmark results. In production testing with coding tasks, the model demonstrates reliable performance on implementation from detailed specs, where the success criteria are well-defined. The 2M context window enables a workflow not available with smaller-context competitors: feeding the entire codebase as context and asking systematic questions about patterns across all files simultaneously. In practice, Grok 4 excels at tasks with clear problem statements and well-defined solutions. The model is strong at:

• Generating implementation from detailed specs
• Explaining existing code at any complexity level
• Mathematical reasoning embedded in code (algorithmic correctness)
• Refactoring with clear instructions

The model shows more variance on:

• Ambiguous tasks requiring significant judgment
• Catching subtle race conditions or security implications in complex code
• Multi-step agentic tasks (where Claude Code’s tooling optimizations give it an edge)

The real-time web search is genuinely useful for staying current — asking about recent API changes, current library versions, or recent CVEs gets live answers rather than training-cutoff responses.

Who Should Use Grok 4 (And When to Choose Alternatives)

Use Grok 4 if: You need a large context window (200K+ tokens) at significantly lower cost than Claude Opus 4.7. You’re building applications where real-time web search integration adds value. You want competitive reasoning capability at $3.50/million input tokens. Your use case is dominated by math, science, or well-specified code generation.

Use grok-code-fast if: You need fast code generation in an interactive loop. Latency matters more than maximum reasoning depth. Cost at scale is a primary concern.

Stick with Claude Opus 4.7 or Claude Code if: You’re doing autonomous multi-step software engineering (SWE-bench is the benchmark here — Claude Code leads). You need the most reliable output on ambiguous complex tasks. Your team is already invested in Anthropic tooling and workflows.

Stick with GPT-5.5 if: GitHub Copilot integration matters (uses OpenAI models natively). You’re in the OpenAI ecosystem with existing tools and workflows.

Verdict: Is Grok 4 Worth It in 2026?

The Grok 4 verdict depends on your primary constraint. For teams constrained by API budget — particularly those currently using Claude Opus 4.7 and paying $15/million input tokens — Grok 4 at $3.50/million with competitive quality is a compelling switch for many workloads. The 2M context window removes context management overhead for large document and codebase analysis use cases. The grok-code-fast variant’s lower latency and pricing (~$1.50/million input) makes it worth evaluating against Claude Sonnet for high-throughput code generation pipelines. For cost-sensitive API use cases at scale, yes. The $3.50/million input token pricing with 2M context is the clearest value proposition — 4x cheaper than Claude Opus 4.7 at competitive quality levels. The grok-code-fast variant is worth evaluating for any high-volume code generation use case.

For autonomous agentic coding workflows (Claude Code territory), Grok 4 is a competitive option but doesn’t yet have the tooling ecosystem that gives Claude Code its SWE-bench advantage. The gap may close as xAI develops agent-specific tooling.

The honest position: Grok 4 is a strong model at a competitive price, not a clear leader over all alternatives. Benchmark against your specific use case before committing to production deployment.

FAQ

What is Grok 4 and how does it differ from Grok 3?

Grok 4 is xAI’s Q2 2026 flagship LLM, successor to Grok 3. Key changes: 2M+ context window (up from 131K in Grok 3), grok-code-fast variant with specialized programming tokenizer, improved math and reasoning benchmarks, and competitive pricing at $3.50/million input tokens. Trained on the Colossus 100,000+ GPU cluster, Grok 4 targets the top-tier reasoning model category alongside Claude Opus 4.7 and GPT-5.5.

Is Grok 4 better than Claude Opus 4.7 for coding?

It depends on the task type. Grok 4 is competitive on math reasoning and well-specified code generation. Claude Opus 4.7 (specifically with Claude Code tooling) leads on SWE-bench Verified (80.9% vs ~75%) for autonomous multi-step software engineering. Grok 4 is 4x cheaper on input tokens, making it the better choice for high-volume use cases where the quality difference is acceptable. For complex agentic coding, Claude Code currently leads.

How do I access the Grok 4 API?

Access is available at console.x.ai. The API is OpenAI-compatible — use the OpenAI Python or TypeScript SDK with base_url="https://api.x.ai/v1" and your xAI API key. Both grok-4 and grok-code-fast model IDs are available. A free credit tier is available for initial evaluation.

What is grok-code-fast?

grok-code-fast is a Grok 4 variant optimized for programming tasks via a specialized tokenizer and inference optimization. It trades some reasoning depth for faster response times, making it suitable for interactive coding sessions where latency is important. Pricing is approximately $1.50/million input tokens — cheaper than the full Grok 4 model.

Does Grok 4 have real-time web search?

Yes. Real-time web search is built into both Grok 4 and grok-code-fast. This is a consistent xAI differentiator: asking about current API pricing, recent CVEs, new library versions, or recent events gets live answers rather than training-cutoff information. The search results are integrated into the response rather than returned as raw links.