xAI
Grok 4.3
Released 
April 2026

xAI
Grok 4.3

xAI's reasoning-first flagship with a 1M-token context, configurable reasoning effort, and leading agentic tool-calling on independent benchmarks.

Modality:
Text
Image
Video
PDF
model ID
x-ai/grok-4.3

Output Speed

N/A
tok/s

Intelligence Index

37.9
/ 100

Context Window

1000000
tokens

Input price

7.5
Anytoken

Output price

15
Anytoken
Grok 4.3: Reasoning-First Agentic Model With a 1M-Token Context Grok 4.3 is xAI's reasoning-first flagship, built on an improved architecture over Grok 4.20 with a December 2025 knowledge cutoff. It accepts text and image input, returns text, and exposes a 1M-token context window with configurable reasoning effort (none, low, medium, high). Its strongest evidence-backed differentiator is agentic performance: independent testing shows a large jump on real-world agentic tasks and strong instruction-following. Multi-step agents, long-document analysis, and accuracy-critical enterprise workflows such as case-law and financial document review benefit most from Grok 4.3 via API. Start building with Grok 4.3 via the AnyAPI.ai API.

Performance

Where Grok 4.3 Earns Its Place: Agentic Tool Use

Grok 4.3 is strongest on multi-step agentic work and instruction following. Independent testing by Artificial Analysis records an Elo of 1500 on the GDPval-AA agentic benchmark, up 321 points from Grok 4.20, plus 98% on 𝜏²-Bench Telecom and 81% on IFBench. Because reasoning is always active and configurable, it holds context more reliably across long agent loops rather than skipping thinking on hard steps. In production this translates into fewer dropped instructions and more consistent tool-calling behavior for customer-support automation and multi-step research agents that run many sequential API calls.

Benchmarks

Grok 4.3 on the Artificial Analysis Intelligence Index

On Artificial Analysis, Grok 4.3 (high) scores 38 on the Intelligence Index v4.1.1, above the comparable-model median of 35, and is rated notably fast though somewhat verbose. The standout independent result is agentic: a GDPval-AA Elo of 1500, surpassing several frontier models, though it still trails GPT-5.5 (xhigh) by 276 Elo, an expected win rate near 17%. It also gains on AA-Omniscience accuracy but with a lower non-hallucination rate than Grok 4.20. Interpretation: pick Grok 4.3 for agentic throughput and instruction adherence, and verify factual precision on your own data.

Output Speed

N/A
tok/s

Intelligence Index

37.9
/ 100

MMLU

Broad world knowledge and problem-solving
0
%

GPQA

PhD-level scientific reasoning across physics, biology, chemistry.
90
%

HLE

Adherence to multi-step structured instructions.
37
%

LiveCodeBench

Tool-calling reliability in long agentic loops.
0
%

Technical Specifications

What the model supports

Grok 4.3 accepts text and image input and returns text; it is not an image, audio, or video output model. The 1M-token context window suits long documents and multi-document agent loops, but it is distinct from generation limits and from tiered billing above 200K total tokens. Reasoning is always active with configurable effort (none, low, medium, high; default low), which shapes both latency and cost per call. Function calling and JSON-schema structured outputs are supported, along with prompt caching. Treat the always-on reasoning as a consistency feature that also adds token overhead on simple requests.
Verified Specifications — 
Grok 4.3
Input modalities
Text
Image
Video
PDF
output modalities
Text
Context window
1000000
 tokens
Maximum output tokens
1000000
Reasoning
Yes
Knowledge cutoff
April 2026
Pricing (standard)
7.5
 AnyTokens in
 / 
15
 AnyTokens out

Quickstart

Sample code for Grok 4.3

import requests

url = "https://api.anyapi.ai/v1/chat/completions"

payload = {
    "model": "x-ai/grok-4.3",
    "messages": [
        {
            "role": "user",
            "content": "Hello"
        }
    ]
}
headers = {
    "Authorization": "Bearer anyapi_api_key",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)
import requests url = "https://api.anyapi.ai/v1/chat/completions" payload = { "model": "x-ai/grok-4.3", "messages": [ { "role": "user", "content": "Hello" } ] } headers = { "Authorization": "Bearer anyapi_api_key", "Content-Type": "application/json" } response = requests.post(url, json=payload, headers=headers) print(response.text)
View docs
Copy
Code is copied
import requests

