Grok 4.3 on Amazon Bedrock: API Access Guide, Setup, and Code Examples (2026)

On June 22, 2026, AWS's weekly roundup flagged Grok 4.3 in Amazon Bedrock. The official AWS model card says the model launched on June 15, uses the model ID xai.grok-4.3, supports a 1M token context window, and runs on Bedrock's new bedrock-mantle endpoint.

That sounds like a small platform note. It isn't. It means xAI is now in the same enterprise distribution lane as the other frontier providers AWS already hosts, and developers who already use OpenAI-compatible clients can get to Grok 4.3 without rewriting their whole stack.

The catch is simple: this is not a normal Bedrock setup. If you reach for boto3 first, you'll waste time. Grok 4.3 on Bedrock wants the OpenAI-compatible path, the right endpoint, and a little more care around region and routing than the usual copy-paste tutorial.

What Actually Changed

AWS says Grok 4.3 is reasoning-first, with configurable reasoning effort, strong tool use, and a 1M context window. The model card also lists standard, priority, and flex tiers, which matters more than marketing copy does. It means you can choose between lower-friction access and more predictable throughput depending on workload.

For developers, the important part is the endpoint change. AWS documents this model on bedrock-mantle with an OpenAI-style base URL:

https://bedrock-mantle.us-west-2.api.aws/openai/v1

That is why KissAPI-style unified clients work so well here. You keep one SDK shape, swap the base URL, and route the model like any other OpenAI-compatible endpoint.

When Grok 4.3 Makes Sense

I would reach for Grok 4.3 when the job needs long context, multi-step reasoning, or document-heavy workflows that should stay inside AWS. The model card calls out contract review, case law research, credit agreement analysis, and financial Q&A. That lines up with the kind of work where longer reasoning and deterministic API access matter more than leaderboard drama.

If you're already routing through KissAPI, this is the kind of model you can add as a premium reasoning backend while keeping cheaper models for routine tasks. That's usually the right shape: spend on the hard stuff, not on every greeting and summary.

Minimal Setup

Install the OpenAI SDK and point it at the Bedrock Mantle endpoint. Keep the model ID exact.

pip install openai

export OPENAI_API_KEY="<your-bedrock-api-key>"
export OPENAI_BASE_URL="https://bedrock-mantle.us-west-2.api.aws/openai/v1"

Then call the model with the Responses API style that AWS documents for this endpoint.

curl

curl https://bedrock-mantle.us-west-2.api.aws/openai/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "xai.grok-4.3",
    "input": "Summarize the tradeoffs of running Grok 4.3 on Amazon Bedrock for enterprise document analysis."
  }'

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["OPENAI_API_KEY"],
    base_url=os.environ["OPENAI_BASE_URL"],
)

response = client.responses.create(
    model="xai.grok-4.3",
    input="Review this procurement contract and list the risky clauses first."
)

print(response.output_text)

Node.js

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  baseURL: process.env.OPENAI_BASE_URL,
});

const response = await client.responses.create({
  model: "xai.grok-4.3",
  input: "Draft a concise risk summary for this credit agreement.",
});

console.log(response.output_text);

If you want the same shape across several providers, this is where a gateway like KissAPI earns its keep. One base client, one routing layer, and a much smaller chance of breaking production when the next model lands.

What Will Break If You Assume Too Much

The biggest mistake is treating Grok 4.3 like a standard Bedrock runtime model. AWS's own docs make it plain that this model uses bedrock-mantle, not the usual Bedrock runtime flow.

1. Don't use the wrong endpoint. If you hit the wrong path, you'll burn time debugging a client problem that is really just a routing problem.
2. Don't hardcode the region without checking availability. The model card shows support in us-west-2, us-east-1, and us-east-2 at launch.
3. Don't send a giant prompt blob without measuring it. A 1M context window is not a license to be sloppy.
4. Don't forget tier selection. Standard, priority, and flex are there for a reason.

On the cost side, the sane move is to keep the expensive model for the cases that actually need it. Use token counting before you ship, and use routing rules when the task does not justify a frontier model. That's the same discipline that keeps API bills sane across the rest of your stack.

Practical Routing Advice

Here's the heuristic I like:

• Use a cheaper model for short prompts, classification, and quick edits.
• Use Grok 4.3 for long documents, multi-step reasoning, or high-value enterprise workflows.
• Keep a second provider ready in case your region, quota, or tier gets messy.

That last point matters. Distributed access is useful, but it is not a substitute for failover. If your app needs to stay up, keep a fallback route and watch usage like a hawk. A tool like KissAPI helps here because you can keep the client code stable while changing the model behind it.

FAQ