I tried OpenAI GPT-6 Astra, which became generally available on Amazon Bedrock
This page has been translated by machine translation. View original
Introduction
On September 8, 2026, OpenAI's GPT-6 Astra became generally available on Amazon Bedrock.
I tried calling GPT-6 Astra via the Converse/OpenAI-compatible path of bedrock-runtime and the OpenAI-compatible path of bedrock-mantle.
Verification Details
Model List
I retrieved a list of foundation models filtered to the OpenAI provider.
aws bedrock list-foundation-models \
--by-provider OpenAI \
--region us-east-1
The returned list included the following entry.
{
"modelArn": "arn:aws:bedrock:us-east-1::foundation-model/openai.gpt-6-astra",
"modelId": "openai.gpt-6-astra",
"modelName": "GPT-6 Astra",
"providerName": "OpenAI",
"inputModalities": [
"TEXT",
"IMAGE"
],
"outputModalities": [
"TEXT"
],
"responseStreamingSupported": true,
"customizationsSupported": [],
"inferenceTypesSupported": [
"INFERENCE_PROFILE"
],
"modelLifecycle": {
"status": "ACTIVE",
"startOfLifeTime": "2026-09-08T17:00:00+00:00"
}
}
The model ID is openai.gpt-6-astra, the input supports text and images, and the output is text. Response streaming is also supported.
Converse
While the model ID appearing in the list is openai.gpt-6-astra, the ID to specify when invoking is global.openai.gpt-6-astra. I ran Converse against us-east-1.
aws bedrock-runtime converse \
--region us-east-1 \
--model-id global.openai.gpt-6-astra \
--messages '[{"role":"user","content":[{"text":"Say ok"}]}]' \
--inference-config '{"maxTokens":64}'
The response was as follows.
{
"output": {
"message": {
"role": "assistant",
"content": [
{
"text": "ok"
}
]
}
},
"stopReason": "end_turn",
"usage": {
"inputTokens": 8,
"outputTokens": 5,
"totalTokens": 13,
"cacheReadInputTokens": 0
}
}
When the same request was sent to us-east-1, us-west-2, and ap-northeast-1, all returned a stopReason of end_turn, a response text of ok, and usage of input 8 / output 5 / total 13.
A response was also obtained using InvokeModel with the same model ID.
The result of passing {"messages":[{"role":"user","content":"Say ok"}],"max_completion_tokens":16} as the input body:
{"choices":[{"finish_reason":"stop","index":0,"message":{"annotations":[],"content":"ok","refusal":null,"role":"assistant"}}],"created":1788919066,"id":"chatcmpl-y3ldv7w2nvet7ibewtphemha2kmyudqvrasturqhjottjo2tbm3q","model":"global.openai.gpt-6-astra","object":"chat.completion","service_tier":"default","usage":{"completion_tokens":5,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens":8,"prompt_tokens_details":{"audio_tokens":0,"cache_write_tokens":0,"cached_tokens":0},"total_tokens":13},"system_fingerprint":null}
OpenAI-Compatible Path
I sent a Responses API-formatted body to the OpenAI-compatible path of bedrock-runtime.
{"model":"global.openai.gpt-6-astra","input":"Say ok","store":false}
I saved this as gpt6-astra-responses-body.json and sent it via curl to /openai/v1/responses. For authentication, I passed the same temporary credentials as the AWS CLI via environment variables, with SigV4 signing applied to curl.
curl --silent --show-error \
--aws-sigv4 'aws:amz:us-east-1:bedrock' \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H 'Content-Type: application/json' \
--data-binary @gpt6-astra-responses-body.json \
https://bedrock-runtime.us-east-1.amazonaws.com/openai/v1/responses
The HTTP status was 200. The response model was global.openai.gpt-6-astra, status was completed, the output text was ok, and usage was the same 8 / 5 / 13 (input_tokens / output_tokens / total_tokens) as Converse.
When sent to /openai/v1/chat/completions with the same model ID, the HTTP status was also 200. The finish_reason was stop, the response text was ok, and usage was prompt_tokens 8 / completion_tokens 5 / total_tokens 13. The output limit was specified with max_completion_tokens.
Calling via OpenAI SDK using IAM role environment variables
The basic example for the official OpenAI SDK uses a Bedrock API key. The code in this article is not a replacement for the authentication method in that SDK sample, but rather a proof-of-concept example that adds SigV4 signing to an HTTP client. The endpoint specification states that both Runtime and Mantle support SigV4 authentication. Here, with AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_SESSION_TOKEN obtained from an IAM role set as environment variables, SigV4 signing was added to the HTTP requests sent by the OpenAI SDK.
Principals executing the Responses API on Runtime require bedrock:InvokeModel for the inference profile and the default project. The following code assumes that temporary credentials with those permissions are already set in environment variables.
import json
import os
import httpx
from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest
from botocore.credentials import Credentials
from openai import OpenAI
REGION = "us-west-2"
SIGNING_SERVICE = "bedrock"
MODEL_ID = "global.openai.gpt-6-astra"
credentials = Credentials(
os.environ["AWS_ACCESS_KEY_ID"],
os.environ["AWS_SECRET_ACCESS_KEY"],
os.environ.get("AWS_SESSION_TOKEN"),
)
class SigV4Signer(httpx.Auth):
requires_request_body = True
def auth_flow(self, request):
aws_request = AWSRequest(
method=request.method,
url=str(request.url),
data=request.content,
headers={"content-type": request.headers.get("content-type", "application/json")},
)
SigV4Auth(credentials, SIGNING_SERVICE, REGION).add_auth(aws_request)
for key, value in aws_request.headers.items():
request.headers[key] = value
yield request
client = OpenAI(
api_key="unused-sigv4",
base_url=f"https://bedrock-runtime.{REGION}.amazonaws.com/openai/v1",
http_client=httpx.Client(auth=SigV4Signer(), timeout=120.0),
)
response = client.responses.create(
model=MODEL_ID,
input="Can you explain the features of Amazon Bedrock?",
)
print("=== output_text ===")
print(response.output_text)
print("=== usage ===")
print(json.dumps(response.usage.model_dump(), indent=2))
I ran this in a python:3.12-slim container with openai, botocore, and httpx installed, passing credentials only via environment variables to the container. response.output_text returned body text explaining Bedrock's features, and usage was input 16, output 1,010 (of which 145 were reasoning), total 1,026 tokens. An excerpt of the output is as follows.
=== output_text ===
**Amazon Bedrock is AWS's managed platform for building generative AI applications.** It gives you access to foundation models and tools for connecting them to your data, automating workflows, and adding security controls—without having to manage the underlying model-serving infrastructure for its standard managed offerings.
Here are its main features:
### 1. Access to multiple foundation models
...
=== usage ===
{
"input_tokens": 16,
"output_tokens": 1010,
"total_tokens": 1026
}
Mantle
GPT-6 Astra was also available from bedrock-mantle. When sent to the OpenAI-compatible Responses API in us-west-2 specifying openai.gpt-6-astra, it returned HTTP 200 with status: completed. The output text was ok, and usage was also the same 8 / 5 / 13.
The model ID specified for bedrock-mantle does not include a profile prefix, unlike bedrock-runtime. When specifying the same model ID in us-east-1, an HTTP 404 with The model 'openai.gpt-6-astra' does not exist was returned. The model card also states that bedrock-mantle availability is limited to us-west-2 only.
Calling Mantle via OpenAI SDK using IAM role environment variables
The same SigV4Signer can be used with Mantle as well. All that is needed is credentials in environment variables that allow bedrock-mantle:CreateInference. From the Runtime version of the code, change the region, signing service name, model ID, and base_url as follows.
REGION = "us-west-2"
SIGNING_SERVICE = "bedrock-mantle"
MODEL_ID = "openai.gpt-6-astra"
client = OpenAI(
api_key="unused-sigv4",
base_url=f"https://bedrock-mantle.{REGION}.api.aws/openai/v1",
http_client=httpx.Client(auth=SigV4Signer(), timeout=120.0),
)
response = client.responses.create(
model=MODEL_ID,
input="Can you explain the features of Amazon Bedrock?",
)
print(response.output_text)
I saved this block and the Runtime version's SigV4Signer in a single file and executed it. In an actual run using a python:3.12-slim container with temporary credentials passed via environment variables, response.output_text returned a long text explaining Bedrock's features. The beginning is as follows.
**Amazon Bedrock is AWS's fully managed service for building generative AI applications.** It lets you access foundation models, connect them to your data, and deploy AI-powered workflows without managing the underlying model-serving infrastructure.
Its main features include:
### 1. Access to multiple foundation models
...
As shown, the SDK call itself is the same, and Runtime vs. Mantle can be called simply by switching the endpoint, SigV4 service name, and model ID.
Pricing
Bedrock's unit prices are listed on the model card, and direct sales unit prices are on OpenAI's model page. Claude Fable 5.1 supports global cross-region inference according to the Bedrock model card, and the Anthropic model page lists input at $10.00 and output at $50.00 (both per 1M tokens).
I compared the per-1M-token prices for input and output without caching, for short contexts up to 272K tokens. The Bedrock price is for global cross-region inference.
| Model / Invocation Method | Input | Output |
|---|---|---|
| GPT-6 Astra / Bedrock | $10.00 | $50.00 |
| GPT-6 Astra / OpenAI Direct | $10.00 | $50.00 |
| Claude Fable 5.1 / Bedrock | $10.00 | $50.00 |
For GPT-6 Astra's in-region inference and geographic cross-region inference on Bedrock, both input and output prices are 10% higher than those in this table.
Summary
GPT-6 Astra, announced by OpenAI on September 3, 2026, is now available on Amazon Bedrock as well.
With GPT-5.6, the bedrock-mantle endpoint was provided first. GPT-6 Astra is available on bedrock-runtime from the day of GA, and the official documentation now recommends bedrock-runtime for new applications.
I look forward to seeing GPT-6 Astra, OpenAI's current top-of-the-line model, deployed in AI agents such as Kiro and expanded to more geographic cross-region inference regions in the future.
