AWS Bedrock Pricing Guide: On-Demand vs Provisioned Throughput

AWS Bedrock brings foundation models from Anthropic, OpenAI, Amazon, Meta, Mistral, DeepSeek, Qwen, and Cohere under one managed service. Understanding how Bedrock bills is what separates a predictable AI line item from a surprise.

Prices verified August 12, 2026 against the AWS Bedrock pricing page and Anthropic's Bedrock documentation. Bedrock rates move monthly and vary by region — always confirm against the AWS console for your own region before committing budget. Where a figure below is region-specific, we say so.

Three things changed in the last year that most Bedrock pricing articles have not caught up with, and each one costs real money:

1. Hourly Provisioned Throughput is largely gone. Reserved capacity — priced in tokens per minute, not Model Units per hour — is the current committed-capacity option. Public hourly Model Unit tables are stale.
2. Regional inference profiles cost about 10% more than global ones. Most teams pick a regional profile by reflex and pay the premium for nothing.
3. Legacy Claude models got more expensive. Claude 3.5 Sonnet moved to Public Extended Access on December 1, 2025 and now bills at $6/$30 per million tokens — double its original rate, and more per token than current-generation Claude Opus 4.8.

This guide breaks down what Bedrock actually charges today, compares it to direct API access, and helps you pick the cheapest correct option for your workload.

Try our free AWS Bedrock Pricing Calculator to model your own token volumes.

Bedrock Pricing Overview

Bedrock has two main ways to pay for inference:

1. On-Demand: pay per token, no commitment. Batch inference is the same thing at a 50% discount for work that can wait.
2. Reserved capacity: commit to a rate of input and output tokens per minute for one or three months. Traffic above the reservation spills to on-demand pricing rather than being throttled.

Beyond inference tokens, these line items catch people out:

• Custom model training (fine-tuning) and the dedicated capacity required to host the result
• Model evaluation jobs
• Knowledge Bases — the embedding calls are cheap, the vector store underneath is not
• Guardrails, evaluated per request
• The regional-vs-global profile premium described above

On-Demand Pricing

On-demand charges per token, with separate input and output rates. All figures below are per 1 million tokens, US regions, global inference profile where one exists.

Anthropic Models (Claude)

Model	Input	Output	Notes
Claude Opus 4.8	$5.00	$25.00	1M-token context
Claude Sonnet 5	$3.00	$15.00	$2.00/$10.00 launch pricing through 2026-08-31
Claude Haiku 4.5	$1.00	$5.00	200K context
Claude 3.5 Sonnet (legacy)	$6.00	$30.00	Public Extended Access, effective 2025-12-01

Two things worth pausing on.

Bedrock does not mark up current Claude models. Opus 4.8 at $5/$25 and Sonnet 5 at $3/$15 are the same rates Anthropic charges on its own API. If someone tells you Bedrock adds a Claude premium, they are working from old information — the premium is in the regional profile, not the model.

The legacy trap is real and it runs the wrong way. Claude 3.5 Sonnet used to be $3/$15. Under Public Extended Access it is now $6/$30. That means an application still pinned to anthropic.claude-3-5-sonnet-* is paying more per token than current-generation Claude Opus 4.8, for a materially less capable model. Most competing pricing guides still quote the retired $3/$15 figure — some still quote it as "$0.003 per 1,000 input tokens." Grep your codebase for pinned legacy model IDs before you do anything else in this article; it is usually the single largest cost win available.

Current-generation Claude models (Opus 5, Opus 4.8, Sonnet 5, Fable 5) are reached through inference profiles rather than ARN-versioned base model IDs. Passing a bare base model ID for a cross-region-inference model returns an HTTP 400 telling you to use an inference profile.

Amazon Nova

Amazon's own family remains the cheapest way to do high-volume, low-complexity work on Bedrock — classification, routing, extraction, summarization of short documents. Nova pricing is published on the Bedrock pricing page under the Amazon tab and is tiered Micro → Lite → Pro → Premier; because these rates have moved several times, we deliberately do not reprint stale figures here. Pull the current numbers from the console for your region.

The structural point matters more than the digits: the gap between a Nova-class model and a frontier model is roughly one to two orders of magnitude per token. Any workload where a small model is sufficient and you are running a frontier model anyway is where your money is going.

