GPT-5.6 on Amazon Bedrock: Inference, Pricing, and Quotas

GPT-5.6 now runs on Amazon Bedrock. OpenAI’s current frontier family is available in more than 25 AWS Regions, reachable through cross-region inference profiles. This guide shows you how to enable the models, call them three different ways, read the real price sheet, and size quotas without surprises.

GPT-5.6: What You’ll Learn

GPT-5.6 arrived on Amazon Bedrock when AWS announced cross-region inference for the family on August 20, 2026. In the sections below you enable model access, make your first call, and work through the pricing and quota mechanics that decide whether the deployment is cheap or expensive.

The numbers come from the Bedrock model cards and the current price sheet, so you can reproduce every calculation in your own account.

Three variants, one API surface

The GPT-5.6 lineup on Bedrock includes three general-purpose variants, all launched on July 13, 2026, all with a 1M token context window, all taking text and image input and returning text output. The differences are capability and price:

• Sol is the most capable variant, aimed at frontier reasoning, agentic coding, security work, and research.
• Terra is the balanced production model. AWS positions it as outperforming GPT-5.5 at a lower cost, because it completes tasks with fewer output tokens.
• Luna is the fast, cheap variant for high-volume jobs like classification, summarization, routing, and real-time responses.

Reasoning mode, tool calling handled server-side, streaming, and prompt caching all work across the family. Three doors lead to them: OpenAI’s Responses format, OpenAI’s Chat Completions format, and Bedrock’s native Converse interface. That is why an existing OpenAI integration usually moves over by editing two values, the base URL and the model name.

The family also has specialized cybersecurity variants, announced August 11, 2026 under OpenAI’s Daybreak initiative, reachable through enrollment in Trusted Access for Cyber. Those sit outside this guide, which sticks to the three general-purpose models.

Picking a variant with real numbers

Variant choice is mostly an output-token decision, because output costs 5 to 6 times more than input on every variant. Price a concrete job: 3,000 input tokens and 500 output tokens per request, through the global profile, per 1,000 requests. Sol costs $22.00, made of $12.00 in input and $10.00 in output. Terra costs $12.00, split evenly at $6.00 each. Luna costs $1.20, at $0.60 each.

Three reads fall out of that math. Luna is 10 times cheaper than Terra, so any classification or routing job that Luna handles belongs on Luna. Sol’s input tokens alone cost $12.00, which is what Terra’s entire request costs, so Sol can never win on efficiency at equal volume; you pay for it when the task genuinely needs frontier reasoning. And because all three share the same 1M context window, there is no context-length reason to step up a tier when a cheaper variant suffices.

The corollary: measure output tokens per task before committing. A variant that emits fewer, denser tokens can win even at a higher unit price, which is the same argument AWS makes for Terra over GPT-5.5. Run 100 real requests through each candidate and compare the distribution, not the price sheet alone.

What GPT-5.6 costs on Bedrock

Pricing is per million tokens, and the numbers differ by variant, by context length, and by profile type. Two tiers apply: prompts up to 272K tokens use short-context pricing, and anything longer up to the 1M window pays long-context rates: exactly double on input and 1.5 times on output. The Standard tier is the only one available for these models; Priority and Flex are not supported. The Bedrock pricing page carries the live numbers.

Short-context input and output prices per million tokens. Long-context prices from the same sheet: Sol runs $8.80 in and $33.00 out, or $8.00 and $30.00 on the global profile; Terra runs $4.40 and $19.80, or $4.00 and $18.00 globally; Luna runs $0.44 and $1.98, or $0.40 and $1.80 globally.

One line in that table is easy to miss: the global profile is about 9 percent cheaper than direct or geographic routing for every variant and both context tiers. AWS cut Sol prices on August 21, 2026, by 20 percent on input and 33.3 percent on output, and the promotional rates hold at least through November 21, 2026.

Cache economics stack on top: a cache write costs 1.25 times the input price and holds for 30 minutes, while a cache read costs one tenth of the input price. For a workload that repeats a long system prompt, reads at 10 percent of input price change the math completely.

Quotas: the 10x output burndown trap

