ModelsPricingEnterprise
500+ AI Model API, All In One API.Just In CometAPI
Models API
Developer
Quick StartDocumentationAPI Dashboard
Company
About usEnterprise
Resources
AI ModelsBlogChangelogSupport
Terms of ServicePrivacy Policy
© 2026 CometAPI · All rights reserved
Home/Models/xAI/Grok 4.20
X

Grok 4.20

Input:$1.6/M
Output:$4.8/M
Context:2,000,000
Grok 4.20 release introduces a multi-agent architecture (multiple specialized agents coordinated in real time), expanded context modes, and focused improvements to instruction-following, hallucination reduction, and structured/tooled outputs.
New
Commercial Use
Playground
Overview
Features
Pricing
API
Versions

Technical Specifications of Grok-4.20

ItemGrok-4.20 (public specs)
Model familyGrok-4 series
DeveloperxAI
Release statusBeta (first rollout Feb 17, 2026)
Input typesText, Image, Video
Output typesText outputs (structured outputs & function/tool calling supported).
Context windowUp to 2,000,000 tokens
ArchitectureMulti-agent collaborative reasoning
Tool supportFunction calling, structured outputs
ReasoningBuilt-in reasoning capabilities
Training infrastructureColossus supercluster (~200,000 GPUs)
Model variantsgrok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning, grok-4.20-beta-0309-non-reasoning.

What is Grok-4.20

Grok-4.20 is the latest experimental release in the Grok-4 family developed by xAI. It focuses on agentic reasoning, extremely long context handling, and high-speed inference, aiming to deliver precise answers with a lower hallucination rate than earlier Grok models.

Unlike earlier Grok models that used single-model inference, Grok-4.20 introduces multi-agent collaboration, where several internal agents analyze a prompt simultaneously and converge on a final answer. This architecture is designed to improve performance on complex reasoning, coding, and research tasks.

Main Features of Grok-4.20

  • Ultra-long context window (2M tokens): Enables processing of entire books, large datasets, or long coding repositories in a single prompt.
  • Multi-agent reasoning architecture: Up to four internal agents can analyze a prompt in parallel and debate solutions before producing a final answer.
  • Agentic tool calling and structured outputs: Supports function calling and structured responses for integration with applications and automated workflows.
  • Multimodal understanding: Accepts text, image, and video inputs within the same model pipeline.
  • Fast inference with low hallucination focus: xAI positions the model as optimized for truthful answers and strong prompt adherence.

Benchmark Performance of Grok-4.20

Public benchmark data is still limited during beta, but early reports indicate:

BenchmarkResult / Status
LMSYS Chatbot ArenaEstimated ELO ~1505–1535
ForecastBenchRanked #2 in early tests
Alpha Arena trading challengeAchieved +34.59% returns

These numbers suggest Grok-4.20 competes with frontier models in real-world reasoning and agent-driven tasks rather than simple benchmark questions.

Grok-4.20 Beta vs Other Frontier Models

ModelDeveloperContext WindowKey Strength
Grok-4.20xAI2M tokensMulti-agent reasoning
GPT-5.2OpenAI~400K tokensAdvanced reasoning + coding
Gemini 3 ProGoogle~1M tokensmultimodal and Google ecosystem
Claude 4 OpusAnthropic~200K+ tokensreliable reasoning

Key differences

  • Grok-4.20 emphasizes multi-agent collaboration for reasoning tasks.
  • It provides one of the largest context windows in production LLMs (2M tokens).
  • Competing models may outperform Grok in certain areas such as structured reasoning or creative writing depending on evaluation tasks.

Representative Use Cases

  1. Long-context research analysis
    Process large documents, legal materials, or academic research.
  2. Agentic automation systems
    Build multi-step workflows where the model plans and executes tasks.
  3. Advanced coding and simulations
    Solve engineering problems or simulate systems with long reasoning chains.
  4. Data analysis and dashboard automation
    Track and analyze multiple streams of data in parallel.
  5. Multimodal knowledge processing
    Interpret images, video frames, and text in a unified reasoning process.

How to access and use Grok 4.2 API

Step 1: Sign Up for API Key

Log in to cometapi.com. If you are not our user yet, please register first. Sign into your CometAPI console. Get the access credential API key of the interface. Click “Add Token” at the API token in the personal center, get the token key: sk-xxxxx and submit.

Step 2: Send Requests to Grok 4.2 API

Select the “grok-4.20-0309-reasoning” endpoint to send the API request and set the request body. The request method and request body are obtained from our website API doc. Our website also provides Apifox test for your convenience. Replace <YOUR_API_KEY> with your actual CometAPI key from your account. Where to call it:   Chat format.

Insert your question or request into the content field—this is what the model will respond to . Process the API response to get the generated answer.

Step 3: Retrieve and Verify Results

