AWS costs: Bedrock pricing - tokens, worked example per model

Amazon Bedrock charges per token for most models — a separate rate for input tokens and a separate, usually higher, rate for output tokens — and the rate depends entirely on which model and which AWS Region you pick, not on Bedrock itself. The counterintuitive part: if you're running Claude Sonnet 4.6 or latest Claude Fable 5.1 on Bedrock today (if u ask me whether its available, yes it is), that spend does not show up as a line item labeled "Amazon Bedrock" in your AWS bill or Cost Explorer — Amazon's own documentation confirms current-generation Claude models are billed as third-party software through AWS Marketplace, filed under the model provider's name instead. And if you've ever been throttled mid-request and simply retried, there's a decent chance you paid for the same tokens twice. This is another important service for our AI/Machine learning in AWS. So, i thought will write a separate post on this too!

How Amazon Bedrock actually charges for tokens

A "token" is a chunk of text — sometimes a whole word, sometimes a piece of one. You never see the token count directly when you type a prompt; the model's API response tells you afterward how many input tokens it read and how many output tokens it wrote. Amazon Bedrock's pricing page states plainly that pricing depends on the modality, the provider, and the specific model — there's no single "Bedrock rate." Every provider listed on the pricing page — AI21 Labs, Amazon, Anthropic, Cohere, DeepSeek, Google, Meta, Mistral AI, Moonshot AI, NVIDIA, OpenAI, Qwen, Stability AI, TwelveLabs, Writer, xAI, and Z AI — sets its own per-token rate, and AWS bills you at whatever that provider's current listed rate is for the Region you're calling from.

The two numbers you'll see on every pricing table are labeled Price per 1M input tokens and Price per 1M output tokens. Some older AWS worked examples still express the same rate per 1,000 tokens instead of per million — both are the same math, just moved three decimal places. If a number looks ten times too low or too high compared to what you expected, check which denominator the table is using before you assume the price changed.

What "input" and "output" tokens include

Input tokens are everything you send in a single request: your prompt, your system instructions, any conversation history you re-send, and any documents you attach. Output tokens are everything the model generates back: the answer text, and — for models that support it — any extended reasoning or "thinking" content the model produces before its final answer. That reasoning content is billed as output tokens, not as a separate category, on the models where AWS documents it.

Reading the tables without misplacing a decimal

Ethan's rule for Jake: read the header row of every table twice before you read the numbers. "Price per 1M input tokens" and "Price per 1,000 input tokens" describe the exact same underlying rate on two different pricing pages, and a spreadsheet built by copying numbers between the two without converting will be off by a factor of a thousand. It sounds obvious until you're the one who built the spreadsheet at 11pm.

On-Demand, Batch, and Provisioned Throughput — the three ways to pay

Bedrock gives you three fundamentally different billing shapes, and picking the wrong one for your traffic pattern is where most surprise invoices come from.

Batch inference works by submitting a file of prompts and letting Bedrock process them asynchronously, with results written back out for you to collect — and AWS's own pricing page states the discount plainly: select foundation models from Anthropic, Meta, Mistral AI, and Amazon get batch inference at 50% lower price than On-Demand for the same model. Not every model supports Batch; several of the newer on-demand tables (DeepSeek, OpenAI's gpt-oss family, Qwen) list their own Batch column directly alongside Standard, Priority, and Flex, so check the specific model's table rather than assuming.

Provisioned Throughput is the opposite shape entirely: instead of paying per token, you buy a fixed number of "model units" at an hourly rate, committed for one month or six months, and you pay that rate whether you send one request or one million. For a customized (fine-tuned) model on Bedrock, this isn't optional — AWS's documentation states directly that a customized model requires Provisioned Throughput; there is no On-Demand tier for a fine-tuned model, at any volume.

The four service tiers: Standard, Priority, Flex, and Reserved

