Skip to main content
Grok is xAI’s flagship model family. The current generation (Grok 4.x) spans five product lines — flagship general-purpose, long-context standard, reasoning/non-reasoning variants, code-focused, and multi-agent collaboration — all available on APIYI. xAI’s official API is itself OpenAI-compatible (Chat Completions + Responses API) with no separate proprietary protocol, so calling Grok through APIYI with the OpenAI SDK gives you the full feature set, including official server-side tools (web search, X search, code execution, Remote MCP). This documentation group is based on a full hands-on test against the APIYI gateway on July 13, 2026 (UTC+8) — 56 request/response logs — so every capability boundary stated here is verified.
🚀 Highlights: grok-4.7 is SpaceXAI (xAI)‘s newest flagship, released September 21, 2026. It moves to a new 2.1T-parameter base model with the biggest gains in coding agents, and its price is identical to grok-4.6; grok-4.3 and the grok-4.20 series offer a 1M-token context window; the Responses API tools web_search / x_search / code_interpreter / MCP are all verified working on APIYI, and X search is a capability unique to Grok; native responses support also means Grok can plug straight into OpenAI Codex. The whole Grok series runs on the xAI official relay line in the default group, priced the same as xAI; see “Groups and Discounts” below.

Model Lineup

grok-4.7

Newest Flagship · Code & AgentsReleased 2026/9/21, 500K context. A new 2.1T-parameter base at the same price as grok-4.6, with clear gains on long coding tasks.

grok-4.6

Previous Flagship · Same PriceReleased 2026/8/7, 500K context. Same foundation as grok-4.5, with stronger self-verification on long-running tasks.

grok-4.5

Previous Flagship · Same Price500K context, with the same input and output price as grok-4.6 — existing workloads can stay on it.

grok-4.3

Standard Workhorse1M context at roughly 60% of the flagship price — the balanced choice for everyday chat and mid-level reasoning.

grok-4.20 Variants

Reasoning / Non-Reasoning-reasoning and -non-reasoning share the same price and 1M context; pick based on whether you want chain-of-thought.

grok-build-0.1

Code-Focused256K context and the lowest price in the series — ideal for high-frequency code completion and light coding tasks.

grok-4.20-multi-agent-beta-0309

Multi-Agent CollaborationMultiple agents work in parallel on complex research tasks. Special billing profile — see Multi-Agent Model.

More Capability Pages

Chat/reasoning/vision: Chat & Reasoning; live search: Web & X Search.

Pricing

Pricing matches xAI’s official pricing (verified item-by-item against the APIYI pricing API on 2026-07-13; grok-4.6 re-verified 2026-08-13 and grok-4.7 on 2026-09-24), and recharge promotions stack on top. The table below is the 0 – 200K context tier (the whole Grok series is billed in tiers by context length; the higher tier is covered below):

Tiered Billing and Cache Rates

The whole Grok series bills in two tiers based on the context length of a single request, with the break at 200K tokens (200Ki = 204,800). Above that point, input and output rates double: All figures are per 1M tokens. grok-4.7 and grok-4.6 are identical on all four billing items; the only price difference between grok-4.6 and grok-4.5 is the cached read rate ($0.50 vs $0.30) — input and output are identical. Both tiers of grok-4.7 and grok-4.6 have been verified item-by-item for input, output and cached read (the grok-4.7 tier break is 200,000 tokens); the second-tier cached read rates for the other models are derived from xAI’s “second tier doubles” convention, so treat the live pricing on the model info page as authoritative.
  • The aliases grok-code-fast / grok-code-fast-1 are also callable (connectivity verified); see the model info page for their pricing.
  • Cached input tokens are billed at the cached read rate in the table above. Grok prefix caching is automatic — no configuration needed, verified across both endpoints and both streaming and non-streaming; see the Grok cache billing guide.
  • Watch the tier break on long-context work: a single 210K-token request is billed entirely at the second tier, not just the 10K above the line. Splitting requests avoids the jump.

Groups and Discounts

The Grok series uses the xAI official relay line in the default group, so there is no longer a separate official relay group. The former GrokOfficial group is no longer listed, also runs at 1x, and Tokens already using it need no changes. To lower costs further, stack a top-up bonus, tiered by the amount of each top-up.

Verified Capability Matrix

Tested on 2026-07-13 (UTC+8) against the APIYI gateway (✅ verified working; ◐ not yet tested, expected identical on the same architecture; — not covered, expected identical on the same architecture):
Why the grok-4.6 column still carries ◐ marks: this 56-request test run dates from 2026-07-13, before 4.6 existed. On 2026-08-19 we re-tested basic chat, streaming (with usage) and prompt caching on 4.6 — across both /v1/chat/completions and /v1/responses, streaming and non-streaming, with billing reconciled line by line — so those rows now report verified results. The remaining ◐ marks carry over the same-architecture expectation: 4.6 shares the 1.5T-parameter V9 foundation, API protocol and endpoints of 4.5, and xAI has announced no breaking parameter-level changes. Run a small sample against your own use case before putting it into production.grok-4.7 (released 2026-09-21) is not in this matrix yet. It moves to a new 2.1T base model, so the same-foundation inference above does not apply; run a small sample on your own use case before adopting it.