Every on-demand GPT-5.6 call draws from a tokens-per-minute allowance, and that allowance belongs to the profile, not to your account as a whole. Call through us. and you consume one pool; call through global. and you consume another. Two profiles fronting the identical model never share headroom.

The part that surprises teams is the burndown rate. Input tokens count against TPM at 1:1, but output tokens for GPT-5.6 consume quota at 10 times their count, so each request is scored as input + cache writes + (output * 10).

Score a 3,500-in, 800-out call under this rule and you get 3,500 + 8,000 = 11,500 quota tokens, against a naive sum of 4,300. Output-heavy agents exhaust TPM far sooner than their token totals imply. Reads served from cache score zero, which turns caching into a quota instrument, not merely a discount.

Two habits keep this manageable. File the quota increase in Service Quotas days ahead of launch, never mid-incident, and put an alarm on the per-profile utilization metric, which streams live in CloudWatch. When you rehearse, replay production-size prompts against the exact profile you intend to call: a dry run on us. tells you nothing about global. headroom.

Prompt caching that survives cross-region routing

Every variant caches prompts on the bedrock-runtime endpoint, and the behavior is identical whichever profile you route through. Give every request the same opening, say a long system prompt or a few-shot block, and Bedrock keeps that opening warm: from the second request onward, the repeated stretch skips reprocessing, so it bills less and answers sooner.

Bedrock decides where the cached region ends in one of two ways. By default it caches up to the most recent user or tool turn, a good fit for chat histories that only ever grow at the tail. When the static part sits at the front and the volatile part arrives later, close the cached region yourself:

# catalog_data is identical across every support request.
completion = client.chat.completions.create(
    model="global.openai.gpt-5.6-terra",
    messages=[
        {
            "role": "system",
            "content": [
                {
                    "type": "text",
                    "text": catalog_data,
                    "prompt_cache_breakpoint": {"mode": "explicit"},
                }
            ],
        },
        {"role": "user", "content": "Can the outdoor camera survive a Minnesota winter?"},
    ],
    max_completion_tokens=300,
    prompt_cache_key="catalog-v1",
)

Pass prompt_cache_key so requests sharing a prefix route to the same cache, and remember each breakpoint needs at least 1,024 tokens of prefix above it. Confirm caching is live in the response usage object:

details = completion.usage.prompt_tokens_details
print("Cache hits:", details.cached_tokens)
print("Cache repopulations:", details.cache_write_tokens)

The AWS model card notes caching under the Responses API while the launch post demonstrates the breakpoint parameter through Chat Completions, so verify the field names against your SDK version when you wire this up.

Cross-region inference profiles, explained

You do not call a GPT-5.6 model by its raw model ID on Bedrock. You call an inference profile, a logical identifier that names a model plus the pool of Regions Bedrock may route your request to. Two kinds exist for GPT-5.6:

• A geographic profile carries a geography prefix, such as us.openai.gpt-5.6-terra. Your call lands in the Region you dialed, and Bedrock may then execute it in any member Region of that geography, nowhere else, which bounds data residency while still spreading load.
• A global profile carries the global. prefix, such as global.openai.gpt-5.6-terra. Bedrock routes each request to whichever Region in the model’s deployment set has capacity to spare at that moment. This is the widest compute pool available.

What cross-region routing actually buys you is capacity headroom. A single Region’s accelerator fleet is shared with every other tenant calling it, and when their traffic spikes, yours queues. A profile lets each request spill into whichever sibling Region has idle compute at that moment, so throughput holds and latency stops moving when neighbors get loud. The effect is most visible at bursts: a launch wave that would have queued in one Region gets absorbed across the pool, and the routing choice happens per request, with no retry logic on your side.

The US geographic profile accepts source calls from us-east-1, us-east-2, us-west-1, us-west-2, ca-central-1, and ca-west-1, and routes across the US Regions. The global profile adds eight European Regions, twelve Asia Pacific Regions, two Middle East Regions, and South America to the source list. Terra and Luna also offer an in. India geographic profile.