url = "https://api.anyapi.ai/v1/chat/completions"

payload = {
    "model": "x-ai/grok-4.3",
    "messages": [
        {
            "role": "user",
            "content": "Hello"
        }
    ]
}
headers = {
    "Authorization": "Bearer anyapi_api_key",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)
import requests url = "https://api.anyapi.ai/v1/chat/completions" payload = { "model": "x-ai/grok-4.3", "messages": [ { "role": "user", "content": "Hello" } ] } headers = { "Authorization": "Bearer anyapi_api_key", "Content-Type": "application/json" } response = requests.post(url, json=payload, headers=headers) print(response.text)
View docs
Copy
Code is copied
curl --request POST \
  --url https://api.anyapi.ai/v1/chat/completions \
  --header 'Authorization: Bearer anyapi_api_key' \
  --header 'Content-Type: application/json' \
  --data '
{
  "model": "x-ai/grok-4.3",
  "messages": [
    {
      "role": "user",
      "content": "Hello"
    }
  ]
}
'
curl --request POST \ --url https://api.anyapi.ai/v1/chat/completions \ --header 'Authorization: Bearer anyapi_api_key' \ --header 'Content-Type: application/json' \ --data ' { "model": "x-ai/grok-4.3", "messages": [ { "role": "user", "content": "Hello" } ] } '
View docs
Copy
Code is copied
View docs
Code examples coming soon...

Comparison

Grok 4.3 vs Grok 4.20: What Actually Changes?

Grok 4.3 is the direct architectural successor to Grok 4.20, matching its pretraining scale with an improved architecture and a December 2025 knowledge cutoff. Both target agentic and long-context workloads, but Grok 4.20 carries a larger 2M-token context window, while Grok 4.3 uses 1M. The realistic decision is between raw context capacity and updated behavior: Grok 4.3 delivers materially better agentic task performance and cost-per-intelligence, whereas Grok 4.20 leads on non-hallucination rate and offers more context headroom for very large document sets.

Dimension
Grok 4.3
Grok 4.5
Context window
1000000
tokens
500000
tokens
Output speed
N/A
tok/s
49.34
tok/s
Intelligence Index
37.9
55.8
Input pricing
7.5
AnyToken
12
AnyToken
Output pricing
15
AnyToken
36
AnyToken
Knowledge cutoff
April 2026
July 2026

Choose Grok 4.3 when agentic tool use, instruction following, and cost-per-intelligence matter most — it posts a large GDPval-AA gain over 4.20 and lower cost to run the benchmark suite. Choose Grok 4.20 when you need the 2M-token context window for extremely large inputs, or when non-hallucination rate is the priority, since Grok 4.20 still leads Grok 4.3 on that metric. For most new agent builds, Grok 4.3 is the stronger default.

Limitations & Trade-offs

Where Grok 4.3 falls short

1
Smaller context than sibling models. Grok 4.3 offers a 1M-token window, but Grok 4.20 and Grok 4.1 Fast reach 2M tokens. For workloads that must hold extremely large corpora — full codebases, massive document bundles, or entire case files — in a single pass, a 2M-context sibling may be preferable. The 1M window is generous for most RAG and agent tasks, but it is not the largest option in the Grok lineup, so validate that your inputs fit before committing.
2
Always-on reasoning adds overhead. Reasoning is always active and cannot be fully disabled in the same way as a plain chat model; the lowest setting is 'none' but the default is 'low' and the model behaves as reasoning-first. This improves consistency across agent loops but adds token and latency overhead on trivial requests. For simple, high-volume classification or extraction where deep reasoning adds no value, a non-reasoning model may be cheaper and faster.
3
Verbosity and hallocation trade-off. Independent testing rates Grok 4.3 as somewhat verbose, generating more output tokens than the median on the Intelligence Index. It also gained accuracy on AA-Omniscience but at the cost of a lower non-hallucination rate than Grok 4.20. For factuality-critical outputs, budget for verification and consider constraining output, since verbose generations increase output token cost and Grok 4.20 still leads on non-hallucination.
4
Tiered long-context billing. Requests exceeding 200K total tokens are billed at a higher rate. This makes Grok 4.3 economical for typical prompts but comparatively more expensive once you fill a large share of the 1M window. High-volume pipelines that routinely push past the 200K threshold should model the higher tier into cost planning rather than assuming a flat rate across the full context window.

