Claude on AWS Bedrock or a gateway: which to pick in 2026

If you plan to ship Claude to production in 2026, two paths come up most often: AWS Bedrock and codexkey. From a distance they look alike. Both give you Claude behind an HTTP API, both bill per token, both support streaming and tool use. They were built for very different teams, though. What follows is a practical breakdown: where each one wins, what the code swap looks like, how the pricing works, and a rule for deciding.

The 30-second version

• AWS Bedrock is Claude as an AWS service. You pay through your AWS account, authenticate with IAM/SigV4, and send traffic through a VPC endpoint if you like. It suits teams whose stack already lives in AWS and whose security and procurement people think in AWS accounts.
• codexkey is a focused Claude gateway with an OpenAI-compatible API, EU presence, and pay-as-you-go billing by card, crypto or SBP (Russia's Faster Payments System). No AWS account, no IAM, no procurement cycle. It suits teams that want Claude in one line of code and have no use for an AWS-native control plane.

Both are legitimate ways to run Claude in production. The wrong one is whichever fights your environment.

What Bedrock gives you

Bedrock's main argument is "Claude inside your existing AWS setup." A lot is packed into that sentence.

1. IAM-based auth. Calls are signed with SigV4 by the same roles you already use for S3, DynamoDB and Lambda. There are no long-lived API keys in .env files. You can grant bedrock:InvokeModel to one role, limit it to specific model ARNs, and audit every call in CloudTrail.
2. VPC PrivateLink. Bedrock traffic can go over an interface endpoint, so prompts and completions never reach the public internet. For regulated workloads (HIPAA, PCI, government) that is often a hard requirement.
3. Regional data residency. Claude is available in us-east-1, us-west-2, eu-central-1, eu-west-3, ap-northeast-1 and other regions, depending on the model. You pick the region, and the data stays in it. Cross-region inference profiles exist for failover.
4. Enterprise procurement. Bedrock spend rolls into your existing AWS contract. If your company has an EDP (Enterprise Discount Program) commitment, Bedrock usage counts toward it. Legal, security and finance have already approved AWS as a vendor, so adding Claude is a checkbox rather than a new vendor review.
5. Provisioned Throughput. For predictable high-volume workloads you can buy reserved capacity at a discount. The lever is real, especially for teams spending more than $50k/month on Claude.
6. Observability inside AWS. CloudWatch metrics, CloudTrail logs and Bedrock's own model invocation logging slot into the monitoring you already run.

You pay for all of this in friction. Standing Bedrock up from scratch (model access requests, IAM policies, region choice, VPC endpoints, a SigV4-aware SDK) takes half a day at best and a week at worst, depending on the organization. If you are not on AWS already, it isn't worth the trouble.

What codexkey gives you

codexkey makes the opposite argument: "Claude with no setup tax."

1. No AWS account. Sign up with an email, top up $5, get an API key, and start working. The whole path takes under five minutes.
2. An OpenAI-compatible API. The same messages shape, the same /v1/chat/completions endpoint, the same streaming format. If you have code on the OpenAI SDK, you change the base URL and the key, and that's it. We covered the full pricing in our 2026 guide to Claude API pricing.
3. Pay-as-you-go from $5. No minimum payments, no annual commitments, no procurement. You can top up by card, USDT/TRC20, BTC, ETH or SBP (Russia's Faster Payments System). Billing is per token, and an unspent balance never expires.
4. An EU point of presence. Inference runs through EU infrastructure by default. That matters if your users are in Europe or Russia and you don't want 200ms of transatlantic round-trip time on every request.
5. One-line setup. Set OPENAI_BASE_URL=https://api.codexkey.online/v1 and OPENAI_API_KEY=cxa-..., and every OpenAI client in your stack (the Python SDK, the TypeScript SDK, LangChain, LlamaIndex, Cursor, Cline, Aider, Open WebUI) works with Claude without code changes.
6. No IAM, no SigV4. A bearer token, like any modern API. That makes it easier to call Claude from edge runtimes (Cloudflare Workers, Vercel Edge), from mobile apps, and anywhere a SigV4 signer is awkward.

The flip side: codexkey is not an AWS-native service. There is no IAM integration, no VPC endpoint, no CloudTrail. If your security model demands those, Bedrock wins by default.

Pricing comparison

For the Claude family in 2026, both platforms charge the same per-token rates as Anthropic's first-party API:

There is no Haiku tier in our lineup. The cheapest model is gpt-5.6-luna, but note it is a different family. The request format is compatible, behaviour and prompts may differ, so check it against your own task. It is priced the same as the Bedrock Haiku row above: $0.33 / $0.33.

Prompt caching is on both platforms: a 90% discount on cache hits, with a TTL of 5 minutes or 1 hour. Batch processing (50% discount, 24-hour SLA) is supported on both as well.

Where pricing diverges:

• Bedrock Provisioned Throughput lets you reserve model capacity at an hourly rate. For workloads above ~$30k/month with predictable traffic, it can come out cheaper than on-demand. Below that threshold on-demand is almost always the better deal.
• codexkey is on-demand only, with no provisioned tier. The markup over Anthropic is zero on cache reads and minimal on standard tokens, though. For the 95% of teams that don't need reserved capacity, the effective cost is the same.
• Bedrock bills in USD on your AWS invoice. codexkey bills in USD or RUB and takes crypto, which matters in jurisdictions where paying a US vendor by card is a struggle.

Feature parity

The big asymmetry is the format. Bedrock uses its own request and response shape (InvokeModel with model-specific JSON bodies), so you need the AWS SDK or a wrapper. codexkey speaks the OpenAI format natively, and every existing client library works unmodified.

Latency

Bedrock has more regions, but you can only pick one. Choose us-east-1 with users in Frankfurt, and every request eats about 90ms of transatlantic RTT. Cross-region inference profiles help with failover but do nothing for the baseline latency of a given user.

codexkey routes traffic through EU infrastructure by default and adds a thin gateway layer (typically <20ms of overhead). For European and Russian users that is usually faster end to end than Bedrock in us-east-1. For US users it is slower by roughly the transatlantic RTT. So if your traffic is mostly US and latency-sensitive, Bedrock in us-east-1 or us-west-2 wins.

Procurement

For many enterprises this is the dimension that decides it:

• Bedrock means no new vendor. AWS is already approved, spend goes into existing contracts, and legal and security have signed their paperwork.
• codexkey means self-serve signup. No contract, no SOC 2 questionnaire, no procurement cycle. You pay by card or crypto and get to work.

At a 5-person startup, self-serve wins every time. At a 5,000-person company with a procurement department, the AWS route is often faster than onboarding a new vendor, even when the new vendor is technically simpler.

Code: boto3 vs OpenAI SDK

The same "summarize this text" call against both services.

Bedrock with boto3:

import boto3
import json

client = boto3.client("bedrock-runtime", region_name="eu-central-1")

response = client.invoke_model(
    modelId="anthropic.claude-sonnet-4.6-20260101-v1:0",
    body=json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 1024,
        "messages": [
            {"role": "user", "content": "Summarize: " + long_text}
        ],
    }),
)