Process the API response to get the generated answer. After processing, the API responds with the task status and output data.

FAQ

What makes Grok-4.20 different from previous Grok models?

Grok-4.20 introduces a multi-agent reasoning system where several agents analyze a prompt simultaneously and collaborate on a final answer, improving complex reasoning and coding performance.

How large is the context window in the Grok-4.20 API?

Grok-4.20 supports up to a 2,000,000-token context window, allowing developers to process extremely long documents or datasets in a single request.

Can Grok-4.20 handle multimodal inputs such as images or video?

Yes. Grok-4.20 supports multimodal inputs including text, images, and video, enabling analysis of mixed content within a single conversation.

How does Grok-4.20 compare with GPT-5.2 or Gemini models?

Grok-4.20 focuses on multi-agent reasoning and very long context windows, while GPT-5.2 emphasizes high-accuracy reasoning and Gemini models focus on multimodal integration within the Google ecosystem.

Is Grok-4.20 available through an API for developers?

Yes. Grok-4.20 is available through the Come API.

What benchmarks show Grok-4.20 performance?

Early reports place Grok-4.20 around 1505–1535 ELO on LMSYS Arena and strong results in real-world competitions such as Alpha Arena trading simulations.

Features for Grok 4.20

Explore the key features of Grok 4.20, designed to enhance performance and usability. Discover how these capabilities can benefit your projects and improve user experience.

Pricing for Grok 4.20

Explore competitive pricing for Grok 4.20, designed to fit various budgets and usage needs. Our flexible plans ensure you only pay for what you use, making it easy to scale as your requirements grow. Discover how Grok 4.20 can enhance your projects while keeping costs manageable.
Comet Price (USD / M Tokens)Official Price (USD / M Tokens)Discount
Input:$1.6/M
Output:$4.8/M
Input:$2/M
Output:$6/M
-20%

Sample code and API for Grok 4.20

Access comprehensive sample code and API resources for Grok 4.20 to streamline your integration process. Our detailed documentation provides step-by-step guidance, helping you leverage the full potential of Grok 4.20 in your projects.
POST
/v1/chat/completions
Python
JavaScript
Curl
import os

from openai import OpenAI

# Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com/v1"

client = OpenAI(base_url=BASE_URL, api_key=COMETAPI_KEY)
response = client.responses.create(
    model="grok-4.20-multi-agent-beta-0309",
    input=[
        {
            "role": "user",
            "content": "Research the latest breakthroughs in quantum computing and summarize the key findings.",
        }
    ],
    tools=[{"type": "web_search"}, {"type": "x_search"}],
)

print(response.output_text or response.model_dump_json(indent=2))

Python Code Example

import os

from openai import OpenAI

# Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com/v1"

client = OpenAI(base_url=BASE_URL, api_key=COMETAPI_KEY)
response = client.responses.create(
    model="grok-4.20-multi-agent-beta-0309",
    input=[
        {
            "role": "user",
            "content": "Research the latest breakthroughs in quantum computing and summarize the key findings.",
        }
    ],
    tools=[{"type": "web_search"}, {"type": "x_search"}],
)

print(response.output_text or response.model_dump_json(indent=2))

JavaScript Code Example

import OpenAI from "openai";

// Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here
const apiKey = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const baseUrl = "https://api.cometapi.com/v1";

const client = new OpenAI({
  apiKey,
  baseURL: baseUrl,
});

const response = await client.responses.create({
  model: "grok-4.20-multi-agent-beta-0309",
  input: [
    {
      role: "user",
      content: "Research the latest breakthroughs in quantum computing and summarize the key findings.",
    },
  ],
  tools: [{ type: "web_search" }, { type: "x_search" }],
});

console.log(response.output_text ?? JSON.stringify(response.output, null, 2));

Curl Code Example

#!/usr/bin/env bash
# Get your CometAPI key from https://api.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

response=$(curl --silent --location --request POST "https://api.cometapi.com/v1/responses" \
  --header "Authorization: Bearer $COMETAPI_KEY" \
  --header "Content-Type: application/json" \
  --header "Accept: application/json" \
  --data-raw '{
    "model": "grok-4.20-multi-agent-beta-0309",
    "input": [
      {
        "role": "user",
        "content": "Research the latest breakthroughs in quantum computing and summarize the key findings."
      }
    ],
    "tools": [
      {"type": "web_search"},
      {"type": "x_search"}
    ]
  }')

if command -v jq >/dev/null 2>&1; then
  printf '%s\n' "$response" | jq -r '(
    [
      .output[]?
      | select(.type == "message")
      | .content[]?
      | select(.type == "output_text")
      | .text
    ][0]
  ) // .output_text // .'
else
  printf '%s\n' "$response"
fi

Versions of Grok 4.20