Two properties matter operationally. Billing and quota consumption stay attached to your account in the source Region no matter where a request lands, and requests through a global profile may be processed in any Region in the model’s eligible set. If you have data residency obligations, use the geographic profile, not the global one.

Call it three ways: playground, SDK, and Converse

Enable model access for your account in the calling Region first; nothing else works until that toggle is on. The fastest validation is the console’s text playground: open Bedrock in a supported Region, such as N. Virginia, and search the model picker for the variant you want. Each one appears twice, under a US entry and a Global entry, which is the two profile types showing themselves.

Send one prompt through each entry before writing any code. Thirty seconds in the playground tells you the routing choice works end to end, and the response pane exposes the inference parameters you will set programmatically later.

The OpenAI SDK route

For an application already built on the OpenAI Python SDK, the shortest path is the OpenAI-compatible endpoint on Bedrock: point the client at https://bedrock-runtime.<region>.amazonaws.com/openai/v1 and pass the inference profile ID as the model.

Authentication accepts standard AWS credentials or a Bedrock API key, and the key route fits the OpenAI SDK naturally because the SDK ships it as a bearer token. For anything beyond experiments, mint short-term keys with the aws-bedrock-token-generator package: it turns the AWS credentials already in your environment into a key that stays good for up to 12 hours:

pip install aws-bedrock-token-generator

from aws_bedrock_token_generator import provide_token
from openai import OpenAI

region = "us-east-1"

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

# Terra riding the global pool.
model_id = "global.openai.gpt-5.6-terra"

response = client.responses.create(
    model=model_id,
    input="Draft a one-paragraph release note for a queue timeout fix.",
    max_output_tokens=512,
)

print(response.output_text)

Swap global.openai.gpt-5.6-terra for us.openai.gpt-5.6-terra when requests must stay inside the US geography, or for the Sol and Luna profile IDs when you want a different capability and price point.

Chat Completions and the Converse API

The same client speaks Chat Completions, which matters if your codebase predates the Responses API. Parameters carry over, including reasoning_effort for controlling how much reasoning the model spends before answering:

response = client.chat.completions.create(
    # Pin to the US geography with "us.openai.gpt-5.6-terra" instead.
    # Siblings follow suit: gpt-5.6-sol, gpt-5.6-luna
    model="global.openai.gpt-5.6-terra",
    messages=[
        {"role": "user", "content": "A 900-line diff just landed in review. What should the approver check first?"}
    ],
    max_completion_tokens=2000,
    reasoning_effort="low",
)

print(response.choices[0].message.content)

Staying inside boto3 is equally valid. Converse is the native Bedrock interface: authentication is plain AWS credentials, no bearer token, and any code you already have that invokes other foundation models extends to GPT-5.6 with a changed model ID:

import boto3

client = boto3.client("bedrock-runtime", region_name="us-east-1")

response = client.converse(
    modelId="global.openai.gpt-5.6-terra",
    messages=[{"role": "user", "content": [{"text": "Our order worker lag metric doubled overnight. What do we inspect first?"}]}],
    inferenceConfig={"maxTokens": 512},
)

print(response["output"]["message"]["content"][0]["text"])

Streaming is available on all three paths: stream=True on Responses and Chat Completions, and converse_stream on the Converse API. The full parameter list lives in the Bedrock User Guide page for OpenAI GPT model parameters.

IAM policy shape for inference profiles

Before a role may call GPT-5.6 through a profile, three grants must line up: the profile itself in your source Region, the foundation model everywhere the profile can land a request, and bearer-token permission for the OpenAI-compatible APIs. For a geographic profile the policy compresses to this shape:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ProfileAndProjectInSourceRegion",
      "Effect": "Allow",
      "Action": "bedrock:InvokeModel",
      "Resource": [
        "arn:aws:bedrock:us-east-1:111122223333:inference-profile/us.openai.gpt-5.6-terra",
        "arn:aws:bedrock:us-east-1:111122223333:project/default"
      ]
    },
    {
      "Sid": "DestinationModelAccessThroughProfileOnly",
      "Effect": "Allow",
      "Action": "bedrock:InvokeModel",
      "Resource": [
        "arn:aws:bedrock:us-east-1::foundation-model/openai.gpt-5.6-terra",
        "arn:aws:bedrock:us-east-2::foundation-model/openai.gpt-5.6-terra",
        "arn:aws:bedrock:us-west-2::foundation-model/openai.gpt-5.6-terra"
      ],
      "Condition": {
        "StringLike": {
          "bedrock:InferenceProfileArn": "arn:aws:bedrock:us-east-1:111122223333:inference-profile/us.openai.gpt-5.6-terra"
        }
      }
    },
    {
      "Sid": "BearerTokenAuth",
      "Effect": "Allow",
      "Action": "bedrock:CallWithBearerToken",
      "Resource": "*"
    }
  ]
}