body = json.loads(response["body"].read())
print(body["content"][0]["text"])

You need AWS credentials in the environment (or an IAM role), the model has to be enabled in your account in that region, and the request body format is specific to Bedrock.

codexkey with the OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.codexkey.online/v1",
    api_key="cxa-...",
)

response = client.chat.completions.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Summarize: " + long_text}
    ],
)

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

That's all. If your project already has OpenAI SDK code, the switch comes down to two environment variables and a model name. Streaming, tool use and vision work through the same OpenAI shapes you already know.

When Bedrock wins

Pick Bedrock if any of these holds:

• Your application already runs in AWS, and you don't want a second cloud vendor.
• Your security model requires IAM-based auth and CloudTrail audit of every model call.
• You need VPC PrivateLink so that prompts never touch the public internet.
• You spend enough on Claude for the Provisioned Throughput math to make sense (a rough threshold: $30k+/month with predictable traffic).
• Procurement has already approved AWS, and any new vendor takes a 6-month review.
• Compliance demands a specific regional residency (for example, eu-central-1 only).
• Your users are concentrated in one AWS region, and you want the lowest latency to it.

When codexkey wins

Pick codexkey if any of these holds:

• You have no AWS account, or you have one but your app runs elsewhere (Vercel, Cloudflare, Fly, bare metal).
• You want Claude working in five minutes, not five days.
• You already have OpenAI SDK code and want to add Claude with two environment variables.
• You need to pay in crypto (USDT, BTC, ETH) or through SBP, which is typical for Russia, the CIS and parts of LATAM/MENA.
• Your users are in Europe or Russia, and you want inference routed through the EU by default.
• You are a solo developer, an indie hacker or a small team where "procurement" means your own card.
• You work in Cursor, Cline, Aider, Open WebUI or another tool that expects an OpenAI-compatible endpoint.
• You want pay-as-you-go from $5, with no minimums and no annual commitment.

The bottom line

Bedrock and codexkey are not really competitors. They are two delivery channels for the same models, tuned for different buyers.

• If your environment is AWS, your auth model is IAM, and your buyer is a procurement department, Bedrock wins. The integration cost is real but paid once, and in return you get an AWS-native control plane.
• If your environment is anything else, your auth model is bearer tokens, and your buyer is you with a bank card, codexkey wins. You get OpenAI compatibility, EU presence, payment by crypto and SBP, and a five-minute setup.

For most teams the decision stops being hard once you write the constraints down. Pick the option that matches the shape of your stack. The wrong choice costs more in friction than you will ever save on tokens.