I tried xAI's Grok 4.6, which became available on Amazon Bedrock

Introduction

On August 19, 2026, AWS What's New announced support for xAI Grok 4.6 on Amazon Bedrock.

https://aws.amazon.com/jp/about-aws/whats-new/2026/08/amazon-bedrock-grok-4-6/

xAI released Grok 4.6 on August 12, 2026, and it took about one week to become available on Bedrock.

https://x.ai/news/grok-4-6

Grok 4.3 was exclusive to the bedrock-mantle endpoint, but the Grok 4.6 model card lists both bedrock-mantle and bedrock-runtime.

https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-xai-grok-4-6.html

In this article, I verified whether the IAM authentication and OpenAI-compatible API via bedrock-mantle used with Grok 4.3 also work with Grok 4.6. I also checked whether invocation via bedrock-runtime is possible.

Changes

Here is a summary of the changes from Grok 4.3, the previous version available on Bedrock, to 4.6. While xAI officially released versions in the order 4.3 → 4.5 → 4.6, 4.5 was not offered on Bedrock, jumping directly from 4.3 to 4.6.

Sources: Grok 4.6 Model Card, Grok 4.3 Model Card (both confirmed on: 2026-08-19)

Pricing

Comparing On-Demand pricing per 1M tokens.

Note that the bedrock-mantle verified in this article uses an In-Region configuration, so the "In-Region" unit price in the table applies to Grok 4.6.

Verification Details

I confirmed that Grok 4.6 can currently be invoked via the bedrock-mantle endpoint. For authentication, I used temporary AWS credentials obtained via AssumeRole on an IAM Role. The flow involves generating a short-lived Bearer Token once using aws-bedrock-token-generator, passing it to an OpenAI SDK client, and reusing it across multiple API calls.

Obtaining the Bearer Token

I assumed a test IAM Role via AssumeRole to set temporary AWS credentials, then obtained a Bearer Token with provide_token.

# Assume the test IAM Role via AssumeRole and set temporary AWS credentials as environment variables
assume_json="$(aws sts assume-role \
  --role-arn "$GROK_ROLE_ARN" \
  --role-session-name grok-4-6-reproduction \
  --duration-seconds 3600 \
  --output json)"
read -r access_key secret_key session_token < <(
  printf '%s' "$assume_json" | python3 -c '
import json, sys
c = json.load(sys.stdin)["Credentials"]
print(c["AccessKeyId"], c["SecretAccessKey"], c["SessionToken"])
'
)
export AWS_ACCESS_KEY_ID="$access_key"
export AWS_SECRET_ACCESS_KEY="$secret_key"
export AWS_SESSION_TOKEN="$session_token"

from aws_bedrock_token_generator import provide_token
from openai import OpenAI

region = "us-west-2"
base_url = f"https://bedrock-mantle.{region}.api.aws/openai/v1"

# The Bearer Token is generated only once and reused for all subsequent calls via the client
token = provide_token(region=region)
client = OpenAI(base_url=base_url, api_key=token)

All subsequent calls reused the same client created above.

Text Generation

I ran the same prompt using both Chat Completions and Responses. Both returned a "Hello" response.

response = client.chat.completions.create(
    model="xai.grok-4.6",
    messages=[{"role": "user", "content": "Hello とだけ短く返してください。"}],
)
print(response.choices[0].finish_reason)
print(response.choices[0].message.content)
print(response.usage.model_dump(mode="json"))

Execution result (actual measurement, JSON):

{
  "id": "chatcmpl-<REQUEST_ID>",
  "finish_reason": "stop",
  "content": "Hello",
  "usage": {
    "completion_tokens": 151,
    "prompt_tokens": 38,
    "total_tokens": 189,
    "completion_tokens_details": {
      "reasoning_tokens": 141
    }
  }
}

response = client.responses.create(
    model="xai.grok-4.6",
    input="Hello とだけ短く返してください。",
)
print(response.output_text)
print(response.usage.model_dump(mode="json"))

Execution result (actual measurement, JSON):