Other Providers

Model	Input	Output	Region basis
OpenAI GPT-5.6 Sol	$5.50	$33.00	US, 272K context
OpenAI GPT-5.6 Terra	$2.75	$16.50	US East, in-region
DeepSeek-V3.2	$0.62	$1.85	US regions
Mistral Large 3	$0.50	$1.50	US East
Ministral 14B	$0.20	$0.20	US
Qwen3 Next 80B A3B	$0.15	$1.20	US, standard on-demand

Bedrock now carries OpenAI models directly, which is a genuine change in what the platform is for — it is no longer "everything except OpenAI." Note how wide the spread is: Qwen3 Next 80B costs about 1/37th of GPT-5.6 Sol on input. For retrieval-heavy pipelines that push enormous input volumes through a model, that ratio, not output quality, usually dominates the bill.

Discounts that apply across every model

Mechanism	Effect	When it applies
Batch inference	50% off on-demand	Asynchronous work with no latency requirement
Prompt caching (cache read)	Roughly 10x cheaper than fresh input	Repeated prefixes — system prompts, tool definitions, retrieved documents
Prompt caching (cache write)	Roughly 1.25x normal input	The first request that establishes the cache
Global inference profile	Avoids the ~10% regional premium	Any workload without data-residency constraints

For reference, Bedrock lists Claude 3.5 Sonnet v2 cache writes at $7.50 and cache reads at $0.60 per million tokens against a $6.00 base input rate — the ~10x read discount and ~1.25x write premium in concrete numbers.

Prompt caching is the most underused lever on this list. A RAG or agent workload that resends the same 20,000-token system prompt and tool schema on every turn is paying full input price for the same bytes hundreds of times a day. Caching that prefix converts it to the read rate. Batch is the second: if a nightly enrichment job does not need to answer in real time, it is a 50% discount for changing an API call.

Reserved Capacity (What Replaced Provisioned Throughput)

This is where most Bedrock pricing content is now actively misleading.

The old mental model was Model Units billed by the hour: buy an MU, pay roughly $20-35/hour whether you use it or not, get guaranteed throughput. Articles across the web still print hourly MU tables with specific dollar figures.

That is no longer how committed capacity generally works on Bedrock. The current option is reserved capacity:

• You reserve a rate of input and output tokens per minute, not an opaque "Model Unit"
• Terms are one month or three months
• Traffic above your reservation spills over to standard on-demand pricing rather than being throttled
• Classic Provisioned Throughput still exists for some models, but public hourly rates have largely disappeared from the pricing page — AWS increasingly directs you to your account team for a quote

Two practical consequences:

The unit you plan in changed. "How many Model Units do I need?" was always a guess, because the mapping from MUs to requests per minute varied by model and was never precisely published. Tokens per minute is something you can actually measure from CloudWatch on an existing on-demand workload. Measure first, then reserve.

Overflow changes the optimal strategy. Because exceeding your reservation degrades to on-demand pricing rather than to errors, you should deliberately under-reserve. Reserve at or slightly below your sustained floor and let peaks bill on-demand. The old advice — size your commitment for peak so you never throttle — is now the expensive answer, because you pay for the reserved rate during every quiet hour.

Deciding whether to commit at all

Stay on-demand if any of these are true:

• Traffic is variable, seasonal, or still growing unpredictably
• You are still evaluating models, or expect to switch within the term
• You cannot state a sustained tokens-per-minute floor from real measurements
• Your workload is batchable, in which case the flat 50% batch discount may beat a commitment with none of the lock-in

Consider reserved capacity when all of these hold:

• You have a measured, sustained token rate that persists across the whole term
• You need latency consistency that on-demand contention does not reliably give you
• You are confident in the model choice for the full one or three months

Because current rates are quote-based for many models, the honest answer to "what's the break-even?" is that you have to get the quote and compare it against your measured on-demand spend. Anyone publishing a universal break-even utilization percentage today is extrapolating from a pricing structure that no longer applies. Model your on-demand baseline with the AWS Bedrock Pricing Calculator, then use that number as the figure your AWS quote has to beat.

Do the cheap optimizations before you commit

Committed capacity is the last lever, not the first. In order of effort-to-savings:

1. Unpin legacy models — Claude 3.5 Sonnet at $6/$30 vs Opus 4.8 at $5/$25 is free money
2. Switch regional profiles to global where residency allows — roughly 10%
3. Enable prompt caching on repeated prefixes — up to ~10x on the cached portion
4. Move async work to batch — a flat 50%
5. Right-size the model — Nova or Qwen-class for extraction and routing
6. Then evaluate reserved capacity against what is left

Cost Comparison Examples

All three examples use current August 2026 rates. Arithmetic is shown so you can substitute your own volumes.

Example 1: Customer Service Chatbot

Usage profile: 100,000 conversations/month, 800 input and 400 output tokens each, Claude Haiku 4.5.

Input:  100,000 × 800   =  80M tokens × $1/M = $80
Output: 100,000 × 400   =  40M tokens × $5/M = $200
Total: $280/month

Verdict: On-demand, obviously. At this scale the engineering hours spent optimizing cost more than the bill. The one change worth making is caching the system prompt — if each conversation carries a 2,000-token instruction block, that is 200M cached-eligible tokens a month sitting inside the $80.

Example 2: Document Processing Pipeline

Usage profile: 500,000 documents/month, 10,000 input and 500 output tokens each, Claude Sonnet 5 at list ($3/$15).

Input:  500,000 × 10,000 = 5.0B tokens × $3/M  = $15,000
Output: 500,000 × 500    = 250M tokens × $15/M =  $3,750
Total: $18,750/month

Now apply the levers that need no commitment:

Batch inference (50% off, pipeline is asynchronous):  $9,375/month

Verdict: One API change halves the bill. This is the example that matters most, because document pipelines are almost always batchable and almost never batched. Before anyone opens a conversation about reserved capacity, this workload should already be at $9,375. If it were still pinned to legacy Claude 3.5 Sonnet at $6/$30, it would be $33,750/month — nearly 4x the optimized figure, for a weaker model.

Example 3: High-Volume Code Assistant

Usage profile: 2,000,000 requests/month, 2,000 input and 1,000 output tokens each, Claude Sonnet 5 at list.

Input:  2M × 2,000 = 4.0B tokens × $3/M  = $12,000
Output: 2M × 1,000 = 2.0B tokens × $15/M = $30,000
Total: $42,000/month

This one is latency-sensitive, so batch is off the table. The available moves:

• Prompt caching. A coding assistant resends the same system prompt, tool definitions, and often the same file context every turn. If 1,200 of those 2,000 input tokens are a stable cached prefix, the input portion drops from $12,000 toward roughly $3,000-4,000.
• Model cascade. Route the requests that do not need frontier reasoning — completions, renames, boilerplate — to Haiku 4.5 at $1/$5. Shifting even 40% of traffic cuts thousands.
• Reserved capacity. At $42,000/month of sustained traffic, this is finally the scale where a commitment conversation is worth having — after the two moves above, against the reduced number.

Verdict: Output tokens dominate here ($30,000 of $42,000), and caching does nothing for output. That makes routing — sending cheap requests to cheap models — the highest-leverage change, not the commitment.

The general pattern across all three: identify whether your bill is input-dominated or output-dominated before choosing an optimization. Input-dominated workloads (RAG, document processing, long-context analysis) respond to caching and batch. Output-dominated workloads (generation, agents, code assistants) respond to model routing. Applying the wrong lever wastes the effort.

Bedrock vs. Direct API Access

Anthropic (Claude)

Aspect	Bedrock	Direct Anthropic API
Token price	Same ($5/$25 for Opus 4.8)	Same
Regional premium	~10% for regional profiles	N/A
Billing	Your AWS bill; AWS credits apply	Separate vendor invoice
Enterprise plumbing	VPC, IAM, CloudWatch	Less AWS-native
Context window	1M on current models	1M
Request payload cap	20 MB	Higher

The token price is the same. The capability is not — and this is the part almost no pricing guide covers, because it never appears as a line item.

Per Anthropic's own Bedrock documentation, several features available on the direct API are not supported on Bedrock:

• Server-side tools — web search, web fetch, code execution
• Files API, and URL sources for images and documents
• Agent infrastructure — Agent Skills, the MCP connector, programmatic tool calling, Managed Agents
• Message Batches API (Bedrock has its own separate batch mechanism, so the 50% discount is still available — the API is not)
• Automatic prompt caching — Bedrock requires explicit cache breakpoints instead of the top-level automatic option
• Server-side fallback — implement client-side fallback instead