The reason Grok 4.20 has multiple snapshots may include potential factors such as variations in output after updates requiring older snapshots for consistency, providing developers a transition period for adaptation and migration, and different snapshots corresponding to global or regional endpoints to optimize user experience. For detailed differences between versions, please refer to the official documentation.
Model iddescriptionAvailabilityRequest
grok-4.20-multi-agent-beta-0309Multi-agent variant tuned for realtime agent orchestration and tool calling (useful for deep research workflows where multiple sub-agents perform web searches, code execution, and critique).✅response format calls.
grok-4.20-0309-reasoningReasoning-optimized variant: prioritizes deeper chain-of-thought style reasoning and higher benchmark scores on reasoning-heavy tests; higher latency/cost per token expected versus non-reasoning variants.✅chat format call and response format calls.
grok-4.20-0309-non-reasoningLower-latency / lower-cost variant for high-throughput tasks where deterministic, short answers or streaming outputs are the priority; tradeoffs include lower reasoning benchmark scores.✅chat format call and response format calls.

More Models

C

Claude Opus 4.7

Input:$3/M
Output:$15/M
Claude Opus 4.7 is a hybrid reasoning model designed specifically for frontier-level coding, AI agents, and complex multi-step professional work. Unlike lighter models (e.g., Sonnet or Haiku variants), Opus 4.7 prioritizes depth, consistency, and autonomy on the hardest tasks.
A

Claude Sonnet 4.6

Input:$2.4/M
Output:$12/M
Claude Sonnet 4.6 is our most capable Sonnet model yet. It’s a full upgrade of the model’s skills across coding, computer use, long-context reasoning, agent planning, knowledge work, and design. Sonnet 4.6 also features a 1M token context window in beta.
O

GPT 5.5 Pro

Input:$24/M
Output:$144/M
An advanced model engineered for extremely complex logic and professional demands, representing the highest standard of deep reasoning and precise analytical capabilities.
O

GPT 5.5

Input:$4/M
Output:$24/M
A next-generation multimodal flagship model balancing exceptional performance with efficient response, dedicated to providing comprehensive and stable general-purpose AI services.
O

GPT Image 2 ALL

Per Request:$0.04
GPT Image 2 is openai state-of-the-art image generation model for fast, high-quality image generation and editing. It supports flexible image sizes and high-fidelity image inputs.
O

GPT 5.5 ALL

Input:$4/M
Output:$24/M
GPT-5.5 excels in code writing, online research, data analysis, and cross-tool operations. The model not only improves its autonomy in handling complex multi-step tasks but also significantly improves reasoning capabilities and execution efficiency while maintaining the same latency as its predecessor, marking an important step towards automated office automation in AI.

Related Blog

Cursor Composer vs Windsurf vs GitHub Copilot: Pricing & What You Actually Get
Apr 20, 2026
copilot
composer-2
windsurf

Cursor Composer vs Windsurf vs GitHub Copilot: Pricing & What You Actually Get

If you want the best autonomous output, Cursor usually wins. If you want the smoothest guided editing experience, Windsurf is often the most comfortable. If you want the best GitHub-native workflow per dollar, Copilot is the most practical. That ranking is an inference from the current product designs, pricing, and agent models published by each vendor.
What is Grok 4.2: Features, Architecture and Comparisons
Mar 12, 2026
grok-4-2

What is Grok 4.2: Features, Architecture and Comparisons

Grok 4.2 is xAI’s public-beta flagship in the Grok 4 family: a multi-agent, tool-enabled generation model with industry-leading throughput, a giant 2,000,000-token agent mode context window, and specialized API variants such as grok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning, and grok-4.20-beta-0309-non-reasoning. It’s optimized for fast, agentic workflows (real-time X data / tool calling), is available in Web, iOS/Android and early API channels eg CometAPI, and is aimed at users needing fast, live-data aware assistants rather than the deepest long-form reasoning.
How to Use Grok 4.2 API in 2026
Mar 12, 2026
grok-4-2

How to Use Grok 4.2 API in 2026

Grok 4.2 is xAI’s latest multi-agent reasoning model that combines four cooperating agents and new agentic tool-calling features to deliver much faster, lower-hallucination inference for enterprise workloads. To call it today most developers either (a) use the official xAI REST/gRPC endpoints or (b) call it through an aggregator like CometAPI (single REST endpoint,post https://api.cometapi.com/v1/responsess) which simplifies keys, billing, and multi-model switching.
Grok 4.2: what will it bring and Why It Matters in AI in 2026
Jan 18, 2026
grok-4-2

Grok 4.2: what will it bring and Why It Matters in AI in 2026

Grok 4.2, a sophisticated iteration of Elon Musk’s flagship model. Unlike its predecessors, Grok 4.2 has arrived through a series of "stealth checkpoints"—mysterious model variants appearing on leaderboards under codenames like *Obsidian, Vortex Shade, and Quantum Crow.