{
  "id": "resp_<REQUEST_ID>",
  "output_text": "Hello",
  "usage": {
    "input_tokens": 38,
    "output_tokens": 225,
    "output_tokens_details": {
      "reasoning_tokens": 215
    },
    "total_tokens": 263
  }
}

Image Input

Using the client created in the previous section, I passed an image to Chat Completions. I provided a Base64-encoded PNG image as an image_url and instructed the model to describe the logo and text in the image in Japanese.

PNG image used for verification

import base64
from pathlib import Path

# Verification image in the repository
image_path = Path("test-inputs/aws-kiro.png")
image_data = base64.b64encode(image_path.read_bytes()).decode("ascii")

response = client.chat.completions.create(
    model="xai.grok-4.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "この画像を日本語で簡潔に解説してください。画像内の文字も読み取ってください。"},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_data}"}},
            ],
        }
    ],
)
print(response.choices[0].message.content)

Execution result (actual measurement, JSON excerpt):

{
  "finish_reason": "stop",
  "content": "紫色の角丸四角形内に白い幽霊アイコン（黒い目2つ）があり、右に白い大文字で「KIRO」と書かれたロゴです。黒い背景。",
  "usage": {
    "prompt_tokens": 815,
    "completion_tokens": 221,
    "total_tokens": 1036,
    "reasoning_tokens": 172
  }
}

A response was returned that correctly identified both the shapes and the text within the logo. Text responses via bedrock-mantle (both Chat Completions and Responses) and image analysis (Chat Completions) all worked as expected.

bedrock-runtime Verification

Using temporary credentials obtained by assuming a Runtime-dedicated IAM Role, I executed the following Converse API call.

aws bedrock-runtime converse \
  --region us-west-2 \
  --model-id us.xai.grok-4.6 \
  --messages '[{"role":"user","content":[{"text":"Hello とだけ短く返してください。"}]}]' \
  --output json

The execution result was as follows.

aws: [ERROR]: An error occurred (ValidationException) when calling the Converse operation: The provided model identifier is invalid.

I also checked the availability of inference profiles in both us-west-2 and us-east-1.

for region in us-west-2 us-east-1; do
  aws bedrock list-inference-profiles \
    --region "$region" \
    --query "inferenceProfileSummaries[?contains(inferenceProfileId, 'xai.grok')].{id:inferenceProfileId,name:inferenceProfileName}" \
    --output json
done

No Grok/xAI-related profiles were found in either region. Once inference profiles become available, I plan to revisit and verify invocation via bedrock-runtime.

Checking Data Retention Settings

In Bedrock, whether to retain input and output during inference is controlled by the data retention mode set at the account or project level. The model also declares the modes it permits as allowed_modes. This can be confirmed by retrieving model information with a previously generated Bearer Token.

curl -s https://bedrock-mantle.us-west-2.api.aws/v1/models/xai.grok-4.6 \
  -H "Authorization: Bearer $GROK_BEDROCK_TOKEN"

{
    "created": 1786492800,
    "data_retention": {
        "allowed_modes": [
            "provider_data_share",
            "none",
            "default"
        ],
        "mode": "default",
        "source": "model_default"
    },
    "id": "xai.grok-4.6",
    "object": "model",
    "owned_by": "system",
    "status": "available"
}

mode was default and source was model_default. The account side was confirmed as inherit using the following command, so the model's default applies as-is.

aws bedrock get-account-data-retention --region us-west-2

{
    "mode": "inherit"
}

With default, AWS may retain input and output for abuse detection purposes, but they are not passed to the model provider. Since none is also included in allowed_modes, zero data retention can also be selected. The meaning of each mode is summarized on the following page.

https://docs.aws.amazon.com/bedrock/latest/userguide/data-retention.html

Summary

xAI positions Grok 4.6 as a high-end model across various benchmarks. That Grok 4.6 is now supported on Amazon Bedrock, making it possible to use it with IAM authentication and within an AWS-only environment.

The pricing is $2.20 for input and $6.60 for output per 1M tokens, placing it in a mid-range tier that is easy to compare with Claude Sonnet 5 and GPT-5.6 Terra. It has the potential to become a strong candidate as an alternative to Claude or OpenAI.