Amazon Bedrock Pricing Explained: How Much Does It Actually Cost?

Amazon Bedrock looks "pay per 1K tokens" simple — until output costs 5× input, provisioned is $768/day even idle, and cached input saves 90%. This 2025-2026 accurate guide breaks down every Bedrock dollar: on-demand, batch (50% off), provisioned, images, embeddings, fine-tuning and the five hidden add-ons, with real $ per 1M tables and $13.50/day example math — so you can estimate your bill before you call the API.

What Amazon Bedrock Is (and Why Pricing Is Per Token, Not Per Request)

Bedrock is AWS's serverless gateway to foundation models — Anthropic Claude, Amazon Titan, Meta Llama, Mistral, Cohere, AI21 — via one Converse API, no GPU hosts to manage. You call Bedrock getting started, pick modelId: anthropic.claude-3-5-sonnet-20240620-v1:0, send messages, and AWS routes to the provider's inference behind IAM + VPC then back. Add-ons: Knowledge Bases (RAG over S3 + OpenSearch/Aurora vectors), Agents (tool use), Guardrails — each has separate draw on tokens or storage.

Pricing is per token because tokens are how models meter work: ~750 words ≈ 1K tokens (English). Input tokens = prompt + system + RAG docs; output tokens = completion. Providers charge separately because generating costs more compute than reading — Anthropic 5× (Sonnet $3 in vs $15 out), Titan 3×. Images are per image (Titan Image G1 $0.04 per 1024² standard), embeddings per 1K in only (Titan Embed $0.10/1M in, no output). Batch and provisioned reuse the same token meter but with different $/token or $/hour envelope. See Bedrock pricing and Bedrock pricing details.

Regions and Billing

Bedrock is per-Region — you enable models per Region (us-east-1, us-west-2, eu-west-3 etc.) and billing is per-Region. Cross-Region inference (CRI, e.g., us.anthropic.claude-3-5-sonnet-...) adds ~10-15% and routes automatically for higher TPS, but meter still shows input/output per Region in Cost Explorer (Service = Bedrock). Enable Cost Explorer and CloudWatch metrics (InputTokenCount, OutputTokenCount, Invocations) to track before you need to explain a spike. Guide: Cross-Region inference.

Pricing Models — On-Demand, Batch, and Provisioned Throughput

Three envelopes share the same token meter; pick per workload shape, not per model:

1. On-Demand — pay per 1K, no commitment. Default. Auto-scales to your account's TPS quota (e.g., Sonnet 2K TPM default, raise via quota). Best for variable (< 100K TPM avg) or spiky. Break the example math above: 2K in + 0.5K out per request × 1K requests/day → 2M in/day × $3/1M = $6 plus 0.5M out × $15/1M = $7.50.
2. Batch — 50% off, 24h. Submit input JSONL to S3 (s3://bucket/batch.jsonl with {recordId, modelInput}), result lands in S3 within 24h. Same models, half price (Sonnet $1.50/$7.50), no real-time — use for bulk evaluation, distillation, backfills, or nightly RAG indexing. Not for chat. Docs: Batch inference.
3. Provisioned Throughput — $/hour for reserved throughput. Buy Model Units — each unit ≈ X input + Y output tokens/min (published per model, e.g., Claude ~ 20K TPM per unit). Billed hourly while provisioned, even idle. Two types: No commitment (higher $/hr, no lock) vs 1/6-month commitment (discount, e.g., ~30-40% off). Use when you need guaranteed TPS for latency (chat at scale) and your steady load > 10M tokens/day. Break-even example: 1 unit Sonnet ~$32/hr → $768/day → $23K/mo if 24/7. At steady 40K input TPM that many tokens on-demand would be ~$35K/mo → provisioned saves ~35%. At 5K TPM spiky, on-demand is $2K/mo vs provisioned $23K — stay on-demand.

Rule of thumb: if your on-demand cost at p95 TPM steady < 60% of provisioned hourly × 730 hrs, stay on-demand. Switch only when p50 stays high for weeks. See Provisioned Throughput and Bedrock pricing for current $/hr per model.

Custom Models (Fine-tuned) — Two Bills

Fine-tuning Titan or Llama via Bedrock: training cost = $ per 1K training tokens (e.g., Titan Text fine-tune ~$8 / 1M tokens, one-time per job) plus hosting cost = provisioned throughput hrs to serve the custom model (cannot be on-demand — fine-tuned models run only provisioned). Only fine-tune if base fails after prompt engineering and RAG — most price deltas vanish with better prompts. Guide: Custom models.

Real Prices — $ Per 1M Tokens by Model (On-Demand us-east-1 Snapshot)

Snapshot as of 2025-Q4 us-east-1 on-demand — always verify at Bedrock pricing (cross-Region +~15%):

Pattern: output always > input (Anthropic 5×, Titan 3×) because generation is more compute. Llama and Titan are cheapest for high volume where Haiku/Sonnet quality isn't needed. Batch halves both (Sonnet $1.50/$7.50).

What 100K, 1M, and 10M Tokens Actually Cost — Calculator Examples

Translate per-1M to per-day with consistent math — input + output separately:

Cost/day = (Input_Tokens/day / 1M) * $Input_per_1M  +  (Output_Tokens/day / 1M) * $Output_per_1M

• Chatbot 1K requests/day × 2K in + 0.5K out (RAG prompt + short answer): 2M in + 0.5M out/day → Sonnet: 2×$3 + 0.5×$15 = $6 + $7.50 = $13.50/day → $405/mo; same volume on Haiku: 2×$0.80 + 0.5×$4 = $1.60+$2 = $3.60/day → $108/mo (73% cheaper for non-code chat).
• Support Copilot 10K requests/day × 1.5K in + 300 out: 15M in + 3M out/day → Sonnet: 15×$3= $45 + 3×$15= $45 → $90/day → $2,700/mo; Haiku: 15×$0.80= $12 + $12 = $24/day → $720/mo.
• Embeddings 10M tokens (docs): Titan Embed $0.10/1M → $1.00 total for 10M. Running that same 10M as Claude input would be $30 (Sonnet) — 30× waste; use Titan/Cohere Embed for vectors.
• Images 1K/day Titan Image 1024 Standard: 1K×$0.04 = $40/day → $1,200/mo; 512 resolution is ~$0.02 half that.
• 1M tokens context — size: ~750K words ≈ 1.5 novels. RAG fetching 100 docs × 10K prompt = 1M in → Sonnet $3 in once; batch that nightly eval → $1.50.

Use AWS Pricing Calculator (Bedrock) to plug your requests/day and avg tokens — it multiplies the same formula but lets you switch models and batch.

Token Counting — Don't Guess, Measure

Tokens ≠ words ≠ characters. Count with: Amazon Titan tokenizer or Anthropic's claude-tokenizer (anthropic-tokenizer) or Bedrock's CountTokens (Count tokens). In code, call bedrock-runtime CountTokens dry-run, or use CloudWatch InputTokenCount/OutputTokenCount after first week to get p50/p95 per request, then multiply. Under-counting by 30% is the most common estimate error (prompts grow with RAG).

Provisioned Throughput — $/Hour for Guaranteed Throughput (When It Actually Saves)

Provisioned buys private capacity for a model — Model Units. Each unit is ~X input + Y output tokens/min (varies per model; e.g., Claude Haiku 1 unit ≈ 20K input TPM). You provision Units, AWS guarantees that TPS (not latency) via dedicated inference hosts, billed per hour the Units exist — even midnight idle.

On-Demand cost at throughput = (tokens/min * 60 * 24 / 1M) * $/1M
Provisioned cost = Units * $/hr per Unit * 24 * 30
→ Pick cheaper at your steady throughput; at spiky, On-Demand wins even if peak > Provisioned.

Example snapshot (check pricing page for current $/hr): 1 Unit Claude Sonnet No-commit ≈ $32/hr → $768/day → ~$23K/mo if 24/7. At steady 40K input TPM that many tokens via on-demand would be ~40K×60×24/1M×$3 = $172.8/day input alone plus output → ~$35K/mo → provisioned saves ~35%. At 5K TPM spiky (8h/day burst), on-demand = ~$2K/mo vs provisioned $23K — 10× waste.

Commit discounts: 1-month and 6-month provisioned (30-40% off vs No-commit) if you know you'll need it. Without commitment, you can delete Units but still pay the hour you held them. Docs: Provisioned Throughput and purchase at Purchase Provisioned.

Cross-Region Inference (CRI) — Hidden 10-15% Add-On

CRI (us.anthropic.claude-...) automatically routes across Regions for higher quota and resilience — billed with ~10-15% uplift over base Region per CRI pricing. Use when single-Region TPS is throttling (429) and you need burst; otherwise single Region is cheaper.

Hidden Costs Most Estimates Miss — And How to Cut 50-80% Without Model Swap

The $/1M token is not the total bill. Five add-ons often double it:

• Knowledge Bases + vector store: Bedrock Knowledge Bases charge for embedding tokens (Titan Embed $0.10/1M) plus the store: OpenSearch Serverless (OCU-hours, $0.24/OCU/hr + storage $0.024/GB/hr) or Aurora Serverless v2, or S3 Vectors. A 10M doc index (≈7.5M words) costs negligible embed $1 but OCUs might be $300-600/mo if always on — most surprise.
• Agents + Guardrails: Agents loop — each thought calls the model again, multiplying input tokens (3 steps × 2K = 6K per request, not 2K). Guardrails add latency and input for filtering.
• Custom model hosting: fine-tuned host is provisioned hours, even zero inference — don't leave a 6-month commit hosting while evaluating.
• S3 + CloudWatch + data transfer: Batch JSONL on S3, logs to CloudWatch Logs ($0.50/GB ingested), plus cross-AZ data if Bedrock VPC.
• Prompt caching (biggest save): Claude prompt caching lets you mark system/RAG as cacheable; cached input is $0.30/1M vs $3 (90% off) + $3.75 cache-write once per 5 min. For RAG with 10K stable context per request, caching cuts $30/day → $5/day input. Enable via cacheControl per Prompt caching. Titan and Llama don't have equivalent yet.

Four prompt savings that beat model swap:

1. Cache stable system + RAG (Claude 90% off) — biggest.
2. Compress RAG: rerank + compress 10K retrieved → 3K top chunks via Cohere rerank before LLM — 70% less input, often better quality.
3. Haiku for classifier, Sonnet for coder: route via Agents routing or your own if intent==coding → Sonnet else Haiku — Haiku is 73% cheaper for chat/summarize.
4. Batch where possible: nightly eval, distillation data gen, backfills → 50% off, no user wait.
5. Titan/Cohere Embed for vectors: 30× cheaper than Claude for embeddings — use the right tool per subtask.

Fine-Tuning Cost Reality

Customization: Titan fine-tune training ~$8 / 1M training tokens (one-time per job, e.g., 5M tokens = $40) plus provisioned hosting after (hrs). Only if base + RAG + caching fail after prompt optimization — most gaps close with better retrieval, not weights. If you do fine-tune, use Provisioned with commit and scale to zero when not serving (delete Units).

Five-Step Bedrock Calculator — Estimate Your Bill

1. Tokens/request: Measure p50/p95 via CloudWatch InputTokenCount/OutputTokenCount for a week, or tokenizer: e.g., 2K in + 0.5K out.
2. Requests/day: e.g., 1K/day → 2M in + 0.5M out/day.
3. Model price: pick per table (Sonnet $3/$15).
4. Cost = (Input/1M×$in) + (Output/1M×$out): 2×$3 + 0.5×$15 = $13.50/day.
5. Check variants: Batch 50% off → $6.75/day if async; Provisioned $32/hr×24=$768/day — only cheaper at steady high TPM.

Track via Cost Explorer (Service = Amazon Bedrock, Usage Type = tokens or Provisioned) and set a budget alarm: CloudWatch Alarm on InputTokenCount + OutputTokenCount > 1M/day → SNS. See Monitoring Bedrock and AWS Pricing Calculator.

Region Pricing and Cross-Region Inference — 15% You Didn't Budget

Bedrock model availability and $/1M vary by Region. us-east-1 is usually cheapest and broadest (all Claude/Titan/Llama). eu-west-3 or ap-northeast-1 add ~10-15% (check pricing per-Region tab). Cross-Region Inference (CRI) using inference profiles like us.anthropic.claude-3-5-sonnet-20240620-v1:0 automatically routes across Regions for higher TPS and resilience — billed with CRI uplift (~10-15% over single Region). Use CRI only when you're hitting single-Region TPS quota (default 2K TPM for Sonnet, raise via Service Quotas) and need burst; otherwise single Region is cheaper. Track via Cost Explorer filtered by Region and by inference profile ID. Docs: Cross-Region inference and Inference profiles.

Images, Embeddings, and Audio — Not Token Pricing

• Titan Image Generator G1: per image, not tokens — Standard 1024×1024 $0.04, 512×512 ~$0.02, Premium variations higher. No batch discount; provisioned not available. Docs: Titan Image params.
• Titan Embeddings G1 - Text: $0.10 / 1M input tokens, no output. For RAG, embed once (10M doc → $1) and query embed per search (~1K → $0.0001). Cohere Embed $0.10 similar; never use Claude input pricing for embeddings — 30× waste.
• Audio (future): if using Bedrock-backed Transcribe/Polly-adjacent, billing is per second, not Bedrock tokens — separate.

Knowledge Bases, Agents, Guardrails — Architecture Multipliers

Bedrock's value is orchestration, but each multiplies tokens or storage:

1. Knowledge Bases: Ingest: chunking + Titan Embed $0.10/1M (same 10M doc $1 one-time) plus vector store: OpenSearch Serverless (minimum 2 OCUs for indexing + search ~ $700/mo if always on, as low as $0 if paused but collections charge even idle), Aurora PostgreSQL with pgvector, or new S3 Vectors (preview, cheaper per vector). Many bills surprise with OCUs, not tokens. Chunk size matters: 500-token chunks × 10K docs = 5M embed $0.50, but query retrieves 3K vs 10K if not reranked.
2. Agents: An Action Group loops — 1 user request → Agent thought (LLM call 1) → Action (Lambda) → Observation → next thought (LLM call 2) → final (call 3). 1 user request → 3× LLM calls (each 2K in + 0.5K out) → $40.50/day vs $13.50 single call. Budget per agent trace, not per user request. See Agents.
3. Guardrails: Input+output filtering adds tokens (deny topics, PII) and latency; billed per 1K of filtered text at Bedrock rates for that model. Enable only after measuring false positives on haiku first.
4. Provisioned custom: Agents on fine-tuned models require provisioned — see below.

Fine-Tuning Deep — When $40 Training + $23K Hosting Is Worth It

Bedrock fine-tuning for Titan Text or Llama via S3 JSONL: e.g., Titan fine-tune training ~$8 / 1M tokens — a 5M token dataset = $40 one-time. But the resulting custom model cannot run on-demand — only provisioned hours (e.g., 1 unit ~$32/hr → $23K/mo if 24/7). Unless your base model fails after prompt engineering + RAG + caching + Haiku/Sonnet routing all tried, you pay hosting forever for a small gain. Alternatives before fine-tune: better retrieval (reranker), prompt cache, few-shot examples (cheaper). If you do fine-tune, use Provisioned with 1-month commit and delete Units when not A/B testing, or host via SageMaker jump-start if provisioned not needed continuously. Docs: Custom models and Prereq.

Prompt Caching Deep — The 90% Off Most Teams Miss

Claude prompt caching on Bedrock via cacheControl (system, tools, or RAG prefix) marks stable input as cacheable: first write stores (~$3.75 / 1M cache-write), next reads in 5 min window are $0.30 / 1M (90% off vs $3). Example RAG 10K stable context × 1K requests/day: without cache 10M in/day ×$3/1M = $30/day input; with cache 10M ×$0.30 = $3/day → save $27/day → $810/mo on Sonnet. Titan/Llama lack equivalent — another reason to route cacheable RAG through Claude and non-cacheable through Haiku. Implement: Prompt caching (anchor cache_control in Converse). Cache hits appear in CloudWatch CacheReadInputTokens vs CacheWrite.

Cost Allocation — Tags, Budgets, and Alerts Before the Surprise

Bedrock supports Cost Allocation Tags — tag inference profiles and Knowledge Base resources with project:abc, env:prod then filter Cost Explorer by tag. Create a Budget: AWS Budgets → Cost budget → Service=Bedrock, Amount=$500/mo, alert at 80%/100% → SNS email/Slack. Add CloudWatch Alarm: InputTokenCount + OutputTokenCount > 5M/day per model. Without this, a runaway Agent loop (bug retries) can burn $1K overnight — same as any serverless pay-per-use. Guide: Cost Allocation Tags, Monitoring Bedrock.

Bedrock vs Direct vs Other — When Bedrock Isn't Cheapest

Bedrock tokens for Sonnet mirror Anthropic direct ($3/$15) — you pay for AWS IAM, VPC PrivateLink, CloudTrail, Knowledge Bases, Guardrails, and provisioned/batch envelopes. If you don't need those, direct Anthropic or OpenAI direct may be cheaper per token and have same quality. AWS advantage is enterprise governance: VPC endpoints, IAM RBAC per model, CloudWatch audit, and buying via EDP commit. For pure price on embeddings, Titan Embed on Bedrock ($0.10) matches Cohere direct; for images, Bedrock Titan Image $0.04 vs Stability via Bedrock similar. Choose Bedrock when you need AWS ecosystem continuity, not just cheapest per-token.

Free Tier, Trials, and How to Start Cheap

No permanent free tier for Bedrock inference — new AWS accounts get no free tokens. Best low-cost start: on-demand with Haiku or Titan Text ($0.50 in) + Titan Embed ($0.10) + OpenSearch Serverless with small OCUs, and batch for eval. Keep RAG prompts cached (Claude) and small (3K not 10K). Ingest one KB, measure InputTokenCount for 100 real queries before scaling — extrapolating from 1 query ×10K under-estimates by 3× when prompts grow.

Enterprise Commit — EDP and Quotas

Large AWS spend can route Bedrock through your Enterprise Discount Program (EDP) — Bedrock on-demand and provisioned count toward EDP commit like EC2, but batch and fine-tune may not (check with TAM). Quotas matter too: default TPS per model (Sonnet ~2K TPM, Haiku higher) throttle burst; raising via Service Quotas → Bedrock → Requests is free but takes days. If you plan provisioned, request TPS + Units weeks before launch — Users who scale from 1K to 100K TPM overnight hit ThrottlingException: Too many requests even with budget, not just cost, but quota.

Calculator Walkthrough — Build Your Sheet in 5 Rows

Duplicate this sheet before you call support:

Row A: Avg input tokens/request (measured)  = 2,100 (2K prompt + 100 system cached)
Row B: Avg output tokens/request             = 520
Row C: Requests/day                          = 8,400 (e.g., 350/hour ×24)
Row D: Input/day = A×C = 17.64M → Cost in = 17.64 × $3/1M = $52.92/day (Sonnet)
Row E: Output/day = B×C = 4.37M → Cost out= 4.37 × $15/1M = $65.55/day
Day total = $118.47 → Mo = $3,554 → Batch offline eval (50% off) = $1,777 for same if 24h OK
Cached? → Input cached 2K of 2.1K = 16.8M cached × $0.30 + 0.84M uncached × $3 = $5.04 + $2.52 = $7.56 vs $52.92 → save $45/day

Input is where caching and RAG compression win. Without them, 17M in/day dominates. With cache + 3K compressed (vs 10K raw), input drops 70% before rate change.

Support Policy and Model End-of-Life — Hidden Lifecycle Cost

Models retire — e.g., Claude 2 → 3 migration required code+pricing change (Opus $15/$75 vs Sonnet $3/$15). Bedrock keeps legacy versions for months after deprecation but price may rise. Pin modelId with version (anthropic.claude-3-5-sonnet-20240620-v1:0 not without date) and test bump via inference profile before prod. See Model IDs for lifecycle.

Common Mistakes — The $500 Surprises

From OpenAI Pricing Mental Model to Bedrock — Direct Translation

If you come from OpenAI's $5 / $15 for GPT-4o, Bedrock Sonnet $3/$15 will feel familiar but watch two deltas: Bedrock batches 50% off (OpenAI batch also 50% but via different API) and Bedrock prompt caching 90% off (OpenAI cached 50% off) — so RAG heavy on Bedrock Claude caches better. Conversely, OpenAI's fine-tune hosting is cheaper short-term (no provisioned Units). Translate: OpenAI cost sheet ×0.9 for Claude RAG heavy on Bedrock with cache, ×1.15 if using CRI across Regions.

What to Do Next — 3-Step Launch Checklist

1. Measure: Enable CloudWatch InputTokenCount/OutputTokenCount for one Knowledge Base query type over 100 samples → p50/p95. Count via tokenizer for batch JSONL.
2. Model-route: Haiku for classify/summarize, Sonnet for code, Titan Embed for vectors — one logic split cuts 50% before any Infra.
3. Cache + compress: Add cacheControl to stable RAG, rerank 10K → 3K, then compare On-Demand p95 vs Provisioned $/hr × 730 via AWS Pricing Calculator before committing.

Add Cost Allocation Tags on day one — retroactive tagging doesn't reattribute past spend.

Bonus — Logs tell truth: enable Bedrock model invocation logging to S3 (input + output + latency) for one week before launch — CloudWatch tokens tell you volume, logs tell you which prompt template is 10K vs 2K and where to cache or compress. One log review often finds a repeated system prefix eating 30% of input cost.

Keep modelId version pinned — 20240620-v1:0 not floating — so pricing and behavior stay reproducible across months.

Frequently Asked Questions

How much does Amazon Bedrock actually cost per 1K tokens?

Depends on model and direction (input vs output). On-demand snapshot us-east-1: Claude 3.5 Sonnet $0.003 in + $0.015 out per 1K, Haiku $0.0008/$0.004, Titan Text $0.0005/$0.0015, Titan Embed $0.0001 in only, Llama 3 70B $0.00265/$0.0035. Batch is half; provisioned is $/hour. See Bedrock pricing.

Is Bedrock cheaper than calling Anthropic or OpenAI directly?

Tokens price is rostered similarly (Sonnet $3/$15 matches Anthropic direct), but Bedrock adds AWS IAM, VPC, CloudWatch, Knowledge Bases, and provisioned/batch envelopes — you pay for integration, not necessarily cheaper per token. Direct may be cheaper if you don't need AWS ecosystem.

What is provisioned throughput and when is it worth it?

Reserved Model Units billed hourly for guaranteed throughput. Worth it at steady high load (roughly >40K input TPM sustained) where its hourly ×730 is < on-demand at that TPM; not for spiky or <60% utilization. See Provisioned.

Does Bedrock have a free tier?

No permanent free inference. You pay per token/hour from first call; new accounts get standard AWS free tier for S3/CloudWatch but not Bedrock tokens. Start cheap with Haiku/Titan + caching + batch for eval.

How do I estimate my monthly Bedrock bill?

Measure avg input/output tokens per request via tokenizer or CloudWatch (week), multiply by requests/day, then × $/1M per model (input×$in + output×$out). Compare batch (50% off) and provisioned ($/hr×24×30). Use AWS Pricing Calculator and Cost Explorer Service=Bedrock.

Why is output more expensive than input?

Generation does more compute (autoregressive decode). Providers price output 3–5× input to reflect GPU time. Anthropic 5×, Titan 3×. Batch still halves both.