Endpoints

Use It Directly in Codex

Because Grok natively supports /v1/responses, it is one of the few non-OpenAI models that runs in OpenAI Codex (desktop app / IDE extension / CLI) over the native responses protocol — set model = "grok-4.6" and wire_api = "responses" in config.toml and you’re connected in 5 minutes, with Codex’s agent features (tool calls, reasoning items, etc.) all on the native protocol. By contrast, Claude / Gemini on APIYI only run in OpenAI-compatible chat mode (wire_api = "chat" fallback), which carries protocol incompatibilities in Codex / agent scenarios. Full setup steps: Codex Integration Guide.
The following are NOT supported on APIYI (verified — avoid these pitfalls):
  • Legacy Completions (/v1/completions): rejected upstream — the entire Grok 4.x line is a reasoning architecture and does not support raw text completion at the official level
  • Legacy live-search parameter search_parameters: removed by xAI (verified 410). All live search goes through Responses API tools — see Web & X Search
  • Batch API / Files: not routed by the gateway; not applicable to key-pool mode
  • Deferred Completions (deferred: true): the parameter is silently ignored — the request executes synchronously and is billed normally. Do not rely on it
  • Collections Search (RAG / file_search): requires collections pre-built in the xAI console; not applicable to key-pool mode
  • Context Compaction (/v1/responses/compact), Priority Processing (service_tier: "priority" — falls back to default in testing), WebSocket mode, mTLS authentication: all unsupported

Quick Start

Which model to pick: default to grok-4.3 (1M context, balanced price); upgrade to grok-4.7 for coding agents and complex tasks (the newest flagship, priced identically to grok-4.6, though it uses more output tokens per task, so compare cost on real tasks first); use grok-4.20-0309-non-reasoning for fast, low-cost answers (no chain-of-thought, cheapest output); grok-build-0.1 for high-frequency code completion; and only reach for the multi-agent model on complex research tasks (mind its billing amplification). To lower costs further, stack a top-up bonus.

Billing Note: Reasoning Tokens

grok-4.7 / grok-4.6 / grok-4.5 / grok-4.3 / grok-build-0.1 reason internally by default: responses include reasoning_content, and reasoning tokens count toward output billing. In testing, a short answer showed just 30 visible tokens but billed 586 output tokens (556 of them reasoning). For cost-sensitive short Q&A, switch to grok-4.20-0309-non-reasoning. Details in Chat & Reasoning.

FAQ

No separate proprietary protocol. xAI’s official REST API is OpenAI-compatible: /v1/chat/completions (chat) plus /v1/responses (Responses API and server-side tools). Point the OpenAI SDK at https://api.apiyi.com/v1 and you get the full feature set — there is no “compatibility-mode downgrade”.
Use the Responses API: tools: [{"type": "web_search"}] (or x_search). The legacy search_parameters field on Chat Completions has been removed by xAI (verified 410) — do not use it. See Web & X Search.
This is normal. All Grok 4.x models self-identify simply as “Grok 4” (the multi-agent model calls itself Oppie) and won’t report exact version numbers like 4.6 / 4.5 / 4.3. Verify identity via the model field in your request and the response, not the model’s self-introduction.
No. Grok prefix caching is automatic; check hits via usage.prompt_tokens_details.cached_tokens (on /v1/responses, read usage.input_tokens_details.cached_tokens). Hits round down to 128 tokens, which both test rounds agree on: an 8802-token prefix hit 8704, a 2735-token prefix hit 2688. xAI states that cache entries can be evicted and hits are not guaranteed, so budget at the uncached price. Full details in the Grok cache billing guide.
A 400 error. Limits differ per model: grok-4.7, grok-4.6 and grok-4.5 are 500K, grok-4.3 and the 4.20 series are 1M, grok-build-0.1 is 256K. Summarize, chunk, or use RAG retrieval for longer content.
4xx client errors (bad parameters / auth failures) are not billed; requests that successfully return tokens are billed by actual usage. Note that deferred: true is silently ignored — the request actually runs synchronously and is billed normally.

Chat & Reasoning

Streaming, chain-of-thought, structured outputs, function calling, vision, caching

Cache Billing

75% off on hits, 128-token block granularity, and which endpoint suits long conversations

Web & X Search

Hands-on with the Responses API web_search / x_search tools

Code Execution & MCP

Server-side Python sandbox and Remote MCP integration

Multi-Agent Model

Capabilities and billing profile of the multi-agent model

Use Grok in Codex

Native responses protocol, connected to Codex in 5 minutes

Grok 4.6 Launch Deep-Dive

Benchmarks, pricing and migration notes for xAI’s newest flagship

Grok 4.5 Launch Deep-Dive

In-depth look at the previous flagship

Model Info

All available models and groups