A global profile needs a fourth statement that grants the foundation model through a Region-agnostic ARN, because routing is not bound to a destination list. If you use ConverseStream, add bedrock:InvokeModelWithResponseStream to the model statements.

One SCP subtlety: global profile requests evaluate with aws:RequestedRegion set to unspecified, so a Region-restrictive service control policy will deny them even when your source Region is allowed. AWS recommends exempting inference through the bedrock:InferenceProfileArn condition key rather than widening the Region allowlist, which would expose the listed Regions to every service rather than Amazon Bedrock alone.

Where your requests actually run: security and audit

Security here mirrors what you already run for any other Bedrock workload. A role sees exactly the profiles its IAM policy names, private connectivity arrives over a VPC endpoint instead of the public path, and the zero-operator access model is enforced in silicon: nobody at AWS can pull up your prompts or completions.

Audit trails stay close to home. CloudTrail journals each call in the Region you called from, and its additionalEventData.inferenceRegion field names the Region that served it. Switch on invocation logging and the full payloads flow into your own S3 bucket or CloudWatch Logs group, both within the source account. Each profile separately reports CloudWatch invocations, token volumes, latency, throttle events, and error counts.

One retention rule belongs in your compliance notes: prompts or responses that trip the abuse filters on these models are stored on the AWS side for up to 30 days and reviewed offline. The abuse detection documentation spells out which models this covers, GPT-5.6 among them.

When to stay on the OpenAI API instead

Bedrock is not the only door to this model family, and two capabilities currently live on the OpenAI side. Ultrafast mode, previewed August 13, 2026, runs GPT-5.6 Sol up to 14 times faster than standard processing, generating up to 750 output tokens per second on Cerebras hardware. It is launching first in the OpenAI API, with no Bedrock availability announced.

So choose by constraint. If you need AWS-native governance, VPC isolation, consolidated billing, or CloudTrail audit, Bedrock with inference profiles is the fit. If you need the fastest possible Sol responses for voice or interactive work, the OpenAI API preview is the only place that exists today, and bridging both is reasonable: keep bulk processing on Bedrock and route the latency-critical sliver to OpenAI.

Bridging has a real management cost, though. Two providers means two auth setups, two quota regimes, two audit trails, and two places where a model update can change behavior. Weigh that overhead before splitting: many teams start entirely on Bedrock, measure where latency actually hurts, and only then carve out the interactive path to the OpenAI API.

A Worked Example

Consider a support team that summarizes incoming tickets. Assume 500 tickets a day, each sent with a 3,000 token system prompt containing the product manual, and each answer capped at 500 output tokens. Terra through the global profile is a sensible default: the task is structured summarization, not frontier reasoning.

Daily input volume is 1.5 million tokens, which at $2.00 per million costs $3.00. Output volume is 250,000 tokens, which at $12.00 per million costs another $3.00. Before caching, the workload costs about $6.00 a day, or roughly $180 a month.

Now add caching. The manual never changes, so an explicit breakpoint after it turns most of those 1.5 million input tokens into cache reads at $0.20 per million. The cache also repopulates roughly every 30 minutes, and each repopulation is a write of 3,000 tokens at the 1.25 times write rate, about $0.36 a day across 48 refreshes. Reads cost about $0.30 a day, so the input side falls from $3.00 to about $0.66 and the total lands near $3.70 a day.

