Guille Ojeda
Caylent Catalysts™
Generative AI Strategy
Accelerate your generative AI initiatives with ideation sessions for use case prioritization, foundation model selection, and an assessment of your data landscape and organizational readiness.
Explore Amazon Bedrock's intricate pricing, covering on-demand usage, provisioned throughput, fine-tuning, and custom model hosting to help leaders forecast and optimize costs.
Conversations about Amazon Bedrock often emphasize how quickly you can integrate generative AI into your applications. Yet behind the convenience lies a pricing structure that can surprise companies that jump in without a thorough understanding. A single user request can now trigger several model calls, a knowledge-base lookup, a reranking step, Guardrails checks, tool calls, memory operations, and compute inside Amazon Bedrock AgentCore. Looking only at the model's input-token price is a reliable way to underestimate the result.
That is where a more complete understanding of Amazon Bedrock pricing helps. The service now spans four inference tiers, batch inference, cross-Region inference profiles, prompt caching, managed retrieval, model customization, media generation, evaluation, and a modular agent platform. Each component has its own billing unit, and not every model supports every option.
In this blog, we will walk through the major pricing surfaces using current models and real calculations. Rather than treating a price per million tokens as the whole story, we'll show how the different charges stack up in practice.
Representative prices in this article are in US dollars and were checked against AWS's published pricing on July 21, 2026. Model availability, Regions, service tiers, and rates change frequently, so confirm the live table for your source Region before making a purchasing commitment.
High-Level Overview of Amazon Bedrock Pricing Components
The most useful way to think about Amazon Bedrock pricing is as a stack:
Total cost = model inference + cache writes and reads + retrieval and reranking + safeguards and orchestration + AgentCore resources and tools + storage, network, and observability
The model-inference layer itself has more choices than it used to. Amazon Bedrock service tiers let you select a different cost, latency, and capacity posture for each supported workload.
Reserved capacity currently targets 99.5% model-response availability and starts at 100,000 input tokens per minute and 10,000 output tokens per minute. Standard, Priority, and Flex share the model's on-demand quota, while Reserved has its own capacity pool. This distinction matters when you are sizing for a peak rather than an average.
Priority and Flex pricing is model-specific. Many current tables show Priority at a 75% premium and Flex at a 50% discount, but you should never apply those percentages to a model until its model card and pricing table confirm support. The same rule applies to Batch and Reserved.
Selected model and Region combinations may also publish a separate latency-optimized inference option. Treat that as a model-specific premium path rather than another universal tier, and do not assume it has the same availability or price as Priority.
On-Demand Usage: Text, Embeddings, Images, Video, and Audio
On-demand pricing remains the natural starting point for prototypes and traffic that is difficult to predict. You pay for what the model processes without reserving capacity. The catch is that “what the model processes” is broader than the user's visible prompt and answer.
Text and Multimodal Models
Text-generation models generally bill input and output tokens at different rates. Output is often the expensive side, and supported reasoning models bill reasoning tokens as output even when the model returns only a shorter summary of its reasoning. Tool-using applications can also make several model turns for one user request, replaying conversation history and tool results on each turn.
Here are representative Standard on-demand rates from the current US East pricing table:
OpenAI's frontier models are available through the Bedrock Mantle endpoint and the Responses API. That is a meaningful implementation detail: you use the OpenAI SDK-compatible endpoint rather than assuming that every Bedrock feature exposed through bedrock-runtime and Converse is available. The current GPT-5.6 model cards list Standard in-Region inference, server-side tools, Projects, and prompt caching; they do not yet list geographic or global inference profiles.
The gpt-oss models use the usual Bedrock Runtime and Mantle paths and support Priority, Flex, and Batch where listed. Current US Flex and Batch rates are half of Standard, while Priority is 75% higher. OpenAI gpt-oss Safeguard variants are also available for model-based safety classification. Their representative US rates are $0.07 per million input and $0.20 per million output tokens for 20b, and $0.15 and $0.60 for 120b.
For Anthropic workloads, Claude Opus 4.8 is the current Opus option for deep reasoning, coding, and complex agents, with a one-million-token context window. Its current commercial Global profile is $5 per million input tokens and $25 per million output tokens; geographic and in-Region inference are $5.50 and $27.50.
Claude Sonnet 5 is the balanced production option and supports both geographic and global cross-Region profiles through bedrock-runtime. AWS is offering Global Sonnet 5 launch pricing of $2 per million input tokens and $10 per million output tokens through August 31, 2026, while current geographic and in-Region pricing is $2.20 and $11. The published Global price becomes $3 and $15 afterward. This is exactly the kind of time-limited rate that should be explicit in a forecast.
The safest forecasting workflow is to measure actual request payloads with the model's tokenizer. The CountTokens API is free for supported models and returns model-specific token counts. Add reasoning tokens, repeated history, tool definitions, tool results, and retries to the estimate; do not budget from the text visible in the UI alone.
Embeddings and Reranking
Embedding models charge for input because their output is a vector rather than generated text.
Amazon Titan Text Embeddings V2 costs $0.02 per million input tokens in supported US Regions and can produce 256-, 512-, or 1,024-dimensional vectors. Using lower-dimensional vectors may lose some of the nuance in the data and often result in less precision, but it reduces the cost of the vector store and of calculating the embeddings, which may drive significant savings at scale.
For multimodal retrieval, Cohere Embed v4 accepts text, images, and mixed documents for $0.12 per million input tokens. It supports US and EU geographic profiles as well as Global inference.
TwelveLabs Marengo Embed 3.0 is purpose-built for multimodal retrieval: video is $0.00070 per second, audio is $0.00014 per second, image is $0.00010 per request, and text is $0.00007 per request.
Reranking is a separate operation. Amazon Rerank is $1 per 1,000 queries, while Cohere Rerank 3.5 is $2 per 1,000. A query can include up to 100 document chunks; additional or oversized chunks can turn one logical search into multiple billable queries. If you use a fully managed Knowledge Base, managed embedding and reranking are included in that service's price. If you assemble retrieval yourself, these remain separate line items.
Image and Video Generation
Media models use different units from text models. Stable Image Ultra v1.1 is designed for premium photorealistic generation and is priced per generated image, currently $0.14 per generation in US West (Oregon). It is an in-Region model and does not currently have a cross-Region profile.
Stability AI's editing services are priced per operation: for example, object removal and inpainting are $0.07 per generation, style transfer is $0.08, and upscaling ranges from $0.03 to $0.60 depending on the method.
For video generation, Luma Ray2 runs asynchronously in US West (Oregon) and writes its output to Amazon S3. It supports five- and nine-second clips at 540p or 720p. The current rates are $0.75 per generated second at 540p and $1.50 per second at 720p. A nine-second 720p clip is therefore $13.50 before S3 storage, requests, or data transfer. Ray2 does not currently have a cross-Region profile.
Video understanding is priced differently from video creation. TwelveLabs Pegasus 1.2 charges $0.00049 per input video second plus $0.0075 per 1,000 output tokens. A ten-second clip that produces 2,000 output tokens costs:
- Video input:
10 * $0.00049 = $0.0049 - Model output:
2 * $0.0075 = $0.0150 - Total:
$0.0199
These two video use cases may look similar in a product diagram, but their billing units and costs are completely different.
Audio Understanding
For transcription and audio understanding, Mistral AI's current Bedrock options are Voxtral Small 24B 2507 and Voxtral Mini 3B 2507, labeled Voxtral Small 1.0 and Mini 1.0 in the pricing table. Small is listed at $0.10 per million input tokens and $0.30 per million text output tokens in US East and US West, while Mini is $0.04 for both input and text output.
These models understand speech and return text, but they are not speech-generation models. As with every multimodal model, confirm what the response reports as billable tokens rather than converting audio duration to tokens with a generic rule.
Prompt Caching
Prompt caching reduces latency and the cost of repeatedly processing a stable prefix such as a system prompt, tool catalog, long document, or policy manual. A correct estimate needs four token buckets:
Uncached input + cache-write input + cache-read input + output, including reasoning
Cache writes may cost more than ordinary input, however, Cache reads are discounted. Minimum prefix size, time to live, checkpoint count, and eligible fields depend on the model. Caching is available for supported on-demand inference, including supported cross-Region requests, but it is not available through the Batch inference API.
GPT-5.6 models illustrate the economics well. They support explicit breakpoints for prefixes of at least 1,024 tokens, up to four checkpoints, and a 30-minute time-to-live. A write costs 1.25 times normal input; a read receives a 90% discount. Cached reads also do not consume the input-tokens-per-minute quota.
Suppose an application sends the same 20,000-token instruction and tool prefix to GPT-5.6 Terra 100 times within the cache window. Excluding output, which is identical in both cases, the uncached price is:
2,000,000 input tokens * $2.75 / 1M = $5.50
With caching, one write and 99 reads cost:
- Cache write:
20,000 * $3.44 / 1M = $0.0688 - Cache reads:
1,980,000 * $0.28 / 1M = $0.5544 - Total cached input cost:
$0.6232
That is an 88.7% reduction in the repeated-prefix cost. It only works if the prefix is stable and reused before expiration. A cache write that receives no subsequent hits is more expensive than ordinary input, so track cache-write and cache-read tokens separately.
Cross-Region routing adds one more wrinkle: a request may be served in a different destination Region, which can cause additional cache writes. Caching and cross-Region inference can still work together, but the cache-hit rate belongs in your load test, not in an assumption.
Batch Inference
Batch inference is for independent, asynchronous records stored as JSON Lines in Amazon S3. Select models receive a 50% discount from Standard on-demand pricing. Batch is a strong fit for nightly summarization, classification, dataset labeling, and offline evaluation.
Take Qwen3 Next 80B A3B at its representative US Standard rate of $0.15 per million input tokens and $1.20 per million output tokens. At the supported 50% Batch discount, processing 150 million input tokens and producing 5 million output tokens costs:
- Input:
150 * $0.075 = $11.25 - Output:
5 * $0.60 = $3.00 - Total:
$14.25 per batch
The trade-off is capability and latency. Bedrock Batch does not support tool calling, structured output, multi-turn conversations, or Provisioned Throughput. We do not recommend moving an agent loop to Batch simply because its token price is lower; it is a different execution model with responses taking from tens of minutes up to 24 hours, not suitable for real-time processing.
Cross-Region Inference Profiles
Cross-Region inference lets supported models use capacity outside the source Region without application-level failover logic. There are two profile types:
- Geographic profiles route within a defined geography such as the US or EU. They are intended for workloads with data-residency boundaries and use the relevant Standard pricing.
- Global profiles can route across supported commercial Regions for the highest available throughput. AWS currently advertises approximately 10% lower pricing for supported models when geographic residency is not required.
There is no additional Bedrock routing fee. The source Region determines the price, even if another Region processes the request. Data stays on the AWS network and is encrypted in transit. However, your AWS IAM policies and service control policies must allow all possible destinations in the profile; global profiles require the documented aws:RequestedRegion handling.
Claude Sonnet 5 is a useful current example because its model card publishes both us.anthropic.claude-sonnet-5 and global.anthropic.claude-sonnet-5 inference profile IDs. Claude Opus 4.8 also supports Global plus US, EU, Japan, and Australia geographic profiles.
By contrast, the GPT-5.6 cards currently list in-Region endpoints only, and AWS says global pricing is coming later. A financial model should therefore apply a global discount only after the exact model card and price table support it.
Inference profiles work with supported on-demand inference. Some Bedrock features, including particular Batch, evaluation, Prompt Management, and Flow configurations, can also invoke a supported profile under their own model and Region matrices. Profiles do not work with Provisioned Throughput.
You can also create application inference profiles to tag and attribute usage by product, environment, or tenant, an important distinction from the system-defined profiles that perform cross-Region routing.
Reserved Capacity and Provisioned Throughput
Reserved and Provisioned Throughput both make cost more predictable, but they are not interchangeable.
Reserved is the current token-capacity option. You reserve input and output tokens per minute for one or three months, pay a fixed monthly amount, and overflow above that reservation to Standard. It is designed for high-importance traffic with predictable throughput requirements. Cache-write input counts when AWS sizes the reserved input capacity, so add InputTokenCount and CacheWriteInputTokens rather than looking at ordinary input alone.
Provisioned Throughput remains a model-specific dedicated-capacity option. Depending on the model, it may use model units or token-based capacity and offer no-commitment, one-month, or six-month terms. You pay for the capacity while it exists, whether it is fully utilized or not.
Current pricing for many models requires a quote from the AWS account team, which makes a load test and measured utilization more useful than an outdated public hourly example.
The rule of thumb is:
- Use on-demand tiers while traffic is uncertain.
- Consider Reserved when token demand and service requirements become predictable.
- Use Provisioned Throughput when the model and deployment requirement specifically call for it.
Do not assume that every customized model requires Provisioned Throughput, supported custom models can now be deployed for on-demand inference.
Model Customization, Distillation, and Custom Model Import
Amazon Bedrock supports several customization paths: supervised fine-tuning, continued pretraining, reinforcement fine-tuning, and distillation. The bill can include training, teacher-model inference, custom-model storage, evaluation, and the eventual inference deployment.
For a current concrete example, reinforcement fine-tuning of OpenAI gpt-oss-20b costs $80 per training hour. The resulting model is priced at $0.09 per million input tokens and $0.39 per million output tokens for on-demand inference, plus $1.95 per stored model per month.
If a five-hour training run produces a model that handles 500 million input tokens and 100 million output tokens in its first month, the direct cost is:
- Training:
5 * $80 = $400 - Input inference:
500 * $0.09 = $45 - Output inference:
100 * $0.39 = $39 - Storage:
$1.95 - Total:
$485.95
This excludes dataset preparation, evaluation, and any Lambda function or model used as a reward function. Reinforcement fine-tuning should be justified by a measured quality improvement, not by the training price alone.
Distillation creates a smaller student model using responses from a more capable teacher. Its business case depends on the full lifecycle: teacher tokens plus training and storage, divided by the per-request savings of the student model. Model pair support changes over time, so evaluate the live compatibility matrix and calculate the break-even volume before starting a recurring pipeline.
Custom Model Import
Custom Model Import lets you bring supported model weights into Bedrock. Import itself has no fee. Inference is priced by Custom Model Units (CMUs), number of active copies, and billable minutes; storage is priced per CMU per month.
The correct formula is:
Active copies * CMUs per copy * price per CMU-minute * billable minutes
The current US rate for CMU version 1 is $0.05718 per CMU-minute. OpenAI-compatible imports use CMU version 2 at $0.1433 per CMU-minute. Storage is $1.95 per CMU per month. Usage is metered in five-minute windows, and an idle model can scale to zero after five minutes.
Suppose an imported model requires two CMUs, averages one active copy, and receives traffic for six billable hours per day over 30 days. Its version 1 inference cost is:
1 copy * 2 CMUs * $0.05718 * 60 * 6 * 30 = $1,235.09
Storage adds 2 * $1.95 = $3.90, bringing the direct monthly total to $1,238.99. Concurrency can create more active copies, while scale-to-zero can reduce quiet-period cost. The trade-off is a cold start after inactivity, so include both concurrency and latency requirements in the estimate.
Bedrock Marketplace is a different path again. A Marketplace model can include a provider software subscription plus the SageMaker endpoint and instance infrastructure that hosts it. Treating it as ordinary serverless token pricing will produce the wrong forecast.
Pricing the Bedrock Features Around the Model
Model inference is often only one part of a production architecture. The following services can each add charges to the same user journey.
Amazon Bedrock AgentCore
Amazon Bedrock AgentCore is a modular platform for deploying and operating agents. You can use each capability independently, but an end-to-end agent will often combine several of them.
AgentCore Runtime bills actual active CPU consumption and peak memory used in each second, with a one-second minimum. If an agent waits for a model or API and no background work consumes CPU, that CPU wait is not billed. Memory, storage, network transfer, and system overhead still need to be considered. Browser and Code Interpreter use the same active-resource rates.
AgentCore also includes the AWS Agent Registry and Payments capabilities in preview. Registry has monthly free allowances followed by per-record and per-API pricing. Payments passes through the selected wallet provider's operation fees. Preview pricing can change before general availability, so it belongs in a separate forecast assumption rather than a permanent zero-cost line.
The biggest AgentCore budgeting mistake is to equate one user request with one model call. A request can involve multiple reasoning turns, a knowledge lookup, several Gateway calls, web search, memory writes and reads, policy checks, Runtime resources, and CloudWatch telemetry. Price the trajectory, not just the final answer.
APIs, Tools, and Structured Output
Bedrock Runtime provides model-native invocation and the Converse APIs, while Bedrock Mantle exposes provider-compatible interfaces such as the OpenAI Responses API and Anthropic Messages API. There is no generic API-access surcharge on top of the applicable model and feature prices, but endpoint choice changes which Bedrock capabilities are available.
Check the current model card before assuming that Guardrails, Knowledge Bases, CountTokens, prompt caching, cross-Region profiles, or a particular service tier works through a provider-compatible endpoint.
Tool use, structured output, response streaming, and computer use do not erase normal token charges. Tool definitions and schemas become input, tool arguments and reasoning become output, and the result may be sent back to the model in another turn.
A computer-use workflow can also add AgentCore Browser resources, screenshots or image input, Gateway calls, and downstream API charges to your cost calculations. If the selected provider publishes a separate server-side tool fee, add that as well to the cost calculations.
Knowledge Bases and Retrieval
Amazon Bedrock Managed Knowledge Base bundles ingestion, multimodal parsing, embeddings, vector storage, and reranking. Current pricing is $5 per GB of raw indexed data per month and $1 per 1,000 Standard Retrieve calls. Managed parsing, embedding generation, and reranking are included.
Agentic Retrieve adds a $4 planning charge per 1,000 calls plus $1 per 1,000 underlying Retrieve calls. If 100,000 agentic requests make two underlying retrievals each, the retrieval portion is $400 + $200 = $600, before storage and model inference.
Using the Standard path, 50 GB of indexed data and 100,000 retrievals per month costs:
- Index storage:
50 * $5 = $250 - Retrieval:
100,000 / 1,000 * $1 = $100 - Total:
$350 per month
If you use a self-managed knowledge base, replace that bundled line with the real cost of the vector database, parser, embeddings, reranking, storage, and compute. That way your cost ledger will include all the adjacent costs that result from your knowledge base. Also remember that Guardrails applied to a knowledge-base request protect the query and generated answer, not the contents of retrieved source references.
Knowledge Bases can also retrieve from structured data by generating SQL. That path is billed per SQL-generation request, while the underlying Redshift or other data-service usage remains billable. Its geographic cross-Region routing has no extra routing charge and should not be forecast as an ordinary vector Retrieve call.
Guardrails
Amazon Bedrock Guardrails charges each selected safeguard independently. A text unit is up to 1,000 characters. Current rates include:
- Content filters: $0.15 per 1,000 text units, or $0.00075 per image
- Denied topics: $0.15 per 1,000 text units
- Sensitive-information filters: $0.10 per 1,000 text units
- Contextual grounding: $0.10 per 1,000 text units
- Automated Reasoning: $0.17 per 1,000 text units per policy
- Word and regex filters: no additional charge
When safeguards are called separately through InvokeGuardrailChecks, the current rates differ: text content checks are $0.07 per 1,000 text units, prompt-attack checks are $0.08, and sensitive-information checks are $0.10. Use the price for the actual API path rather than assuming every Guardrails invocation has the same rate.
Suppose 300,000 monthly conversations each send one 200-character user message and receive one 1,500-character response. That is three text units per conversation, or 900,000 units. Applying both a content filter and a sensitive-information filter costs:
900,000 / 1,000 * ($0.15 + $0.10) = $225 per month
For every safeguard that you add to your system, you're adding to your cost ledger another independently metered line.
Data Automation, Flows, Prompt Tools, and Evaluation
Several other Bedrock capabilities are easy to miss because their prices are not part of the selected model's token table:
These features can save engineering time and improve quality, but they should be modeled explicitly. A Flow node that calls a model, queries a knowledge base, invokes a Lambda function, and checks a Guardrail creates several charges even though the Flow transition itself costs a fraction of a cent.
A Complete Bedrock Pricing Example
To see how the pieces stack up, imagine a fictional company called Skyline Analytics. Skyline runs a support and research assistant in US East, produces marketing images, and summarizes customer conversations overnight. It handles 300,000 agent sessions per month.
1. Interactive Model Inference
The AgentCore application makes two GPT-5.6 Terra model calls per session. Each call averages 300 input tokens and 200 output tokens.
- Monthly input:
300,000 * 2 * 300 = 180M tokens - Monthly output:
300,000 * 2 * 200 = 120M tokens - Input cost:
180 * $2.75 = $495 - Output cost:
120 * $16.50 = $1,980 - Total interactive inference:
$2,475
This deliberately uses the in-Region price. GPT-5.6 Terra does not currently publish a cross-Region inference profile, so Skyline does not subtract a global-profile discount that is not available. If it changes models later, the team will reprice the exact geographic or global profile from the source Region.
2. Nightly Batch Summaries
Each night, Qwen3 Next 80B A3B processes 150 million input tokens and produces 5 million output tokens through Batch:
- Per-night cost:
$14.25 - Monthly cost:
30 * $14.25 = $427.50
3. Image Generation
Skyline creates 10,000 marketing images with Stable Image Ultra v1.1:
10,000 * $0.14 = $1,400 per month
4. Managed Knowledge Base
The assistant indexes 50 GB of documents and makes 100,000 Standard Retrieve calls:
$250 storage + $100 retrieval = $350 per month
5. AgentCore Runtime and Tools
Each session lasts 60 seconds and uses one vCPU for 18 active seconds. Memory starts at 1 GB for ten seconds, grows to 2 GB for 20 seconds, and reaches 2.5 GB for the final 30 seconds.
- CPU:
300,000 * 18 / 3,600 * $0.0895 = $134.25 - Memory:
300,000 * (10×1 + 20×2 + 30×2.5) / 3,600 * $0.00945 = $98.44 - Runtime total:
$232.69
The agent averages two Gateway tool invocations per session, for 600,000 calls:
600,000 / 1,000 * $0.005 = $3
Ten percent of sessions use one Web Search query:
30,000 / 1,000 * $7 = $210
Four short-term memory events are stored per session:
1,200,000 / 1,000 * $0.25 = $300
6. Guardrails
The content and sensitive-information filters process 900,000 text units:
900,000 / 1,000 * ($0.15 + $0.10) = $225
Monthly Total
That total still excludes Amazon S3 or Amazon ECR storage, Amazon CloudWatch telemetry, network transfer, taxes, retries, failed application-level work, and any supporting AWS services. It also assumes the stated average token counts hold in production.
The example is useful because it shows where intuition fails: the inexpensive Gateway calls are not the issue, while model output and premium image generation dominate the bill.
Strategies for Cost Optimization
The most effective cost controls are architectural rather than cosmetic.
- Choose models by evaluated task, not reputation. Route classification, extraction, and straightforward generation to an efficient model after testing quality on your own data. Reserve frontier models such as GPT-5.6 Sol or Claude Opus 4.8 for work that benefits from their additional reasoning capability.
- Control output and reasoning budgets. Output tokens often cost several times more than input. Set realistic output limits, remove unnecessary verbosity, and tune reasoning effort where the model supports it.
- Match the inference option to the workload. Use Standard for normal synchronous traffic, Priority only where latency has business value, Flex for delay-tolerant requests, and Batch for independent offline records. Consider Reserved or Provisioned Throughput only after measuring steady demand.
- Cache stable prefixes and track the break-even point. Place tool definitions, instructions, and reference documents before the cache breakpoint. Compare cache writes with subsequent reads; a cache with no hits is a surcharge.
- Use cross-Region inference deliberately. Geographic profiles improve available throughput while preserving a defined residency boundary. Global profiles can add throughput and approximately 10% savings for supported models, but only when compliance permits and the exact model supports them.
- Budget complete agent trajectories. Record the number of model turns, retrievals, tool calls, memory operations, policy checks, and active compute per task. AgentCore's per-unit rates are predictable; uncontrolled iteration counts are not.
- Keep retrieval lean. Tune chunk size, top-k, and reranking so that you do not pay for irrelevant context twice. Do it once during retrieval and again when those chunks become model input.
- Evaluate customization against a baseline. Fine-tuning, reinforcement fine-tuning, and distillation should improve a measured business metric enough to repay training, evaluation, storage, and operational complexity.
- Create cost boundaries in the architecture. Use application inference profiles, Projects or Workspaces, IAM principals, and request metadata to attribute cost by application, environment, team, or tenant. The Bedrock cost-management guidance explains how these layers complement Cost and Usage Reports and invocation logs.
Common Mistakes and Pitfalls
Across Amazon Bedrock deployments, a few patterns repeatedly cause budget surprises:
- Counting user requests instead of model turns. An agent can invoke the model several times and replay a growing context on each turn.
- Assuming every model supports every tier or profile. Standard, Priority, Flex, Reserved, Batch, caching, and cross-Region inference all have model-specific support matrices.
- Applying a global discount to an unsupported endpoint. Cross-Region inference is free to route, but the profile must exist for the exact model and source Region.
- Ignoring cache writes. Reads can be dramatically cheaper, but a changed prefix or cross-Region cache miss can create another premium-priced write.
- Confusing quotas with billing. Some models apply token-burndown multipliers to quota consumption. The bill still uses actual metered tokens; quota math and cost math are related but not identical.
- Treating a Marketplace endpoint like serverless token inference. Provider software and continuously running SageMaker infrastructure can dominate that deployment's cost.
- Leaving supporting services out of the estimate. Vector storage, Guardrails, Flow transitions, Data Automation, AgentCore tools, CloudWatch, S3, Lambda, and network transfer remain billable even when model inference is inexpensive.
- Relying on a launch price indefinitely. Promotions, model lifecycle changes, extended-access rates, and preview pricing all need dates and owners in the financial model.
Model invocation logging is disabled by default. Enable the appropriate logs and metrics, then reconcile per-call token and cache data with the Cost and Usage Report at the model, usage-type, and time grain. Forecasts become reliable only when production measurements replace assumed averages.
Conclusion
Amazon Bedrock pricing is no longer a single token calculation. The service offers several ways to trade cost for latency, throughput, residency, and operational control, while AgentCore, Knowledge Bases, Guardrails, Flows, evaluation, and media services can all contribute to the same user journey.
Small or unpredictable workloads still tend to favor on-demand Standard inference. Flexible and offline work can benefit from Flex or Batch. Cross-Region inference profiles can improve throughput and, for supported global profiles, reduce price. Predictable mission-critical traffic may justify Reserved capacity, while Provisioned Throughput and custom deployments need their own utilization model.
The durable approach is to price the complete architecture, test with current model cards and Regions, and measure actual production trajectories. When you understand every billing unit, from cache writes to agent memory, you can make deliberate trade-offs instead of discovering them on the AWS bill.
How Caylent Can Help
At Caylent, we help organizations design, deploy, and optimize generative AI solutions on AWS with cost efficiency, performance, security, and scalability in mind. From model and inference-profile selection to AgentCore architectures, retrieval, evaluation, customization, and ongoing cost attribution, our experts can help turn an experiment into a production system with an explainable operating model.
Whether you are validating your first use case or scaling an enterprise agent platform, reach out to Caylent to start building with confidence.
Generative AI & LLMOps
Guille Ojeda
Guille Ojeda is a Principal Innovation Architect at Caylent, a speaker, author, and content creator. He has published 2 books, over 200 blog articles, and writes a free newsletter called Simple AWS with more than 45,000 subscribers. He's spoken at multiple AWS Summits and other events, and was recognized as AWS Builder of the Year in 2025.
View Guille's articlesAccelerate your GenAI initiatives
Leveraging our accelerators and technical experience
Browse GenAI Offerings
Related Blog Posts
Survey Report: The Enterprise Readiness for Agentic Engineering & Autonomous Cloud Operations
Generative AI & LLMOps
Claude Opus 5: Changes, Improvements, and How It Compares to Fable 5
Learn what's new in Claude Opus 5, how it compares to Opus 4.8 and Fable 5, and what its new reasoning behavior, pricing, and performance improvements mean for enterprise AI workloads.
Generative AI & LLMOps
AWS Summit New York 2026: New Launches and Capabilities
Explore all of the launches and capabilities announced at the 2026 AWS Summit in New York City, including Amazon Bedrock Managed Knowledge Base, AgentCore harness, AWS Context, and AWS Continuum.
AWS Announcements
Generative AI & LLMOps