Best-Fit Workloads

Where this model earns its place

01

Multi-step agentic automation


Grok 4.3's strongest evidence is agentic: a GDPval-AA Elo of 1500 (up 321 points over Grok 4.20) and 98% on 𝜏²-Bench Telecom. Always-on, configurable reasoning helps it stay on-task across long tool-calling loops. This fits customer-support automation, workflow agents, and research agents that chain many sequential API calls, where dropped instructions or skipped reasoning steps break the loop.

02

Long-document and multi-document analysis

The 1M-token context window lets Grok 4.3 ingest extensive reports, policy manuals, research packets, or code fragments in a single request. Paired with medium or high reasoning effort, it supports deep synthesis across many sources. This suits legal, financial, and technical review pipelines — but note tiered billing above 200K tokens and confirm the model reasons accurately over selected material rather than being distracted by low-value content.

03

Enterprise accuracy-critical Q&A


Grok 4.3 ranks well in enterprise domains such as case-law and corporate-finance analysis, and independent testing shows strong instruction following (81% IFBench). It fits contract review, credit-agreement analysis, and financial document Q&A where structured, schema-constrained outputs matter. Because its non-hallucination rate trails Grok 4.20, pair it with retrieval grounding and verification for outputs that carry compliance or financial risk.

04

Tool-driven data extraction with structured outputs


With native function calling and JSON-schema structured outputs, Grok 4.3 can drive pipelines that must return machine-parseable results from unstructured input. Combined with image input, it handles document-plus-screenshot extraction tasks. Keep reasoning effort low for high-throughput extraction to control latency and token overhead, reserving medium or high for records requiring judgment.

Pricing in anytokens via AnyAPI
Input
7.5
Output
15
Cache write
Cache read
1.2

Integration

Access Grok 4.3 via AnyAPI.ai

Access Grok 4.3 through AnyAPI.ai using a unified API built for multi-model AI applications. Integrate Grok 4.3 without maintaining a separate provider-specific connection, and keep the flexibility to test, switch, or combine models as your application requirements evolve.

01

One API integration

Access Grok 4.3 and other AI models through the same API workflow instead of maintaining separate integrations for every provider.

02

Easy model switching

Test Grok 4.3 against alternative models or switch models as your performance, capability, or cost requirements change without rebuilding your application around another provider API.

03

Flexible for production

Use Grok 4.3 from experimentation through production while keeping your AI stack flexible as workloads, traffic, and model requirements evolve.

04

Multi-model applications

Use Grok 4.3 for the workloads where it performs best and combine it with other models for tasks that require different capabilities, performance, or efficiency.

Frequently Asked Questions

Answers to common questions about integrating and using this AI model via AnyAPI.ai

Grok 4.3 supports a 1,000,000-token context window via the xAI API. That is smaller than sibling models Grok 4.20 and Grok 4.1 Fast, which reach 2M tokens. Note that requests exceeding 200K total tokens are billed at a higher tiered rate, so plan large-context pipelines accordingly.

Yes. Grok 4.3 is a reasoning-first model with configurable reasoning effort — none, low, medium, and high — set via the reasoning/reasoning_effort parameter, defaulting to low. Reasoning is always active by default, which improves consistency across multi-step agent loops but adds token and latency overhead on simple requests.

Grok 4.3 accepts text and image input and returns text output. It is not an audio or video output model, and does not generate images. Some integrations also report file/PDF input support. Confirm exact modality behavior against current xAI documentation for your specific endpoint.

Grok 4.3 is strongest on agentic tool use and instruction following. Independent testing shows a GDPval-AA Elo of 1500, a large jump over Grok 4.20, plus 98% on 𝜏²-Bench Telecom and 81% on IFBench. Its Artificial Analysis coding index (composite) is around 42%, so it is capable but not primarily a coding specialist.

Grok 4.3 is the improved-architecture successor to Grok 4.20 with a December 2025 knowledge cutoff. It delivers materially better agentic performance and cost-per-intelligence, but has a smaller 1M-token context (versus 2M) and a lower non-hallucination rate. Choose Grok 4.20 for maximum context or factual precision, Grok 4.3 for agentic work.