OpenAI GPT-5.6 on Amazon Bedrock: Choose the Inference Profile Before You Route

The Prefix Is a Processing Policy

All three general-purpose GPT-5.6 variants use the same profile pattern. For Terra, the two launch profiles are global.openai.gpt-5.6-terra and us.openai.gpt-5.6-terra; replace terra with sol or luna for the other variants. These logical IDs define both the foundation model and the Regions Bedrock may select. Passing openai.gpt-5.6-terra instead is a different choice: an in-Region call, where supported, rather than cross-Region inference.

The global profile draws from the supported commercial AWS Regions worldwide and is the broadest capacity pool. The US geographic profile stays within its published US destination set. At launch, AWS lists US and global cross-Region profiles for GPT-5.6; it does not list an EU geographic GPT-5.6 profile. That means a team with an EU-only processing requirement cannot infer that a generic Bedrock feature table mentioning EU profiles creates eu.openai.gpt-5.6-terra. Check the model-specific routing table and use an available in-Region option if one Region is the required boundary.

This is separate from OpenAI's own per-request regional domains. The site's direct OpenAI regional-processing guide covers us.api.openai.com and eu.api.openai.com with an OpenAI project key. On Bedrock, the source Region appears in the AWS endpoint, the profile ID defines the cross-Region destination set, AWS IAM authorizes the route, and CloudTrail records the destination.

Put the Profile in Configuration, Not a Fallback Chain

The OpenAI Python client can call Bedrock's OpenAI-compatible endpoint. AWS's launch example generates a short-term Bedrock bearer token from the workload's AWS credentials; AWS recommends long-term Bedrock API keys only for exploration. Keep the requesting Region and the approved profile as separate, validated settings:

import os

from aws_bedrock_token_generator import provide_token
from openai import OpenAI

region = os.environ["BEDROCK_REQUEST_REGION"]          # for example: us-east-1
profile = os.environ["BEDROCK_INFERENCE_PROFILE"]      # approved: us. or global.

allowed_profiles = {
    "us.openai.gpt-5.6-terra",
    "global.openai.gpt-5.6-terra",
}
if profile not in allowed_profiles:
    raise ValueError(f"Unapproved inference profile: {profile}")

client = OpenAI(
    base_url=f"https://bedrock-runtime.{region}.amazonaws.com/openai/v1",
    api_key=provide_token(region=region),
)

response = client.responses.create(
    model=profile,
    input="Return the word READY and nothing else.",
    max_output_tokens=16,
)
print(response.output_text)

The endpoint Region is where the application submits the request; it does not prove where inference ran. Likewise, a successful response proves that some authorized route worked, not that the intended destination set was used. Log the configured source Region, exact inference profile, application request ID, and Bedrock response metadata. Keep the profile explicit in deployment configuration so that a change from us. to global. produces a reviewable configuration diff.

IAM Must Authorize the Whole Route

Cross-Region inference fails closed if any destination Region in the selected profile is blocked by IAM or an AWS Organizations service control policy. For a US geographic profile invoked from us-east-1, AWS's example grants bedrock:InvokeModel on the inference-profile and default-project ARNs in the source Region, plus the Terra foundation-model ARNs in us-east-1, us-east-2, and us-west-2. The destination-model statement is conditioned on the exact bedrock:InferenceProfileArn, preventing that permission from becoming general direct-model access.

The global profile needs a different shape. In addition to the source-Region profile, project, and in-Region model, AWS uses the Region-agnostic resource arn:aws:bedrock:::foundation-model/openai.gpt-5.6-terra. Its condition combines the exact profile ARN with aws:RequestedRegion set to unspecified. A Region-deny SCP that permits only named Regions can therefore reject a correct global request unless it has a narrowly conditioned CRIS exception.

For the OpenAI-compatible API, the role also needs bedrock:CallWithBearerToken. If the application uses streaming through Bedrock's Converse API, add bedrock:InvokeModelWithResponseStream to the relevant profile and model statements. Do not copy an IAM example and remove a destination that looks unused: the routing service, not the client, chooses among the profile's destinations. AWS recommends scoping the exception with bedrock:InferenceProfileArn instead of widening the organization's Region allowlist for every AWS service.

Verify the Destination in CloudTrail

A pre-production canary should send synthetic content through the same role, source Region, endpoint, and profile that production will use. Then inspect CloudTrail in the source Region. AWS records the actual processing destination in additionalEventData.inferenceRegion. This is the evidence that separates a selected profile from an observed route.

import json
import boto3

source_region = "us-east-1"
cloudtrail = boto3.client("cloudtrail", region_name=source_region)

page = cloudtrail.lookup_events(
    LookupAttributes=[{
        "AttributeKey": "EventSource",
        "AttributeValue": "bedrock.amazonaws.com",
    }],
    MaxResults=50,
)

for wrapper in page["Events"]:
    event = json.loads(wrapper["CloudTrailEvent"])
    destination = event.get("additionalEventData", {}).get("inferenceRegion")
    if destination:
        print(event["eventTime"], event["eventName"], destination)

Run enough canaries to exercise routing over time, but do not expect one request to enumerate every permitted destination. For a US profile, assert that every observed inferenceRegion belongs to the approved US set. For a global profile, record the observed Region and confirm that the workload policy truly allows worldwide commercial-Region processing. If the field is missing, do not substitute the endpoint Region as proof; investigate the event selection and logging configuration.

CloudTrail proves where a particular invocation was processed. It does not prove that IAM will allow every future destination or that the profile's eligible set will never change. Keep both controls: preventive authorization over the complete documented route and detective verification over actual invocations. The site's verification ladder fits this rollout: reject an unapproved profile locally, exercise a synthetic live request under the production role, inspect CloudTrail, then canary real traffic.

The Production Checklist Is Four Decisions

1. Choose the boundary. Use us. when processing must remain inside the published US geography. Use global. only when worldwide commercial-Region processing is acceptable. Use an available in-Region model path when one Region is required.
2. Pin the logical ID. Allowlist the full profile string for Sol, Terra, or Luna and keep it out of automatic model or capacity fallback logic.
3. Authorize the route. Grant the profile, project, bearer-token, and complete destination-model permissions; test the production SCP, not only a developer account.
4. Observe the result. Send a synthetic canary, read additionalEventData.inferenceRegion in source-Region CloudTrail, and reject observations outside the approved set.