That caching item has a direct cost consequence. On the direct API you can enable automatic caching with one parameter. On Bedrock you must place breakpoints deliberately. Teams migrating to Bedrock frequently assume caching carries over unchanged, silently lose the discount, and then cannot explain why per-token costs rose despite identical list prices.

Verdict: Choose Bedrock for AWS-native billing, IAM, credits, and data governance. Choose the direct API if your application leans on server-side tools or agent infrastructure. This is an architectural decision, not a pricing one.

Open-weight models (Llama, Mistral, Qwen, DeepSeek)

This is where Bedrock genuinely costs more. Specialist inference hosts — Together AI, Groq, Fireworks — compete hard on serving open weights and typically undercut Bedrock on the same models. Bedrock's premium buys one bill, one IAM boundary, one VPC story, and no additional vendor review.

That is a real trade rather than a rip-off, but it should be a decision rather than a default. If you are running high-volume inference on genuinely commodity weights, price it at a specialist host before assuming Bedrock.

The build-vs-buy floor

For open-weight models there is a third option worth pricing honestly: running them yourself.

Our own local LLM benchmarks on a single RTX 5060 Ti 16 GB (about $570 at time of testing) measured 43 tokens/sec for a model fully resident in VRAM, falling to 2.9 tokens/sec when forced entirely onto an i7-8700 CPU — roughly 15x slower. Separately, a 30B-A3B mixture-of-experts model ran at 10.6 tokens/sec on CPU alone while scoring 8/10 on our graded reasoning task, against 1/10 for a dense 3B model at comparable speed.

The honest reading: self-hosting is competitive for steady, predictable throughput where a $570 card amortizes quickly, and for workloads with hard data-residency requirements. It is not competitive for bursty traffic, for frontier-model quality, or once you price the engineering time to keep it healthy. Bedrock's real advantage over self-hosting is that you pay nothing at 3 a.m. when traffic is zero.

Model both directions with our self-hosted LLM cost calculator and LLM VRAM calculator before committing to either.

Additional Bedrock Costs

Knowledge Bases

Bedrock Knowledge Bases for RAG applications incur:

Component	Cost
Embedding (Titan)	$0.02 per 1M tokens
Vector storage	OpenSearch Serverless charges
Retrieval queries	Per-query embedding cost

Model Evaluation

Evaluation Type	Cost
Human evaluation	Per-task pricing
Automatic evaluation	Model inference costs

Custom Models

Fine-tuning costs include:

Phase	Cost
Training	Per-token training cost
Hosting	Provisioned Throughput required
No on-demand	Custom models need dedicated capacity

Optimization Strategies

1. Right-Size Your Model

Match capability to task. Using current rates:

Task	Model	Input / Output per 1M	Relative to Haiku
Classification, routing, extraction	Claude Haiku 4.5	$1 / $5	Baseline
General chat, most application work	Claude Sonnet 5	$3 / $15	3x
Complex reasoning, agents, hard coding	Claude Opus 4.8	$5 / $25	5x

The spread between tiers is far narrower than it used to be — Opus 4.8 is 5x Haiku, not the 60x gap of the Claude 3 era. That changes the calculus: aggressive downgrade-everything routing buys less than it once did, while leaving a genuinely hard task on a weak model now costs you more in retries and bad output than the token savings are worth. Route by task difficulty, not by reflex.

2. Implement Prompt Caching

Bedrock supports caching repeated prefixes, billed at roughly 10x cheaper on reads. Note that Bedrock requires explicit cache breakpoints — the direct API's automatic caching option is not available here.

# Explicit cache breakpoint on the stable prefix
response = bedrock.invoke_model(
    modelId="global.anthropic.claude-sonnet-5",
    body={
        "anthropic_version": "bedrock-2023-05-31",
        "system": [{
            "type": "text",
            "text": system_prompt,
            "cache_control": {"type": "ephemeral"},
        }],
        "messages": messages,
    },
)