Layered on top of On-Demand pricing, Bedrock also supports service tiers, and this is where a lot of the recent-model pricing tables (DeepSeek, Google's Gemma family, MiniMax, Mistral, Moonshot's Kimi models, NVIDIA's Nemotron family, OpenAI's gpt-oss models, Qwen, and Z AI's GLM models) all repeat the identical footnote: Priority tier pricing runs at a 75% premium over Standard tier pricing, and Flex tier pricing runs at a 50% discount to Standard tier pricing. Amazon's own Nova pricing page describes the same three tiers in plain language: Standard provides consistent performance at regular rates for everyday tasks; Priority is a premium tier that provides preferential compute allocation for mission-critical applications; Flex offers discounted pricing for workloads that can trade immediate processing for cost efficiency.

Ethan put it to Jake this way: "Standard is what you get by default if you never touch the setting. Priority is for when a slow answer costs you a customer. Flex is for when nobody's watching the clock." Jake's shop runs an overnight inventory-description job that nobody reads until morning — that's a textbook Flex candidate, and switching it over cut the job's model spend without changing a single word of the prompts. "Took me ten minutes to change one string in the code," Jake said. "I spent longer arguing with myself about whether it was worth doing."

Reserved capacity is the fourth tier, aimed at sustained, predictable workloads with dedicated throughput; AWS's pricing page lists it as a heading across several provider pages but directs pricing conversations to your AWS account or sales team rather than publishing a flat rate, the same way it does for most Provisioned Throughput quotes on newer models.

Worked examples: what a request actually costs, model by model

Amazon Bedrock's own pricing page publishes worked pricing examples for several providers, using the exact same formula every time: take the input tokens, divide by the denominator the table uses, multiply by the input rate; do the same for output tokens; add the two together. Below are AWS's own examples, provider by provider, so you can see the formula applied with real numbers before you plug in your own.

Anthropic Claude

AWS's official worked example for Anthropic: a developer in the US West (Oregon) Region sends Claude an input of 11K tokens and gets back an output of 4K tokens. The math: 11K tokens ÷ 1,000 × $0.008, plus 4K tokens ÷ 1,000 × $0.024, equals $0.088 plus $0.096, for a total of $0.184 per request.

Amazon Titan

Titan Text Lite, on an hourly basis: a request summarizing 2K tokens of input to 1K tokens of output. The math: 2K ÷ 1,000 × $0.0003, plus 1K ÷ 1,000 × $0.0004, for a total hourly cost of $0.001 — a tenth of a cent. For image generation, Titan Image Generator is priced per image rather than per token: 1,000 standard-quality images at 1024×1024 resolution, at $0.01 per image, comes to $10 total. Fine-tuning Titan Image Generator with 1,000 image-text pairs, then running an hour of Provisioned Throughput to evaluate it, plus a month of storage, comes to a documented $182.95 for the full cycle — training, storage, and evaluation together.

Meta Llama

Llama 2 Chat (13B), summarizing a 2K-token input to a 500-token output: 2K ÷ 1,000 × $0.00075, plus 500 ÷ 1,000 × $0.001, for a total of $0.002 per request. AWS's current on-demand table for Llama 2 lists Chat (13B) at $0.75 per million input tokens and $1.00 per million output tokens, and Chat (70B) at $1.95 per million input and $2.56 per million output — the same rates the example above is built from, just expressed per million instead of per thousand.

Cohere

Cohere's Command model, summarizing a 6K-token input to a 2K-token output: 6K ÷ 1,000 × $0.0015, plus 2K ÷ 1,000 × $0.0020, for a total of $0.013. The lighter Command-Light model, same 6K-in/2K-out shape, comes to $0.003. Embedding models bill differently — there's no output side at all. Generating embeddings for 10K tokens of input on either Embed English or Embed Multilingual costs 10K ÷ 1,000 × $0.0001, or $0.001 total, because embedding models charge for input tokens only. Rerank 3.5 bills separately again, at $2.00 per 1,000 queries, where a query can carry up to 100 document chunks — a request with 350 documents counts as 4 queries, and any document over 512 tokens gets split into more than one document to fit the cap.

Mistral AI

AWS's hourly worked examples for Mistral: the Mistral 7B model on a 2K-in/1K-out request comes to $0.0005 per hour; Mixtral 8x7B on the same shape comes to $0.0016; Mistral Large on the same shape comes to $0.04. On the current on-demand lineup for newer Mistral models — Devstral 2 123B, Magistral Small 1.2, the Voxtral speech models, the Ministral family, and Mistral Large 3 — prices in US East and US West Regions range from $0.04 per million input tokens for Voxtral Mini up to $0.50 per million input tokens for Mistral Large 3, with Asia Pacific, South America, and European Regions consistently running higher for the identical model.

DeepSeek

AWS's hourly worked example for DeepSeek-R1: a request that summarizes 2K tokens of input to 1K tokens of output, including reasoning tokens, comes to 2K ÷ 1,000 × $0.00135, plus 1K ÷ 1,000 × $0.0054, for a total hourly cost of $0.0081. On the current DeepSeek v3.2 on-demand table, US East (N. Virginia), US East (Ohio), and US West (Oregon) price at $0.62 per million input tokens and $1.85 per million output tokens; Asia Pacific (Mumbai), South America (São Paulo), Asia Pacific (Jakarta), Asia Pacific (Tokyo), and Europe (Stockholm) price higher at $0.74 and $2.22; Asia Pacific (Sydney) sits closer to the US rate at $0.6386 and $1.9055.

Stability AI

Stability's image models are priced per generated image rather than per token, and the price scales with step count and resolution. AWS's own examples: an SDXL request generating a 512×512 image at a step size of 70 (premium quality) costs $0.036 per image; the same step count at 1024×1024 resolution on SDXL 1.0 costs $0.08 per image. Most of Stability's current image-editing services — background removal, object erase, structure control, style transfer, inpainting, search-and-replace, search-and-recolor — sit at a flat $0.07 per generation, with style transfer at $0.08, upscaling priced separately from $0.03 for fast upscale to $0.60 for creative upscale, and outpainting at $0.06 per image.

TwelveLabs

TwelveLabs bills video and embedding requests on a mix of duration and token pricing. AWS's example: describing a 10-second video with the Pegasus 1.2 model, producing a 2,000-token output, costs 10 seconds × $0.00049 plus 2K ÷ 1,000 × $0.0075, for a total of $0.0199. Embedding 10 videos totaling 100 minutes with the Marengo Embed model costs 6,000 seconds × $0.00070, or $4.20. A mixed text-and-image query against that embedding library, using Marengo Embed 3.0, costs $0.00007 for the text portion plus $0.0001 for the image portion — $0.00017 total.

AI21 Labs

AWS's example for AI21's Jurassic-2 Mid model: summarizing a 10K-token input to a 2K-token output. The math: 10K ÷ 1,000 × $0.0125, plus 2K ÷ 1,000 × $0.0125, for a total of $0.15 — a case where AWS's own example happens to use the same rate for input and output.

Where the Claude reveal lives: AWS Marketplace billing

This one catches finance teams off guard more than any single per-token number does. You can run the exact same invoke_model or converse API call against Claude Sonnet 4.6 that you'd run against any other Bedrock model — same endpoint, same SDK, same code — and the billing plumbing behind it still routes to Marketplace rather than to a generic Bedrock usage line. AWS's documentation lists the model ID as anthropic.claude-sonnet-4-6, with a global inference profile ID of global.anthropic.claude-sonnet-4-6, and for Haiku 4.5, global.anthropic.claude-haiku-4-5-20251001-v1:0. The same documentation confirms Standard, Priority, Flex, and Reserved service tiers all apply to these models, that prompt caching is available on the bedrock-runtime endpoint, and that Bedrock offers three inference routing options for them: In-Region, which keeps requests inside a single Region for strict compliance needs; Geo Cross-Region, which routes within a geography such as US, EU, or APAC while respecting data residency; and Global Cross-Region, which routes anywhere with no residency constraint.

"Half my job this month was just figuring out which line item was actually Claude," Jake admitted. Ethan's answer: "That's not a Jake problem, that's an everyone problem right now. Tag your resources by application, not by provider, and this stops mattering — the tag survives the billing reshuffle even when the line-item label doesn't."

Provisioned Throughput math: what a model unit actually costs per month

Provisioned Throughput is billed hourly, per model unit, for the length of your commitment — whether you use it or not. AWS's own worked examples show exactly how fast this adds up:

Cohere's Provisioned Throughput table also publishes committed-term discounts directly: Cohere Command runs $49.50 per hour with no commitment, $39.60 with a 1-month commitment, and $23.77 with a 6-month commitment. Cohere Command-Light runs $8.56, $6.85, and $4.11 across the same three commitment lengths, and both Embed 3 English and Embed 3 Multilingual run $7.12, $6.76, and $6.41. That's roughly a 52% discount for committing six months versus paying with no commitment at all on Cohere Command — a meaningful number if your volume is genuinely steady, and a meaningful trap if it isn't.

To decide which mode fits your workload, work through it in order:

1. Estimate your real request volume and shape. Requests per day, average input tokens, average output tokens — not your best-case guess, your actual traffic if you have it.
2. Check whether the response needs to come back instantly. If a delay of minutes to hours is fine, price out Batch first — it's the same model at half price.
3. Multiply your On-Demand estimate against a Provisioned Throughput unit's hourly rate for a full month. If On-Demand comes in lower, stay On-Demand, even at high volume — Provisioned Throughput is for capacity guarantees, not automatically for savings.
4. If you've customized or fine-tuned the model, you don't get a choice — Provisioned Throughput is required, so build that fixed cost into your plan from day one.

Custom Model Import: the "free to import, pay to run" model

If you already have a customized model — your own fine-tuned Llama, Mistral, Mixtral, Flan, or Qwen weights — Bedrock's Custom Model Import lets you bring it in and run it On-Demand instead of forcing Provisioned Throughput. There's no charge to import the model itself. In US East (N. Virginia) and US West (Oregon), the price is $0.05718 per Custom Model Unit per minute, plus $1.95 per Custom Model Unit per month in storage; in Europe (Frankfurt) the per-minute rate rises to $0.07144. Billing runs in 5-minute windows: the metering clock starts at your first successful invocation, and if there's no further invocation in a 5-minute window, Bedrock scales the model copy down to zero and metering stops.

AWS's own worked example: importing a customized Llama 3.1 8B model with a 128K sequence length in us-east-1 requires 2 Custom Model Units, priced on the page at $0.1570 per minute for that pair, with monthly storage across 2 units running $3.90. If your first successful invocation lands at 8:03 AM and nothing else invokes the model after 8:07 AM, only the single 5-minute window from 8:03 to 8:07 gets billed: $0.1570 × 5 minutes × 1 window equals $0.785 for that burst of usage — then billing stops until the next invocation restarts the clock. The number of Custom Model Units a given import needs depends on architecture, parameter count, and context length; AWS notes a Llama 3.1 8B 128K model needs 2 units, while a Llama 3.1 70B 128K model needs 8.

Quotas, throttling, and the endpoint you didn't know you were using

Every price on this page assumes your request actually goes through. It doesn't always. Bedrock enforces per-model quotas — Tokens Per Minute (TPM) and, for some models, Requests Per Minute (RPM) — and AWS's documentation is specific about how they're counted: on the primary bedrock-runtime endpoint, TPM quotas count input and output tokens together against a single per-model quota, rather than tracking them separately. RPM is enforced for some models on that endpoint and not others; AWS's documentation notes that Anthropic's Claude Opus 4.7 and Claude Opus 4.8, for example, carry no RPM quota at all and are governed solely by the token-based limit. Where an RPM quota does apply, output tokens count against it through a model-specific "burndown rate" rather than a flat one-token-one-unit count.

Two endpoints, two separate quota pools

As of a change AWS documented in 2026, Bedrock added a second inference endpoint, bedrock-mantle, which serves the OpenAI Responses API, OpenAI Chat Completions API, and the Anthropic Messages API directly — letting existing OpenAI- or Anthropic-shaped application code run on Bedrock with minimal changes. Traffic to bedrock-mantle is governed by its own separate quotas from bedrock-runtime: rather than one combined TPM number, it applies distinct input-tokens-per-minute and output-tokens-per-minute quotas, has no RPM quota at all, and — notably for anyone leaning on prompt caching to cut costs — cached input tokens read through prompt caching don't count against its input-tokens-per-minute quota. If you're running workloads against both endpoints, AWS's own guidance is to plan capacity for each independently; hitting the limit on one endpoint says nothing about your headroom on the other.

Watching your usage before it throttles you

AWS documents four CloudWatch metrics specifically useful for tracking whether you're approaching a Bedrock quota: Invocations, InvocationThrottles, InputTokenCount, and OutputTokenCount. Watching InvocationThrottles climb is the earliest warning sign that your traffic has outgrown your current quota, before your users start seeing errors. Quotas themselves are viewable and adjustable in the Service Quotas console under Amazon Bedrock, searchable by model name — something like "Tokens per minute for Anthropic Claude 3.5 Sonnet v2" — and AWS's documentation notes that quota increase requests get priority when your existing traffic is already consuming close to your current allocation; a request for headroom you're nowhere near using is more likely to be denied.

The costs nobody warns you about

Token pricing is the headline number, but a working Bedrock application usually carries a handful of adjacent charges that don't show up until the bill does. Here's what AWS actually publishes for each.

Guardrails

Bedrock Guardrails charges per "text unit," where one text unit covers up to 1,000 characters — a 5,600-character input gets billed as 6 text units. Content filters and denied-topic filters both run $0.15 per 1,000 text units; sensitive information filters run $0.10 per 1,000; contextual grounding checks run $0.10 per 1,000; Automated Reasoning checks run $0.17 per 1,000 per policy applied. Word filters and regular-expression-based sensitive information filters are free. A separate table applies for the InvokeGuardrailChecks API, where content filters drop to $0.07 per 1,000, prompt attack detection runs $0.08 per 1,000, and sensitive information filters stay at $0.10 per 1,000. AWS's own worked examples: a customer support chatbot serving 1,000 queries an hour, each with a 200-character query and a 1,500-character response, using both content filters and denied topics, comes to 3,000 text units an hour and $0.90 an hour combined. A call-center transcript summarizer redacting PII across 10,000 conversations, each averaging 3,500 characters, comes to $4 total. A healthcare Automated Reasoning check processing 5,000 patient cases a month, each contributing 8 text units of patient data, diagnosis, and treatment recommendation, comes to $6.80 a month.

Knowledge Bases

Amazon Bedrock's Managed Knowledge Base charges $5.00 per GB of raw indexed data per month for storage, with document parsing, embeddings generation using the built-in model, and re-ranking with the managed reranker all included at no extra charge. Standard Retrieval costs $1.00 per 1,000 API calls. Agentic Retrieval, which uses an LLM for multi-hop query planning, costs $4.00 per 1,000 Agentic Retrieve calls plus $1.00 per 1,000 underlying Retrieve calls each agentic call triggers. AWS's own example: indexing 50GB of SharePoint content and handling 100,000 standard retrieval queries a month comes to $250 in storage plus $100 in retrieval, for a $350 monthly total. Swap the same 50GB to 100,000 Agentic Retrieve calls, averaging 2 underlying calls each, and the same setup jumps to $850 a month — $250 storage, $400 for the agentic calls, and $200 for the underlying calls they trigger.

Intelligent Prompt Routing and Prompt Optimization

Intelligent Prompt Routing costs $1 per 1,000 requests, and works by automatically routing each prompt between two models in the same family — Claude 3.5 Sonnet and Claude 3 Haiku, Meta Llama 3.3 70B and 3.1 8B, or Nova Pro and Nova Lite — based on how complex the prompt is, with AWS stating it can reduce costs by up to 30% without compromising accuracy. Prompt Optimization has two tiers: the Simple Prompt Optimizer, available with one click in the Bedrock playground, charges $0.03 per 1,000 tokens across both your original prompt and the optimized result. AWS's worked example: optimizing a 429-token news-summarization prompt into a 511-token version, then generating two further model-specific variants at 582 and 579 tokens, totals 3,123 tokens across the whole job — a bill of $0.09. The Advanced Prompt Optimizer bills at on-demand standard-tier token rates for whichever model is being optimized, currently using Claude Sonnet 4.6 as the optimizer LLM itself in AWS's documented cost formulas.

Nova Act, for teams building agents

If your Bedrock project involves Amazon's Nova Act browser-automation agent rather than plain chat completion, the billing shape changes entirely: Nova Act workflows are priced at $4.75 per agent hour, where an "agent hour" is the real-world elapsed time the agent spends working, not compute time or token count. Amazon's own Nova pricing page specifies that if multiple agents run in parallel, each one generates its own separate bill, and that time spent waiting for a human to respond, when you've implemented Human-in-the-Loop review, is excluded from the billed agent hour. This is a genuinely different pricing shape from everything else on this page — worth knowing before you assume every Bedrock-adjacent product bills per token.

Why your bill doesn't match your estimate

Three things throw off a hand-built estimate more than anything else, and each one is visible directly on AWS's own tables and documentation once you know to look.

The first is Region. NVIDIA's Nemotron Nano 2 model, for example, prices at $0.06 per million input tokens and $0.23 per million output tokens in US East (N. Virginia), US East (Ohio), and US West (Oregon) — but the identical model in Europe (London) prices at $0.09 and $0.36, and in AWS GovCloud runs $0.072 and $0.276. Google's Gemma models show the same pattern: Gemma 3 4B costs $0.04 per million input tokens in US Regions, $0.05 in Frankfurt, and $0.06 in London. If your estimate used a US price and your traffic actually lands in a European Region, your real bill runs meaningfully higher for the exact same token count.

The second is which service tier your requests are actually landing on. If your application code sets "service_tier": "priority", or if a default configuration you inherited did, you're paying 75% more per token than the Standard-tier estimate you built your budget around — and unlike a Region mismatch, that setting is invisible unless someone reads the request parameters.

The third, covered in the quotas section above, is retry behavior under load. An estimate built purely from expected traffic volume assumes every request succeeds on the first try. In practice, a spike that trips your TPM quota generates throttling errors, and depending on how your application handles them, some of those requests get retried — sometimes with the full conversation history re-sent each time. The token count that actually gets billed can run higher than the token count your traffic-volume math predicted, purely from retry overhead that never shows up in a simple requests-per-day estimate.

Third-party pricing calculators: what they get right and wrong

A search for Bedrock pricing turns up dozens of third-party calculators and comparison sites that will happily plug your token counts into a table and spit out a dollar figure. They're useful for one thing and risky for another. They're genuinely convenient for side-by-side comparison across many models at once — seeing DeepSeek, Llama, and Mistral rates lined up in one table saves you clicking through a dozen accordion tabs on AWS's own page. What they're not reliable for is the number itself on any given day: several of these sites explicitly note that their figures are collected periodically rather than pulled live, and Bedrock's per-model, per-Region rates change often enough that a cached snapshot from even a few weeks ago can be stale by the time you read it.

How to actually estimate a Bedrock bill before you build anything

Ethan's approach with Jake, walked through step by step:

1. Pick the exact model ID and Region you plan to call, not a family name — "Claude" isn't a price, "claude-sonnet-4-6 in us-east-1" is.
2. Send five to ten real prompts through the model in the console and record the actual input and output token counts the response returns — don't guess your average prompt length.
3. Multiply your averages against the model's current input and output rates using the formula from the top of this post, for a single-request cost.
4. Multiply that single-request cost by your expected daily volume, then by 30 for a monthly figure.
5. Add Guardrails, Knowledge Base retrieval, and any Prompt Routing charges separately — these are billed independently of the model call itself and won't show up if you only price the token call.
6. Check your quota against your expected peak, not your expected average — a traffic spike that trips throttling adds retry overhead your average-volume math won't have accounted for.
7. Re-check the number monthly, not once. Region-specific and model-specific prices on Bedrock's tables move; an estimate from six months ago is a guess, not a fact.

Comparison table: current on-demand rates across the lineup

All figures below are Standard-tier, on-demand, US East/US West Regions unless noted, straight from Bedrock's current pricing tables:

*Qwen3 235B and OpenAI gpt-oss-20b figures shown are the published Asia Pacific (Sydney) Region rates from Bedrock's current tables; check the live pricing page for your own Region before budgeting.

Frequently asked questions

How does Amazon Bedrock charge for tokens?

Most Bedrock models charge separately for input tokens (what you send) and output tokens (what the model generates), at a rate per million tokens that's set by the model's provider, per AWS Region. You add the two costs together for a total per-request price.

What counts as an input token versus an output token?

Input tokens are your prompt, system instructions, conversation history you re-send, and any attached documents. Output tokens are the model's generated response, including any extended reasoning content on models that support it.

Is there a free tier for Amazon Bedrock?

Bedrock does not have a permanent free tier for model inference — every invocation is billed from the first call at the rate the model and Region carry.

What's the difference between On-Demand, Batch, and Provisioned Throughput?

On-Demand bills per token with no commitment. Batch bills the same per-token rate at a 50% discount for select models, but processes prompts asynchronously rather than instantly. Provisioned Throughput bills a flat hourly rate per model unit for a committed one- or six-month term, regardless of actual usage.

What are Bedrock's Standard, Priority, Flex, and Reserved tiers?

Standard is the default pay-per-token tier. Priority costs 75% more than Standard for guaranteed faster response times. Flex costs 50% less than Standard for workloads that can tolerate higher latency. Reserved provides dedicated capacity under a term commitment, generally priced through a direct conversation with your AWS account team.

Why is Claude missing from my "Amazon Bedrock" line item in Cost Explorer?

Current-generation Claude models (Sonnet 4.6, Haiku 4.5, and others) are documented by AWS as third-party models billed through AWS Marketplace. Their charges appear under the model provider's name in your bill and in Cost Explorer, not grouped under a generic "Amazon Bedrock" line.

Does prompt caching actually save money on Bedrock?

Where it's supported, yes. Claude 3.5 Sonnet v2 on Bedrock, for example, charges $7.50 per million tokens to write to cache but only $0.60 per million tokens to read from it — a fraction of the standard $6.00 input rate — once the cached content is reused. On the newer bedrock-mantle endpoint, cached input tokens don't count against your input-tokens-per-minute quota either, which is a second benefit beyond the price cut.

How much does Batch inference save compared to On-Demand?

AWS states the Batch discount as a flat 50% off the On-Demand rate for supported models from Anthropic, Meta, Mistral AI, and Amazon, and several newer model tables (DeepSeek, OpenAI's gpt-oss, Qwen) publish the same 50% figure directly in their own pricing tables.

What is a model unit, and how is Provisioned Throughput priced?

A model unit is a fixed slice of dedicated capacity you commit to for one or six months, billed at an hourly rate regardless of how much you actually use it. AWS's examples show hourly rates ranging from roughly $16 to $50 per unit depending on the model, multiplied out across a full month of 24-hour days.

Do embedding models charge for output tokens?

No. AWS's own Cohere embedding example bills only the input side — 10,000 input tokens at $0.0001 per thousand, with no output charge at all, since embedding models return a vector, not generated text.

What happens to my bill if I get throttled and have to retry a request?

A request AWS rejects outright for exceeding your quota doesn't process tokens, so there's nothing billed for that specific attempt. The real cost risk is retry design: if your application re-sends growing conversation history on every retry attempt, only the attempt that finally succeeds gets billed, but you're paying for a larger input than a single clean request would have needed.

What's the difference between the bedrock-runtime and bedrock-mantle endpoints?

bedrock-runtime is Bedrock's primary inference endpoint and counts input and output tokens together against one combined per-model TPM quota. bedrock-mantle, which serves OpenAI- and Anthropic-shaped API calls directly, applies separate input-tokens-per-minute and output-tokens-per-minute quotas instead, has no RPM quota, and is tracked independently from bedrock-runtime for capacity planning.

How is Amazon Bedrock Guardrails priced?

Guardrails charges per text unit of up to 1,000 characters. Content filters and denied topics cost $0.15 per 1,000 text units, sensitive information filters cost $0.10 per 1,000, and Automated Reasoning checks cost $0.17 per 1,000 per policy. Word filters and regex-based sensitive information filters are free.

What does Amazon Bedrock Knowledge Bases cost?

Managed Knowledge Base charges $5.00 per GB of indexed data per month for storage, with parsing, embeddings, and re-ranking included free. Standard Retrieval costs $1.00 per 1,000 API calls; Agentic Retrieval costs $4.00 per 1,000 agentic calls plus $1.00 per 1,000 underlying retrieval calls.

Is Custom Model Import free?

Importing the model is free. You pay only once you invoke it, billed per Custom Model Unit per minute in 5-minute windows, plus a monthly storage charge per unit. Billing stops after 5 minutes with no invocations.

Does the AWS Region I pick change my token price?

Yes, substantially in some cases. NVIDIA's Nemotron Nano 2 model, for example, costs $0.06/$0.23 per million tokens in US East and US West Regions but $0.09/$0.36 in Europe (London) for the identical model — a 50% jump for choosing a different Region.

Honestly AWS Quick is one of the best one that is going to be in future, so give it a try..

Incase, if you want to check how to run all the famous AI model like google's Gemini (Gemma), Alibaba's Qwen (one of the best), Deepseek, IBM's Granite, Ornith we had created a playlist for it. You can check it here. Stay tuned..

Revision note. Written September 2026, covering the on-demand, Batch, Provisioned Throughput, Custom Model Import, quota, Guardrails, and Knowledge Base pricing published on Amazon Bedrock's pricing page and documentation at that time, across providers. But, (i repeat but because) Bedrock adds new models, endpoints, and quota structures often enough that a table like this one is a snapshot, not a promise — always confirm the live number for your exact model and Region before you commit real budget to it. If a surprise line item, a mysterious throttling error, or a missing "Bedrock" charge sent you here in the first place, you're not the first person a token bill has caught off guard, and the formula and quota mechanics above should get you to the bottom of it. Use this bit with caution, as always because you might need to sell everything like organs like brain, kidney to repay😂 if you didn't pay attention !