What is Grok 4.3?
Grok 4.3 is a general-purpose multimodal model provided by xAI. Its canonical API identifier is grok-4.3, and xAI documents grok-4.3-latest as an alias. In practical terms, it is a text-generation and reasoning model that can also inspect images supplied in a request.
The model is intended for long-document analysis, coding, research, enterprise question answering, structured extraction and agentic applications. An agentic application is one in which the model can call external functions or tools instead of responding only with information already in the conversation. Grok 4.3 supports this style of use through function calling and xAI’s server-side tools.
xAI describes Grok 4.3 as fast and reliable, with strong instruction-following and tool-calling capabilities. Those descriptions are provider claims rather than independent benchmark results. The supplied documentation does not provide a specific benchmark score or a published maximum output-token value.
Where Grok 4.3 fits in xAI’s lineup
Grok 4.3 is documented as a current xAI API model and is available through the xAI API, with general availability through Amazon Bedrock in supported regions. xAI’s model documentation also states that older identifiers, including Grok 3 and several Grok 4 fast variants, were redirected to Grok 4.3 after their May 15, 2026 retirement from the xAI API.
This positioning makes Grok 4.3 a practical general-purpose choice rather than a narrowly specialized model. It is built to handle ordinary instruction following as well as large-context analysis, reasoning-heavy tasks and workflows that need external information or actions. The model should not be confused with the broader Grok consumer service, which may expose additional features such as voice, image generation or video generation. Grok 4.3 itself produces text output only.
One-million-token context and configurable reasoning
Grok 4.3 has a documented context window of one million tokens. A context window is the amount of input and generated conversation material the model can consider in a request. This capacity is useful for large document collections, extensive codebases, long transcripts, retrieval-heavy applications and conversations that would exceed the limits of many smaller-context models.
A large context window does not mean that every long prompt will be inexpensive or equally easy to analyze. xAI applies higher long-context rates to requests reaching or exceeding 200,000 prompt tokens, and very large inputs can still require careful document organization. For best results, applications should provide clear instructions and relevant source material rather than treating the context window as a reason to include every available file.
The model supports configurable reasoning effort. The documented settings are none, low, medium, high and xhigh, with low identified as the default. The setting controls how much additional reasoning the model applies to a request; it is not a separate model identity. No reasoning can reduce latency for straightforward tasks, while higher settings are intended for more complex analysis and multistep problems. Higher reasoning effort may increase response time and token consumption, so it should be reserved for tasks that benefit from deeper deliberation.
Supported inputs and outputs
Grok 4.3 accepts text and image inputs and returns text. Its image understanding makes it suitable for tasks such as describing a supplied image, extracting information from visual material or combining screenshots with written instructions. The supplied model data does not identify audio or video input support for this API model.
Its output is text rather than a directly generated image, audio track or video. This distinction matters because the wider Grok product ecosystem includes image and video generation, but those consumer capabilities should not be attributed to the Grok 4.3 API model. If an application needs native media generation, a different xAI product or another specialized service may be more appropriate.
Grok 4.3 supports structured outputs, allowing an application to request responses that follow a predefined machine-readable schema. This is useful for extracting fields from documents, classifying records, producing API-ready objects and reducing the cleanup required after a model response. The supplied documentation confirms structured outputs but does not independently confirm a separate legacy JSON mode, so a distinct JSON-mode capability should not be assumed.
Tools, coding and API features
Function calling allows Grok 4.3 to select an application-defined function and provide the arguments needed to run it. The application, rather than the model, performs the actual external operation. This pattern can connect the model to databases, business systems, search services, calculators or workflow actions while keeping control of execution in the surrounding software.
xAI also documents support for web search and X search when those tools are enabled in a request. These tools can provide current external information during a request, which is useful for research and questions involving recent events. They do not change the model’s underlying training-data cutoff, and the supplied official documentation does not publish an exact cutoff for Grok 4.3.
For coding, the model is suited to generating and explaining code, reviewing existing code, working through debugging problems and analyzing large repositories. Its one-million-token context can be useful when a task depends on relationships across many files. However, the research does not establish a specific software-engineering benchmark score, execution environment or guaranteed ability to run code. Applications should use an explicit execution or testing system when generated code must be validated.
Additional API features include streaming, prompt caching and batch processing for supported requests. Streaming lets an application display output as it is generated instead of waiting for the complete response. Prompt caching can reduce the cost of repeated input material when supported by the API. The Batch API is useful for offline or high-volume processing where immediate responses are not required.
Grok 4.3 API pricing
According to the supplied xAI pricing information, standard requests below 200,000 prompt tokens cost:
| Usage type | Price |
|---|---|
| Input tokens | $1.25 per million tokens |
| Cached input tokens | $0.20 per million tokens |
| Output tokens | $2.50 per million tokens |
Requests reaching or exceeding 200,000 prompt tokens use long-context rates:
| Usage type | Long-context price |
|---|---|
| Input tokens | $2.50 per million tokens |
| Cached input tokens | $0.40 per million tokens |
| Output tokens | $5.00 per million tokens |
These are usage-based API prices, not a consumer subscription fee. The threshold applies to prompt length, so a workflow that sends very large inputs should estimate costs using the long-context rates. Caching may lower the cost of repeated input material, but it does not make all long-context processing inexpensive. The supplied research does not provide a maximum output-token limit.
Main strengths and limitations
Grok 4.3’s clearest strength is the combination of long context and adjustable reasoning. It can hold a large amount of source material while still supporting tool calls, structured responses and coding-oriented work. The standard input and output rates are also comparatively economical for a model positioned at this capability level, although long-context requests cost more.
- Long inputs: The one-million-token context window supports large documents, codebases and retrieval-heavy prompts.
- Flexible reasoning: Five documented reasoning-effort settings allow applications to trade depth against latency and cost.
- Agent integration: Function calling, web search, X search and structured outputs support production workflows.
- Multimodal understanding: Image input can be combined with text instructions, while text remains the output format.
- Operational features: Streaming, caching and batch processing support different latency and throughput requirements.
The limitations are equally important. Grok 4.3 does not natively generate images, audio or video. Its exact knowledge cutoff is unpublished, so current-information tasks should use the documented search tools and still be checked. Tool access also does not guarantee that search results are complete or correct. Finally, the supplied documentation does not establish a maximum output length, a fine-tuning option or a separate legacy JSON mode.
When to choose Grok 4.3
Choose Grok 4.3 when the application needs to combine several of the following requirements:
- Analysis of very large documents, repositories or conversation histories.
- Adjustable reasoning depth for tasks ranging from quick answers to complex multistep analysis.
- Text and image understanding with text responses.
- Structured extraction or schema-constrained responses.
- Function calling and access to current information through web or X search.
- Usage-based pricing with caching and batch options for operational efficiency.
It is particularly suitable for research assistants, enterprise question-answering systems, document-processing pipelines, coding assistants and agents that need to connect model output to external tools.
Another option may be more appropriate when the priority is native media generation, audio or video interaction, a specifically published output limit, a verified knowledge-cutoff guarantee or a narrowly optimized specialist workflow. A smaller or faster model may also be preferable for short, repetitive requests where a one-million-token context and higher reasoning settings provide little benefit. Conversely, if a request routinely crosses the 200,000-token threshold, the higher long-context rates should be compared with alternatives before deployment.
Bottom line
Grok 4.3 is best understood as a long-context, text-output reasoning model for xAI’s API ecosystem. It combines a one-million-token context window with configurable reasoning, image understanding, structured outputs, tool calling, search integrations, caching and batch processing. Its strongest use cases involve large or complex inputs that must be analyzed, transformed or connected to external systems. Its main boundaries are the absence of native media generation, an unpublished knowledge cutoff and missing confirmation for some limits and modes. For applications that fit those boundaries, it offers a practical balance of context capacity, capability and usage-based cost.