How to Access OpenAI Models on Amazon Bedrock (May 2026)

On May 1, 2026, AWS and OpenAI announced GPT-5.5 and GPT-5.4 on Amazon Bedrock in limited preview — the first time OpenAI’s frontier models are available outside Microsoft Azure since the original 2019 partnership. This guide walks through requesting access, setting up IAM, calling the API, migrating existing OpenAI SDK code, and deciding whether to migrate at all.

Last verified: May 6, 2026

Step 1: Confirm prerequisites

Before requesting access, ensure you have:

• An active AWS account in good billing standing.
• IAM admin privileges (or someone who has them on your team).
• Region availability: limited preview launched in us-east-1 and us-west-2 first; expansion expected through Q2-Q3 2026.
• Optional but helpful: AWS Enterprise Support or Business Support tier — early-access reports indicate faster approval.

If you don’t have an AWS account, Bedrock is accessible from any standard AWS account. Personal accounts work for evaluation; production deployments typically run from organizational accounts under AWS Organizations.

Step 2: Request limited preview access

Navigate to the Bedrock console:

AWS Console → Amazon Bedrock → Model access → Request access

In the Model access page, look for OpenAI as a provider. As of May 6, 2026, two models are listed:

• GPT-5.5 (limited preview)
• GPT-5.4 (limited preview)

Click Request access for the model(s) you need. This submits a waitlist request to the Bedrock team.

Approval timeline: Early-access reports indicate 1-3 weeks. Enterprise Support customers report 1-7 days. The request form asks about your use case and expected token volume — be specific to improve approval odds.

You’ll receive an email when access is granted. The model then appears in your account’s Bedrock model list.

Step 3: Configure IAM permissions

Once approved, create IAM permissions for users and roles that need OpenAI model access. The minimum policy:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream",
        "bedrock:Converse",
        "bedrock:ConverseStream"
      ],
      "Resource": [
        "arn:aws:bedrock:us-east-1::foundation-model/openai.gpt-5-5*",
        "arn:aws:bedrock:us-east-1::foundation-model/openai.gpt-5-4*"
      ]
    }
  ]
}

For production use cases, add resource-level conditions for VPC endpoints and request rate limits. AWS publishes a recommended IAM template in the Bedrock console under Model access → IAM templates.

Step 4: Call the API (basic example)

Bedrock uses its own API surface — InvokeModel for raw inference and Converse for chat-style conversations. The simplest call using the AWS SDK for Python (boto3):

import boto3
import json

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

response = client.converse(
    modelId="openai.gpt-5-5-preview-20260501",
    messages=[
        {
            "role": "user",
            "content": [{"text": "Explain quantum computing in 100 words."}]
        }
    ],
    inferenceConfig={
        "maxTokens": 500,
        "temperature": 0.7
    }
)

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

The Converse API matches what you’d expect from OpenAI’s chat.completions but with AWS-native parameter names.

Step 5: Migrate existing OpenAI SDK code

Most teams have existing OpenAI SDK code (openai Python package, or the equivalent in other languages). Three migration paths:

Option A: Migrate to bedrock-runtime SDK directly

Most idiomatic for AWS-native teams. Pros: best AWS integration, full feature access, optimal performance. Cons: significant code rewrite.

Option B: Use LiteLLM as a compatibility layer

LiteLLM exposes a unified OpenAI-compatible API across Bedrock, OpenAI direct, Anthropic, and others. Migration is roughly 5 lines of code:

import litellm

# Set AWS credentials in environment
# AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION

response = litellm.completion(
    model="bedrock/openai.gpt-5-5-preview-20260501",
    messages=[{"role": "user", "content": "Hello"}]
)

LiteLLM handles the API translation. Same code now routes through Bedrock instead of OpenAI direct.

Option C: Wait for OpenAI-compatible Bedrock endpoint

AWS has signaled an OpenAI-compatible endpoint coming in Q3 2026 that exposes Bedrock models behind the chat.completions interface. When it ships, migration is just changing the base URL.

Most teams in early access pick Option B (LiteLLM) for fastest migration. It also keeps the door open to multi-model routing.

Step 6: Set up VPC and PrivateLink (for production)

The main reason to use Bedrock over OpenAI direct is keeping inference inside your AWS network. To enable:

1. Create a VPC endpoint for Bedrock in each VPC that needs access.
2. Configure security groups to allow traffic from your application subnets.
3. Update your Bedrock client configuration to use the VPC endpoint.

client = boto3.client(
    "bedrock-runtime",
    region_name="us-east-1",
    endpoint_url="https://vpce-xxxxx.bedrock-runtime.us-east-1.vpce.amazonaws.com"
)

This ensures all GPT-5.5 inference traffic stays inside your VPC — no public internet egress.

Step 7: Configure logging and observability

Enable CloudTrail for the Bedrock service (if not already on) and configure model invocation logging:

1. Bedrock Console → Settings → Model invocation logging.
2. Enable logging to S3 or CloudWatch.
3. Choose what to capture: text inputs/outputs, embeddings, image inputs, etc.
4. Set up CloudWatch alarms on token usage to catch runaway scripts.

This is materially better observability than OpenAI’s direct dashboard for compliance-sensitive workloads.

Step 8: Test the migration

Before cutting over production traffic:

1. Run side-by-side. Send the same prompts to OpenAI direct and Bedrock GPT-5.5 in shadow mode. Compare outputs.
2. Measure latency. Bedrock typically adds 100-200ms first-token latency due to AWS routing.
3. Verify rate limits. Bedrock applies its own per-account rate limits; check that they meet your needs.
4. Test fallback behavior. Configure your client to fall back to OpenAI direct if Bedrock fails (LiteLLM makes this easy).

Common pitfalls

Five issues teams hit during early-access migration:

1. Region mismatch. Limited preview is us-east-1 and us-west-2 only. If your app runs in eu-west-1, you’re paying cross-region latency until expansion.
2. Underestimating cost variance. Bedrock pricing isn’t publicly disclosed at preview launch. Budget for parity to +30% over OpenAI direct rates.
3. Missing fine-tuning. OpenAI’s fine-tuning APIs are not on Bedrock as of May 2026. If you have fine-tuned models, you can’t migrate them yet.
4. Missing batch API. OpenAI’s batch API (50% discount on async workloads) is also not on Bedrock yet.
5. VPC endpoint costs. Each VPC endpoint costs ~$7.50/month plus data processing fees. Budget for these in production.

Should you migrate from OpenAI direct?

Quick decision checklist. Migrate to Bedrock if:

• ✅ Your data must stay inside AWS VPC and IAM boundaries.
• ✅ You have $1M+ annual AWS commit and want OpenAI tokens to count toward EDP credits.
• ✅ You need PrivateLink, CloudTrail, and Bedrock Guardrails on top of GPT-5.5.
• ✅ You’re building with Bedrock Managed Agents (powered by OpenAI).
• ✅ You’re already deep on Bedrock for Claude, Llama, or Nova.

Stay on OpenAI direct if:

• ❌ You need the latest model versions immediately on launch (Bedrock lags by days to weeks).
• ❌ You need fine-tuning or the batch API.
• ❌ You’re not on AWS or you’re multi-cloud.
• ❌ You’re a startup or SMB without significant AWS commitment.
• ❌ You value the simpler procurement of OpenAI direct.

What’s coming next

Through Q3 2026, AWS has signaled:

• Broader region availability — eu-west-1, ap-northeast-1, others.
• GA pricing publication — preview ends, public pricing.
• OpenAI-compatible endpoint — chat.completions shape exposed on Bedrock.
• Fine-tuning support — bring your own fine-tuned OpenAI models to Bedrock.
• Batch API support — async jobs at OpenAI’s batch rates.

Migration economics will improve as these ship. If you’re not in a rush, waiting through Q3 2026 means more options at GA.

Bottom line

In May 2026, getting OpenAI models on Bedrock requires a limited-preview access request, IAM setup, and either a code migration or a LiteLLM compatibility layer. The economics make sense for AWS-heavy, regulated, or compliance-driven workloads. For startups, SMBs, and teams that need OpenAI’s newest models immediately, OpenAI direct API remains the better path. Plan migration carefully, run side-by-side validation, and budget for the operational changes — Bedrock is not a drop-in replacement for OpenAI direct, but for the right workloads, it’s a meaningful improvement on governance and cost predictability.

Sources: AWS Bedrock OpenAI page (May 2026), AWS What’s Next with AWS 2026 announcements, AWS Bedrock IAM documentation (May 2026), LiteLLM documentation (May 2026), AWS Bedrock pricing page (May 2026).