Place the breakpoint at the end of the stable portion. Caching is a prefix match, so anything that varies per request — a timestamp, a user ID, a session UUID interpolated into the system prompt — invalidates everything after it and silently produces zero cache reads. Verify by checking that cache_read_input_tokens is non-zero on repeat requests; if it stays at zero, something in your prefix is changing.

3. Use Batch Inference

For non-real-time workloads, batch inference can reduce costs:

# Submit batch job
response = bedrock.create_model_invocation_job(
    modelId="anthropic.claude-3-haiku",
    inputDataConfig={"s3InputDataConfig": {"s3Uri": "s3://bucket/input/"}},
    outputDataConfig={"s3OutputDataConfig": {"s3Uri": "s3://bucket/output/"}}
)

Batch jobs typically cost 50% less than real-time inference.

4. Monitor with CloudWatch

Set up cost monitoring:

# CloudWatch alarm for Bedrock spending
cloudwatch.put_metric_alarm(
    AlarmName='BedrockSpendingAlert',
    MetricName='InvocationCount',
    Namespace='AWS/Bedrock',
    Threshold=100000,
    Period=86400,  # Daily
    EvaluationPeriods=1,
    ComparisonOperator='GreaterThanThreshold'
)

5. Leverage AWS Credits

Bedrock charges apply to your AWS bill, so:

• AWS Activate credits (startups) can cover Bedrock
• Enterprise agreements may include discounts
• Reserved capacity through AWS can reduce costs

Choosing Your Pricing Model

Stay On-Demand If:

• Traffic is variable, seasonal, or still growing unpredictably
• You are still evaluating models or expect to switch soon
• You cannot yet state a sustained tokens-per-minute floor from real measurements
• The workload is batchable — the flat 50% batch discount carries no lock-in

Consider Reserved Capacity If:

• You have a measured, sustained token rate that will hold for the full one- or three-month term
• Latency consistency matters more than the flexibility you are giving up
• You are confident in the model choice for the whole term
• You have already applied the free optimizations below and the remaining bill still justifies a commitment

The Hybrid That Actually Works:

Reserve at or below your floor, not at your peak, and let overflow bill on-demand. Because exceeding a reservation degrades to on-demand pricing rather than to errors, over-reserving is a pure waste during quiet hours while under-reserving costs you nothing but the on-demand rate on peaks.

Bedrock Cost Checklist

Work these in order — the early items cost nothing but a config change:

• Grep for pinned legacy model IDs. Claude 3.5 Sonnet now bills at $6/$30, more than current Opus 4.8
• Switch regional inference profiles to global wherever data residency permits (~10%)
• Determine whether your bill is input- or output-dominated — this decides which lever to pull
• Add explicit cache breakpoints to stable prefixes, then verify cache_read_input_tokens is non-zero
• Move every asynchronous workload to batch inference (50%)
• Route easy requests to Haiku 4.5 instead of running everything on a frontier model
• Audit current usage in tokens and requests per model via CloudWatch
• Compare Bedrock against the direct API on features, not just price — check whether you need server-side tools
• Confirm AWS Activate or enterprise-agreement credits are being applied
• Only then: get a reserved-capacity quote and compare it against your measured on-demand spend

Conclusion

Bedrock gives you many providers behind one bill, one IAM boundary, and one governance story. That is worth real money to most enterprises. But the platform's pricing structure has moved enough in the past year that a guide written even twelve months ago will lead you to the wrong decisions.

The five things worth remembering:

1. Current Claude pricing matches Anthropic's direct API — Opus 4.8 at $5/$25, Sonnet 5 at $3/$15. There is no Bedrock model premium.
2. The premiums are elsewhere — roughly 10% for regional inference profiles, and 10-40% on open-weight models versus specialist hosts.
3. Legacy models can cost more than current ones. Claude 3.5 Sonnet at $6/$30 under Public Extended Access is the trap; check for pinned model IDs first.
4. Hourly Provisioned Throughput has largely given way to reserved capacity priced in tokens per minute, with overflow to on-demand. Under-reserve deliberately.
5. Caching and batch beat commitments. A 50% batch discount and a ~10x cache-read discount require no term, no quote, and no lock-in — and Bedrock's caching needs explicit breakpoints that do not carry over automatically from the direct API.

Use our AWS Bedrock Pricing Calculator to model your own token volumes, and the LLM Token Counter to measure what your prompts actually cost before you commit to anything.