Quota relief comes from the same place. Cache reads drop out of the TPM calculation entirely, so daily quota consumption falls from about 4 million tokens, 1.5 million input plus 2.5 million output burndown, to roughly 2.6 million once the write refreshes are counted. That is a third of the headroom back, and on a quota-limited deployment it can matter more than the dollar savings.

Steady-state sizing then looks different per request. A cached request burns just its 5,000 output-burndown tokens, and the 3,000 token manual only counts when the cache repopulates. At peak, if 60 tickets arrive in one minute, that is about 300,000 quota tokens against the Terra global profile’s TPM limit. Check the limit in Service Quotas from the calling Region, request headroom before the launch, and watch the per-profile CloudWatch utilization metric once live.

Finally, verify the routing story in your audit tools. The CloudTrail event in us-east-1 shows the call, and its inferenceRegion field reveals which Region served each request. Cost Explorer breaks the bill out per model and per profile, so the Terra global line stays separable from any Sol experiments running alongside it.

Spend one more hour on validation before calling the migration done. Run 100 identical requests and record two numbers from each response: output token count and end-to-end latency. The token distribution tells you whether the 500 token cap is realistic, and the latency spread tells you how much routing across Regions actually costs you in wall-clock time. If the p99 sits far above the median, compare the geographic and global profiles over the same run, since the two pools can behave differently under your specific traffic shape.

GPT-5.6: Common Mistakes to Avoid

Even experienced AWS teams hit the same four issues in their first week with GPT-5.6 on Bedrock.

• Calling the raw model ID, like openai.gpt-5.6-sol, on the bedrock-runtime endpoint instead of an inference profile ID. The runtime endpoint expects the profile; raw IDs belong to other endpoint types.
• Assuming the geographic and global profiles share one quota pool. They are separate TPM allocations, so a load test against us. proves nothing about global. headroom.
• Sizing capacity on raw token counts. Output tokens count 10 times against quota, so an output-heavy agent exhausts TPM long before the token totals suggest it should.
• Routing regulated workloads through the global profile. Global routing can process a request in any eligible commercial Region; only the geographic profile keeps processing inside one geography.

GPT-5.6: Best Practices

• Match the variant to the job: Luna for high-volume classification and routing, Terra for everyday production work, Sol for the hardest reasoning steps.
• Prefer the global profile when residency allows; it draws on the largest routing pool and runs about 9 percent cheaper than direct or geographic routing.
• Keep prompts under 272K tokens where you can, because input bills at double and output at 1.5 times above that line.
• Enable prompt caching for shared prefixes, pin it with prompt_cache_key, and confirm savings in the usage object rather than assuming hits.
• Scope IAM tightly with bedrock:InferenceProfileArn conditions and keep SCP Region allowlists intact by exempting inference through the condition key.

GPT-5.6: Frequently Asked Questions

Is GPT-5.6 on Bedrock the same model as on the OpenAI API?

The three general-purpose variants, Sol, Terra, and Luna, are the same family on both platforms. Some OpenAI-side tiers, like the Ultrafast preview, have no Bedrock equivalent announced yet.

Do cross-region requests break my audit trail?

No. CloudTrail keeps its entry in the Region you called from, and the additionalEventData.inferenceRegion value inside it names the serving Region. Invocation logs and metrics stay home too.

Which profile should I start with?

Use the geographic profile when data must stay within a geography. Otherwise start with the global profile: its pool spans every supported commercial Region, and it prices about 9 percent below direct routing.

Does prompt caching work through inference profiles?

Yes, through both geographic and global profiles. Each breakpoint needs at least 1,024 tokens of prefix, and cache reads are excluded from TPM quota, so caching helps throughput as well as cost.

How long does the reduced Sol pricing last?

AWS states the promotional Sol rates of $4.00 input and $20.00 output per million tokens hold at least through November 21, 2026. Check the Bedrock pricing page before locking in budgets.

GPT-5.6 on Amazon Bedrock comes down to four levers: pick the variant that matches the job, pick the profile that matches your residency and capacity needs, cache every stable prefix, and size quotas with the 10 times output burndown in mind. Get those right and the family is both cheaper and more predictable than it first looks.