grok/grok-4.3: flagship 1M-context, text+image model from grok on OrcaRouter at provider direct pricing
grok/grok-4.3 is a flagship model from grok, offered on OrcaRouter at the provider's direct pricing with no markup. It supports a context window of 1 million tokens – significantly larger than many…
As a flagship model, grok-4.3 is designed for high-level reasoning, long-context comprehension, and multimodal understanding. Its core capabilities include: 1) processing up to 1 million tokens of combined text and image input in a single turn; 2) performing complex analytical tasks such as multi-step reasoning, code generation, and mathematical problem-solving; 3) understanding images and answering questions about visual content; 4) maintaining coherence over very long conversations or documents. It does not support function calling or structured output in a specialized way beyond what the base API provides. Users should note that while the model is powerful, exact performance on specific benchmarks is not disclosed in this catalog. For tasks that do not need the full 1M context or image input, a cheaper or faster model on OrcaRouter may suffice.
Choose grok-4.3 when your task demands the full 1 million token context window or requires image understanding within that long context. Examples include analyzing entire legal documents, reviewing extensive codebases, or studying lengthy research papers with embedded figures. It is also suitable when you need a single model that can handle both text and images without switching providers. If your use case does not involve images or can be satisfied with a shorter context (e.g., 128K tokens), you may find better value in a mid-tier or cheaper model on OrcaRouter, which could offer lower latency and cost. Additionally, if your task is simple and does not require the advanced reasoning of a flagship model, a smaller model may deliver adequate results faster. Always evaluate the cost–benefit trade-off: grok-4.3's price is $1.25/$2.50 per million tokens, which can add up for high-volume usage.
The best use cases for grok-4.3 involve tasks that leverage its massive context and multimodal input. These include: long-form document summarization and Q&A where the entire document fits in context; codebase review across thousands of lines; academic research where papers include figures and tables; legal analysis of contracts and case law; and complex reasoning chains that require the model to refer back to earlier parts of a very long prompt. It is also effective for conversational agents that need to remember full session history without truncation. However, for real-time applications where low latency is critical, the model's large context processing may introduce noticeable delay. Benchmarks for speed are not provided, but longer context generally increases processing time. Users should test with representative workloads on OrcaRouter.
grok-4.3 accepts images as part of the input, typically via the 'image_url' modality in the API message. Images are encoded and fed into the model along with text. The model can describe image contents, answer questions about them, and reason about visual relationships. It does not process video directly, but you can send individual frames as separate images (keeping total tokens within 1M). The exact image resolution and token cost are specified by grok; users should check grok's documentation for details. On OrcaRouter, the API call follows the standard OpenAI multimodal format: include a 'content' array with items of type 'text' and 'image_url'. Image URLs can be publicly accessible or base64-encoded with a 'data:image/...;base64,' prefix. The model's understanding of images is limited to what is visible; it cannot perform OCR or fine-grained visual recognition beyond typical vision-language model capabilities.
Specific benchmark scores for grok-4.3 are not provided in the catalog. As a flagship model from grok, it is expected to perform at a high level on standard LLM benchmarks such as MMLU, HumanEval, and GSM8K, but actual numbers are not listed here. Users who require verifiable performance data should refer to grok's official documentation or run their own evaluations on representative tasks. The absence of benchmark data in this context means that direct comparisons with other models must be made through empirical testing on OrcaRouter. For problem domains where benchmarks matter (e.g., academic or certification tests), it is advisable to test grok-4.3 against your specific prompts and measure accuracy.
Latency for grok-4.3 is not quantified in seconds or tokens per second in the catalog. Generally, flagship models with large context windows have higher latency, especially when processing prompts that fill the entire 1M token limit. Time-to-first-token can be significant due to the need to process the full input before generating any output. On OrcaRouter, response times will also depend on provider-side load and network conditions. For real-time applications, consider using a smaller model with lower context. For offline batch processing, the latency may be acceptable. Users should run latency tests with their typical input sizes to gauge suitability. There is no dedicated speed tier for grok-4.3; it is served at the provider's standard inference speed.
Strengths: Extremely large context window (1M tokens) allows handling of very long documents in a single turn. Multimodal input (text+image) enables integrated visual reasoning. As a flagship model, it likely demonstrates strong language understanding and generation capabilities. Limitations: Higher cost per token compared to cheaper models. No specific benchmark numbers are available to quantify performance. Latency may be high for large contexts. The model does not generate images. It is a general-purpose model, not fine-tuned for narrow domains (though it may still perform well). There is no mention of function calling or structured output support beyond standard API capabilities. Users should verify suitability through their own testing, as catalog data is limited.
grok-4.3 is priced at $1.25 per million input tokens and $2.50 per million output tokens. These are the provider's rates; OrcaRouter passes them through with zero markup. There are no additional fees for API usage beyond token consumption. Payment is billed based on the total tokens processed in each API call. For a typical exchange with 10,000 input tokens and 2,000 output tokens, the cost would be approximately $0.0125 (input) + $0.005 (output) = $0.0175. This pricing applies to both text and image tokens. Image token cost is determined by the provider and is included in the input token count. There are no monthly credits or package discounts mentioned; pricing is pay-as-you-go. Users should monitor their usage to manage costs, especially when processing large contexts.
The trade-off involves balancing capability against cost. grok-4.3 is a flagship model with a 1M context window and image input. If your task does not require that full context or multimodal input, you can select a cheaper model on OrcaRouter – for example, a smaller grok model or a third-party provider's model with lower per-token pricing. Cheaper models may have smaller context windows (e.g., 4K to 128K) and may not support images, but they can significantly reduce your bill. For tasks that fit within a shorter context and are purely text-based, the cost savings can be substantial. Conversely, if you need the long context and multimodal ability, grok-4.3 may be the only option among certain provider lines. Evaluate both input and output token volumes. There is no caching discount mentioned.
The catalog does not specify any caching mechanism or special pricing tiers for grok-4.3. The model is billed per token at the rates listed: $1.25 per million input tokens and $2.50 per million output tokens, with zero markup. OrcaRouter does not add any extra fees. There is no mention of discounted batch processing, monthly subscriptions, or volume discounts. Users should assume standard pay-as-you-go pricing. If caching were available, it might reduce costs for repeated prompts, but that information is not provided. Contact OrcaRouter support for any unpublished pricing options. For high-volume users, it may be worth exploring alternative models or negotiating custom rates directly with the provider.
OrcaRouter charges exactly the rate set by grok for grok-4.3: $1.25 per million input tokens and $2.50 per million output tokens. OrcaRouter does not add any margin. This means you pay the same per-token cost as if you were using grok's own API directly, but you gain access through OrcaRouter's unified API layer. This can simplify integration if you use multiple providers. There are no hidden fees. Token counting is done by OrcaRouter based on the content you send and receive. The base URL for API calls is https://api.orcarouter.ai/v1, and the model ID is 'grok/grok-4.3'. Billing is handled by OrcaRouter, typically on a postpaid basis. Always verify token counts in your dashboard.
To call grok-4.3, send a POST request to https://api.orcarouter.ai/v1/chat/completions with the model parameter set to 'grok/grok-4.3'. The API is OpenAI-compatible, so the request format matches the OpenAI Chat Completions schema. Include an API key issued by OrcaRouter in the Authorization header (Bearer token). For multimodal requests, use a 'content' array with objects of type 'text' or 'image_url'. Example snippet: \n{"model":"grok/grok-4.3","messages":[{"role":"user","content":[{"type":"text","text":"Describe this image"},{"type":"image_url","image_url":{"url":"https://example.com/photo.jpg"}}]}],"max_tokens":500}. The model will then generate a text response. Ensure your total input tokens (including image tokens) plus the response max_tokens do not exceed 1,000,000.
grok-4.3 supports standard chat completion parameters: model (required, set to 'grok/grok-4.3'), messages (required, array of message objects), max_tokens (integer, maximum output tokens), temperature (float, controls randomness, typically 0-2), top_p (float, nucleus sampling), frequency_penalty and presence_penalty (floats), stop (string or array of strings), and stream (boolean). Not all parameters may have an effect; for example, temperature and top_p are often both functional. For multimodal input, the 'content' field of a user message can be an array. There is no parameter for image quality or detail; use standard image_url format. The model may also support system messages. For best results, use a system message to set the assistant's behavior. Check OrcaRouter's documentation for any provider-specific parameters.
Migrating involves changing the API endpoint and model identifier. If you previously called grok-4.3 directly via grok's API, update your code to use OrcaRouter's base URL (https://api.orcarouter.ai/v1) and model ID 'grok/grok-4.3'. Replace your API key with one from OrcaRouter. The message format remains identical as both are OpenAI-compatible. If you were using a different model on OrcaRouter and want to switch to grok-4.3, simply change the model name in your requests. No other code changes are needed. Test with a single query to confirm connectivity and pricing. Note that response behavior may differ slightly due to provider-side inference configurations. For high-traffic migration, consider gradual rollout.
Authentication is done via an API key provided by OrcaRouter. Include this key in the 'Authorization' header as 'Bearer YOUR_API_KEY'. You must obtain a valid key from OrcaRouter's dashboard or through their account setup. There is no additional authentication method supported. The key should be kept confidential. OrcaRouter may rate-limit requests based on your plan. Include the header in every request. For security, avoid hardcoding keys in client-side code. If you encounter authentication errors, verify the key and that it has access to the 'grok/grok-4.3' model. There are no separate keys per model; one key grants access to all models within your allowed scope.
The catalog does not list other flagship models with specific comparisons. Generally, grok-4.3 stands out for its 1M token context window, which is among the largest offered. Many flagship models have context windows of 128K or 200K tokens. The multimodal support (text+image) is also a feature, though not unique. Its price of $1.25/$2.50 per million tokens is comparable to some premium models, but others may be cheaper or more expensive. Without benchmark data, direct quality comparisons are impossible. Users should consider their required context length and modality. If a shorter context suffices, a cheaper model may offer similar performance. For the longest context needs, grok-4.3 is a strong candidate.
grok may offer other models (e.g., smaller versions or specialized variants), but the catalog only lists grok-4.3. Assuming there are other grok models with lower context limits or no image support, grok-4.3 would be preferred when you need the full 1M context and image understanding. If you only need text and a smaller context, a cheaper grok model could reduce costs. Since grok-4.3 is the flagship, it is likely the most capable but also the most expensive. If your task does not require the highest capability, consider a less expensive option. Without specific data on other grok models, the decision must be based on context and modality requirements.
Alternatives available on OrcaRouter that combine image input with long context include other multimodal models from various providers. For example, models with 128K context and image capabilities may be suitable. grok-4.3's 1M context is unique. If you do not need the full 1M, a model with 128K context may be cheaper and faster. However, if your images are part of a very long document, grok-4.3 may be the only option. Users should compare exact token pricing, context limits, and reported performance. Since benchmark data is lacking, test with your own data. OrcaRouter supports switching models easily, so you can try multiple alternatives.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1from openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key="$ORCAROUTER_API_KEY",
)
response = client.chat.completions.create(
model="grok/grok-4.3",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)include_reasoninglogprobsmax_completion_tokensmax_tokensnparallel_tool_callsreasoningreasoning_effortresponse_formatsearch_parametersseedstreamstream_optionsstructured_outputstemperaturetool_choicetoolstop_logprobstop_puserweb_search_options| Input / 1M tokens | $1.25 |
| Output / 1M tokens | $2.50 |
| Cache read / 1M | $0.200 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
@misc{orcarouter_grok_4_3,
title = {grok/grok-4.3 API},
author = {grok},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/grok/grok-4.3}
}grok. (n.d.). grok/grok-4.3 API. OrcaRouter. https://www.orcarouter.ai/models/grok/grok-4.3