← Agent Frameworks 🕐 25 min read
Agent Frameworks

Azure OpenAI vs AWS Bedrock Enterprise TCO

Pricing Models, Cost Attribution, and Platform Decision Framework (2026) · March 2026

Azure OpenAI and AWS Bedrock have converged on a similar two-tier pricing architecture — on-demand pay-per-token and a reserved-capacity commitment tier — but the mechanics, economics, and operational

Audience: Enterprise architects, FinOps leads, platform engineering teams
Decision scope: Cloud AI platform selection, commitment tier optimization, multi-cloud strategy
Last verified: June 2026

Executive Summary

Azure OpenAI and AWS Bedrock have converged on a similar two-tier pricing architecture — on-demand pay-per-token and a reserved-capacity commitment tier — but the mechanics, economics, and operational overhead differ enough to materially affect a 12-month TCO at enterprise scale. The short version:

  • PTU (Azure) and Reserved Service Tier (Bedrock) break even at different utilization floors — Azure’s PTU requires ~50% sustained utilization over ~150–200M tokens/month to beat pay-as-you-go on GPT-4o; Bedrock’s RST tips at 80–85% sustained throughput.
  • Claude Sonnet 4.x on-demand pricing is identical on both platforms ($3.00/$15.00 per 1M input/output tokens); GPT-4o is Azure-exclusive; open-weight models (Llama 3.x) are Bedrock-exclusive. This creates model-driven platform lock-in.
  • Cost attribution tooling reached parity in April 2026 when AWS launched line_item_iam_principal in CUR 2.0. Azure’s tag inheritance model remains easier for multi-team environments already on an EA subscription; Bedrock’s IAM principal tracking is more precise for agent-level attribution.
  • Beyond API costs, vector DB and egress choices dominate TCO at 10M tokens/day scale — the gap between Azure AI Search and OpenSearch Serverless can exceed the API cost difference.
  • FOCUS 1.x exports are available from both providers but AI inference line items are not yet fully normalized; expect spec gaps through at least mid-2027.

1. Pricing Model Differences

1.1 Azure OpenAI: Pay-As-You-Go vs PTU

Pay-As-You-Go (PAYG) bills per token consumed. No commitment. Capacity is shared and subject to rate limiting at the subscription level. Suitable for development, irregular production traffic, and workloads below ~150M tokens/month.

Provisioned Throughput Units (PTU) reserve dedicated model compute capacity. The unit of commitment is a PTU-hour: you pay for reserved capacity regardless of whether tokens are consumed. PTU delivers:

  • Predictable latency (no neighbor-noise from shared tier)
  • Priority queue access under load spikes
  • Up to 70% savings vs PAYG at sustained high utilization

PTU mechanics:

  • 1 PTU ≈ 1,000 tokens-per-minute (TPM) of output capacity for GPT-4o (Microsoft’s documentation expresses PTU capacity in output tokens/min, not combined)
  • Minimum commitment: 1 PTU = approximately $2,448/month on monthly terms
  • Annual commitment reduces that by ~35% (≈ $1,591/month per PTU)
  • Batch API (async, non-real-time): 50% discount off PAYG on supported models

PTU break-even formula (GPT-4o):

Monthly PAYG cost = (input_tokens / 1M × $2.50) + (output_tokens / 1M × $10.00)

PTU monthly cost = num_PTUs × $2,448 (monthly) or × $1,591 (annual)

Break-even: PTU_cost ≤ PAYG_cost
Requires: ~150–200M tokens/month at ≥50% sustained utilization

Example: A team running 200M tokens/month (50% input, 50% output at a 1:3 input:output ratio by token count):

  • PAYG: (100M × $2.50/M) + (100M × $10.00/M) = $250 + $1,000 = $1,250/month
  • 1 PTU monthly: $2,448 — not break-even yet
  • At 3× that volume (600M tokens/month): PAYG = $3,750 vs 2 PTU = $4,896 — still marginal
  • PTU value emerges clearly at sustained high-throughput production (>500M tokens/month) with annual commitment; below that, PAYG or Batch wins

Critical nuance: PTU capacity is measured in output tokens/minute. A workload heavy on long completions (code generation, document drafting) consumes PTU capacity faster than a classification or short-answer workload. Under-sized PTU reservations throttle to PAYG overflow, negating savings.

1.2 AWS Bedrock: On-Demand vs Reserved Service Tier vs Provisioned Throughput

On-Demand is equivalent to Azure PAYG — per-token billing, shared compute, no commitment.

Reserved Service Tier (RST) — introduced for Claude Sonnet models and expanded to GovCloud in January 2026 — allows customers to commit to a fixed tokens-per-minute capacity with 1-month or 3-month terms:

  • Commitment unit: tokens-per-minute (TPM), specified separately for input and output (not combined)
  • Discounts: 15–40% vs on-demand depending on term and model
  • Designed for “mission critical applications with consistent throughput needs”
  • Break-even utilization: 80–85% sustained — a materially higher floor than Azure PTU’s ~50%

Provisioned Throughput (PT) — older mechanism, model-unit-hours rather than TPM, required for custom/fine-tuned model inference (no pay-per-token option for fine-tuned models)

Batch (async) processing: 50% discount off on-demand rates for both providers, applied when latency tolerance ≥ minutes. Both implement this through separate batch-inference APIs that accept job manifests and return results asynchronously.

RST vs PTU structural comparison:

Dimension Azure PTU Bedrock RST
Commitment unit PTU-hour (output TPM proxy) Input TPM + Output TPM (separate)
Minimum term 1 month 1 month
Maximum discount vs on-demand ~70% (annual, high utilization) 15–40% (shorter terms)
Break-even utilization floor ~50% 80–85%
Granularity 1 PTU increments Per-100-TPM increments
Overflow behavior Throttle or spill to PAYG Throttle; no auto-spill
Best fit Predictable high-volume, latency-sensitive Steady-state batch-adjacent workloads

Bedrock RST break-even formula:

Monthly on-demand cost = (input_tokens / 1M × model_input_rate) + (output_tokens / 1M × model_output_rate)

RST monthly cost = reserved_input_TPM × input_rate_per_TPM × hours + reserved_output_TPM × output_rate_per_TPM × hours

Break-even: RST_cost ≤ on-demand_cost
Requires: ≥80% sustained utilization of reserved capacity

2. Model Availability and Pricing (2026)

2.1 Model Landscape by Platform

Model Azure AI Foundry AWS Bedrock Direct API
GPT-4o ✓ ✗ OpenAI direct
GPT-4o mini ✓ ✗ OpenAI direct
o3 / o4 reasoning ✓ (via Foundry) ✗ OpenAI direct
Claude Sonnet 4.5 ✓ ✓ Anthropic direct
Claude Sonnet 4.6 ✓ ✓ Anthropic direct
Claude Opus 4 ✓ ✓ Anthropic direct
Claude Haiku 3.5 ✓ ✓ Anthropic direct
Llama 3.1 70B ✗ ✓ Meta/self-host
Llama 3.1 405B ✗ ✓ Meta/self-host
Amazon Nova Pro/Lite ✗ ✓ AWS only
Mistral Large ✓ (via Foundry) ✓ Mistral direct

GPT-4o is Azure-exclusive among managed cloud APIs. If GPT-4o is a hard requirement, Azure is the only managed option. This is the single biggest model-driven lock-in vector.

Claude models carry no cross-cloud pricing premium. Anthropic sets the same on-demand rates regardless of whether you access through Azure AI Foundry or AWS Bedrock.

Open-weight models (Llama 3.x) are Bedrock-exclusive among the two platforms. For teams that want to arbitrage between proprietary and open-weight models in one platform, Bedrock has the broader menu.

2.2 Current On-Demand Token Pricing (per 1M tokens, June 2026)

Model Platform Input Output Notes
GPT-4o Azure PAYG $2.50 $10.00 Azure-exclusive
GPT-4o mini Azure PAYG $0.15 $0.60 Azure-exclusive
Claude Sonnet 4.6 Azure AI Foundry $3.00 $15.00
Claude Sonnet 4.6 AWS Bedrock $3.00 $15.00 Identical to Azure
Claude Sonnet 4.5 Azure AI Foundry $3.00 $15.00
Claude Sonnet 4.5 AWS Bedrock $3.00 $15.00 Identical to Azure
Claude Haiku 3.5 AWS Bedrock $0.80 $4.00
Llama 3.1 70B AWS Bedrock $0.35 $0.45 Bedrock-exclusive
Llama 3.1 405B AWS Bedrock $0.65 $0.80 Bedrock-exclusive
text-embedding-3-small Azure OpenAI $0.02 — Input only

Batch discount (async): Both platforms offer ~50% off on-demand rates for batch API workloads. For a team running 10M tokens/day in classification or summarization tasks with latency tolerance of 15–30 minutes, batch alone cuts the API line item in half.

Prompt caching: Claude models on both Bedrock and Azure support prompt caching (up to 90% off cached input tokens for repeated system prompts/contexts). This is especially material for RAG pipelines where the retrieved context is large and overlapping across requests.

2.3 Cross-Cloud Arbitrage

Because Claude pricing is identical on both platforms, there is no token-cost arbitrage in switching Claude workloads between Azure and Bedrock. The arbitrage is operational:

  • Azure advantage: Tight integration with Entra ID, Azure Policy, existing EA billing consolidation
  • Bedrock advantage: IAM principal attribution (richer per-caller cost visibility as of April 2026), native AWS service integration (S3, Lambda, SageMaker)
  • Model arbitrage: Teams with mixed GPT-4o (Azure) and Llama (Bedrock) workloads will necessarily run multi-cloud

3. Cost Attribution Differences

3.1 Azure: Diagnostic Settings → Log Analytics → Cost Management Tags

Azure’s attribution model is hierarchical and tag-propagating:

  1. Azure Cost Management shows spend by Subscription → Resource Group → Resource (the Azure OpenAI service instance). Deployment-level granularity is not surfaced natively in Cost Management.
  2. Tagging strategy: Tags applied at the Resource Group level propagate to child resources and appear in billing exports. The recommended pattern is:
    • project tag on the Resource Group
    • feature tag on each Azure OpenAI deployment
    • env tag (prod/staging/dev)
  3. Diagnostic Settings: Enabling Azure Monitor diagnostic settings on the OpenAI resource pushes token usage, latency, and request counts to Log Analytics. Query:
    AzureMetrics
| where ResourceProvider == "MICROSOFT.COGNITIVESERVICES"
| where MetricName in ("TokenTransaction", "PromptTokensCount", "CompletionTokensCount")
| summarize sum(Total) by bin(TimeGenerated, 1h), ResourceId
  4. Azure Policy for tag enforcement: Assign the built-in Require a tag on resource groups policy at management group scope to enforce the feature and project tags before resource creation. This prevents attribution gaps at the point of provisioning rather than retroactively.
  5. Cost Management exports to FOCUS: Azure supports FOCUS-format billing exports from Cost Management. Available fields include ResourceId, Tags, UsageQuantity (tokens), and EffectiveCost. AI inference line items appear under service name Microsoft.CognitiveServices.

Known friction points:

  • Deployment-level tag enforcement requires custom policy; built-in policies stop at resource level
  • Log Analytics ingestion is billed separately (as microsoft.operationalinsights in Cost Management) — verbose logging at scale adds 15–40% to the observable monitoring cost on top of API cost
  • FOCUS exports do not yet include the full token breakdown (input vs output) as separate line items; this is on the known gap list for the FOCUS 1.x AI inference extension

3.2 AWS Bedrock: CUR 2.0 + IAM Principal Attribution

AWS’s attribution model is identity-first since April 2026:

  1. CUR 2.0 columns relevant to Bedrock:
    • line_item_usage_type: operation name (e.g., InputTokens, OutputTokens, InvokeModelInference)
    • line_item_resource_id: the model ARN
    • line_item_iam_principal: the full ARN of the IAM user, role, or assumed-role session that made the call — opt-in per data export config, not retroactive
    • resource_tags/*: cost allocation tags attached at request time
  2. FOCUS export from Bedrock: AWS includes Bedrock in its FOCUS 1.x data exports. The line_item_iam_principal field does not yet have a FOCUS-spec equivalent column name (it appears as a provider-extension column). Input/output tokens appear as separate line items with distinct usage types — better granularity than Azure’s FOCUS export.
  3. Cost allocation tags: Tags must be activated in the Billing Console before use. They are not retroactive. The standard pattern for enterprise teams: tag by Project, Team, CostCenter, and Environment at the IAM role level (roles assumed by applications propagate their tags to Bedrock usage).
  4. Account-level isolation: The strongest Bedrock attribution pattern is separate AWS accounts per team/project (AWS Organizations), with consolidated billing. This gives zero-ambiguity attribution without relying on tags or IAM principal filtering. Tag discipline failures are contained to a single account.
  5. SCP (Service Control Policies): Tag policy enforcement via AWS Organizations SCPs prevents Bedrock API calls from accounts that don’t have the required cost allocation tags active — equivalent to Azure Policy’s resource-group tag enforcement.

Comparison verdict:

Dimension Azure AWS Bedrock
Deployment-level attribution Requires custom policy + Log Analytics Native via line_item_iam_principal (April 2026)
Tag enforcement Azure Policy (mature, built-in) SCP + Organizations tag policies
Billing export granularity Resource-level; deployment needs extra tagging IAM principal + operation type natively in CUR 2.0
Input vs output token separation Not split in FOCUS export Separate line items in CUR 2.0
Ease for existing EA customers Lower friction (existing Azure tooling) Requires AWS Organizations setup if not already in place
Agent-level attribution Requires custom logging layer Native since April 2026 — best in class

For FinOps teams that need to answer “which application/agent spent what,” Bedrock’s IAM principal attribution is now the stronger solution. For teams already invested in Azure subscription hierarchy and Policy, Azure’s tag-propagation model requires less net-new infrastructure.

4. FinOps Tooling Ecosystem

4.1 AWS: CUDOS + FinOps Agent

CUDOS (Cloud Intelligence Dashboards on AWS) is an AWS-native QuickSight dashboard powered by CUR 2.0. As of CUDOS v5.8.0–v5.8.1 (2026):

  • Bedrock token cost visuals updated from per-1K to per-1M tokens
  • IAM principal tag cost breakdowns added
  • InvokeModelInference and InvokeModelStreamingInference operation-level spend visible
  • Database Savings Plans coverage (relevant if pairing Bedrock with RDS/Aurora for retrieval stores)

AWS FinOps Agent (public preview, June 9, 2026): An AI agent that sits atop Cost Explorer, Anomaly Detection, Cost Optimization Hub, Compute Optimizer, and CloudTrail. Relevant Bedrock capabilities: detects token cost anomalies, flags over-provisioned RST capacity, recommends batch conversion for idle-hour patterns.

nOps, CAST AI, Spot.io: Third-party tools with Bedrock support, primarily focused on compute and not yet deeply integrated with AI token-specific optimization.

4.2 Azure: Cost Management + Advisor

Azure Cost Management (ACM) surfaces OpenAI spend at the resource level with tag filtering. The microsoft.cognitiveservices service type covers all Azure AI services including OpenAI. PTU commitment utilization is visible in ACM under Reservations.

Azure Advisor provides PTU rightsizing recommendations when it detects PTU deployments running below 50% average utilization over 30 days. This is operationally useful: Azure self-reports on wasted PTU commitments.

Microsoft Cost Management + Billing API: Programmatic access for custom FinOps dashboards. The usageDetails endpoint returns per-resource spend with tags. Integration with Power BI is native.

4.3 Multi-Cloud: LiteLLM as Attribution Gateway

LiteLLM (open source SDK + proxy) normalizes API calls across Azure OpenAI, Bedrock, Anthropic direct, Vertex AI, and 100+ other providers behind an OpenAI-compatible interface. FinOps-relevant capabilities:

  • Unified spend tracking: Every request logged with provider, model, input tokens, output tokens, cost (calculated using provider rate cards)
  • Per-project/per-user budgets: Budget limits enforced at proxy layer before calls reach providers — prevents runaway spend without cloud-provider-level setup
  • Metadata injection: Attach project, team, feature metadata to every request; stored in proxy logs for attribution queries independent of cloud-provider tagging
  • Provider fallback: Route to Bedrock if Azure quota is exhausted (or vice versa) with cost visibility on both legs

LiteLLM for multi-cloud arbitrage: Useful for teams that genuinely run both platforms. The proxy adds ~5–20ms latency overhead (self-hosted). The operational burden of running the proxy infrastructure (Redis for rate limiting, PostgreSQL for logs, load balancer) adds ~$300–800/month in infrastructure cost for a mid-size deployment — justified when it replaces per-platform attribution tooling.

LiteLLM Enterprise (commercial): Adds RBAC, SSO, audit logs, and a management UI. Priced per seat; relevant for teams with >10 engineers consuming AI APIs.

4.4 Third-Party Multi-Cloud: Apptio / CloudHealth / Finout

Apptio (IBM): Strong Azure module (born from Microsoft ecosystem). Bedrock support added in 2025 but not as deep — IAM principal attribution not yet surfaced in standard Bedrock views as of June 2026.

VMware Aria Cost (CloudHealth): AWS-native heritage, strong Bedrock integration. Azure OpenAI coverage added but lacks PTU commitment utilization tracking.

Finout: Purpose-built FinOps for AI workloads. Supports both Azure and Bedrock with token-level cost attribution. MegaBill feature normalizes spend across providers. Better fit for “AI-first” teams than legacy multi-cloud tools.

4.5 FOCUS Export Comparison

Both Azure and AWS publish FOCUS-format billing exports. Current state (June 2026):

Field Azure FOCUS Export AWS Bedrock FOCUS Export
ServiceName Azure OpenAI Amazon Bedrock
ResourceType microsoft.cognitiveservices/accounts Model ARN (as ResourceId)
UsageUnit Tokens (combined) Tokens (split input/output as separate line items)
Tags Full tag map from resource Cost allocation tags + IAM principal as extension column
FOCUS version 1.0 GA (partial 1.1) 1.0 GA
AI inference extension Not yet adopted Not yet adopted

Key gap: Neither provider has adopted the FinOps Foundation’s 2026-targeted AI inference FOCUS extensions. Input vs output token costs are not split in Azure’s export; Bedrock splits them via CUR 2.0 operation types but maps them to a custom extension column in FOCUS. Teams building multi-cloud cost normalization pipelines should treat AI inference data as requiring provider-specific parsing logic until the extension is ratified (expected 2027).

5. Enterprise Data Residency and Compliance

5.1 Regulatory Coverage

HIPAA: Both Azure and AWS are HIPAA-eligible and will sign a Business Associate Agreement (BAA). Azure includes AI Foundry/OpenAI under its BAA scope explicitly. AWS Bedrock’s HIPAA eligibility is documented in the AWS Artifact HIPAA package. For healthcare workloads, both are viable; Azure has an operational edge for organizations already running M365 under a HIPAA BAA.

FedRAMP:

  • Azure Government (AzureGov): FedRAMP High authorized. Azure Government Secret and Top Secret tiers for classified. Azure OpenAI is available in AzureGov regions.
  • AWS GovCloud (US-East, US-West): FedRAMP High authorized. Amazon Bedrock Reserved Tier became available in GovCloud (US-West) in January 2026. This was a significant milestone — previously Bedrock commitment tiers were US commercial only.
  • Verdict for FedRAMP High: Both are viable. Azure has broader compliance certification count (100+ vs AWS’s 143+ security standards). Azure wins on pre-built compliance policy templates within the platform ecosystem; AWS wins on breadth of third-party FedRAMP-authorized services that integrate with Bedrock.

FINRA (financial services): Neither platform has explicit FINRA certification (FINRA does not certify cloud providers). The relevant requirements are SEC Rule 17a-4 (immutable record retention) and FINRA Rule 4511 (books and records). Azure has longer-standing financial services audit trails and purpose-built compliance features in Microsoft Purview. AWS GovCloud satisfies SEC 17a-4 requirements via S3 Object Lock + Macie. For broker-dealer workloads, both are viable; the decision hinges on existing audit infrastructure (Azure Sentinel vs AWS Security Hub/CloudTrail).

SR 26-2 (Federal Reserve model risk guidance): Both platforms’ AI model inference APIs fall into scope as “vendor models” requiring third-party model risk management. Neither platform provides the model documentation package needed for SR 26-2 compliance directly. This is a governance layer above platform choice.

5.2 Data Residency

Azure data residency: Azure OpenAI deployments are region-scoped. With Data Boundary configuration, Azure can guarantee that prompts and responses stay within the EU or US. Azure’s Sovereign Cloud (AzureGov, Azure Germany, Azure China) provides hard geo-fencing. For EU customers, Azure AI Foundry deployments in swedencentral or francecentral satisfy EU Data Boundary requirements.

AWS Bedrock data residency: Bedrock inference does not leave the selected AWS region by default. Cross-region inference (a Bedrock feature for higher throughput) routes traffic to additional regions and must be explicitly disabled for strict residency requirements. For EU data residency: eu-west-1 (Ireland) and eu-central-1 (Frankfurt) are available. AWS GDPR DPA covers Bedrock.

Latency and throughput SLAs: Neither Azure nor AWS publishes hard throughput SLAs for PAYG/on-demand tiers. PTU (Azure) and RST (Bedrock) both include throughput guarantees as a primary feature — this is one of the principal reasons to pay the commitment premium in latency-sensitive production workloads.

5.3 Model Data Handling

Both platforms explicitly state that prompts and completions on their managed AI APIs are not used for model training by default. Azure has a clearer contractual commitment to this in the Azure OpenAI Product Terms. AWS Bedrock’s data handling is governed by the AWS Customer Agreement and Bedrock-specific addendum; same effective guarantee. Fine-tuning data submitted to either platform may be stored temporarily for job execution.

6. Total Cost Model — Beyond API Costs

6.1 The Cost Stack

Enterprise AI TCO at 10M tokens/day has five cost layers, not one:

1. API inference costs        (per-token or PTU/RST commitment)
2. Vector database costs      (storage + query compute)
3. Embedding generation       (separate from inference)
4. Egress / data transfer     (from storage to inference)
5. Observability / logging    (Log Analytics or CloudWatch)

The API cost dominates in early phases. At 10M tokens/day scale, layers 2–5 often represent 30–60% of the API cost and are systematically underestimated in initial budgets.

6.2 Vector Database Cost Comparison

Azure AI Search (vector search):

  • No additional per-query charge for vector operations — included in the base Search Unit pricing
  • Search Units (SU) = replicas × partitions; 1 SU starts at ~$73/month (Standard tier)
  • For a production RAG deployment (2 replicas × 2 partitions = 4 SU): ~$292/month
  • 2GB index storage included per partition; additional partitions for larger corpuses
  • Integrated with Azure OpenAI (same VNet, no cross-cloud egress for embeddings)

AWS OpenSearch Serverless (vector engine):

  • OCU pricing: $0.24/OCU/hour for both indexing and search
  • Minimum production deployment: 2 OCUs (redundancy) = $0.48/hour = ~$350/month
  • Each collection group has a minimum charge floor; 12 isolated tenant collections = ~$4,200/month minimum
  • For a standard single-tenant production RAG deployment: $350–700/month depending on query load
  • Storage: $0.024/GB/month (separate from OCU costs)

Pinecone on AWS or Azure (cross-cloud):

  • Serverless plan: $0.033 per 1M reads, $0.08 per 1M writes, $0.00000025/vector/month storage
  • At 10M RAG queries/day (each querying top-5 vectors): 10M × $0.033/M = $0.33/day = ~$10/month for reads (surprisingly cheap at serverless tier)
  • Pod-based (dedicated): starts at ~$70/month per pod (p1.x1 on AWS)
  • Pinecone is cloud-agnostic and doesn’t create egress coupling; cross-cloud latency (+10–30ms) is the trade-off

Cost verdict at 10M tokens/day RAG scale:

  • Azure AI Search: $292–600/month (predictable, no per-query charge)
  • OpenSearch Serverless: $350–1,400/month (highly variable by collection count)
  • Pinecone serverless on same cloud: $10–50/month (lowest cost for read-heavy workloads)

6.3 Embedding Costs

Azure OpenAI text-embedding-3-small: $0.02 per 1M tokens — effectively zero at most enterprise scales.

AWS Bedrock Titan Embeddings: Similar pricing tier. Amazon Titan Embed Text V2: $0.02/1M tokens.

Embedding cost at 10M tokens/day:

  • Assuming 10% of daily token volume is re-embedded (new documents): 1M tokens/day
  • Monthly: 30M tokens × $0.02/M = $0.60/month
  • Even at 100M tokens/day total embedding: $2/month — not a material TCO driver

Embedding costs are negligible. Index storage and query compute (vector DB) dominate this layer.

6.4 Egress Costs

Azure: Data transfer within the same Azure region is free. Cross-region data transfer: $0.02–$0.05/GB. Azure Blob Storage → Azure OpenAI (same region): $0. Azure Blob Storage → external: $0.087/GB (first 10TB/month).

AWS: Data transfer within the same AWS region between services (S3 → Bedrock): $0. Cross-region: $0.02–$0.09/GB. Bedrock → internet: $0.09/GB.

Practical egress cost at 10M tokens/day:

  • Assuming average 2KB context payload per request: 10M × 2KB = 20GB/day
  • Intra-region (Azure or AWS): $0
  • Cross-region or hybrid (e.g., S3 in us-east-1, Bedrock in eu-west-1): 20GB/day × $0.02/GB = $0.40/day = ~$12/month — still not material
  • Large document corpus transfer (e.g., nightly S3 → Bedrock Knowledge Base sync at 100GB): 100GB × $0.02 = $2/month

Egress is not a TCO driver unless data is being exfiltrated across regions at high volume. The more significant cost is inter-cloud egress if running a multi-cloud architecture (e.g., Bedrock inference pulling context from Azure Blob): ~$0.09/GB, which at 20GB/day = $54/month. Multi-cloud data plane coupling is the egress trap.

6.5 Fine-Tuning Costs

Azure OpenAI fine-tuning:

  • Training: $1.50–$25 per 1M tokens depending on model
  • Hosting (deployed fine-tuned model): $1.70–$3.00/hour regardless of usage = $1,224–$2,160/month idle cost
  • This idle hosting cost makes fine-tuned model deployment economically viable only for high-utilization deployments

AWS Bedrock fine-tuning:

  • Training: ~$0.008 per 1,000 tokens for 70B models = $8 per 1M tokens
  • Custom model hosting (Provisioned Throughput required): $23.40/model unit-hour (no commitment), $16.85/model unit-hour (6-month), = $16,848/month minimum for a deployed custom model
  • Storage of trained model weights: $1.95/month (negligible)
  • Note: Fine-tuned models on Bedrock cannot use pay-per-token; Provisioned Throughput is mandatory

Verdict: Fine-tuning economics on both platforms require high, sustained inference volume to justify the hosting commitment. AWS’s Provisioned Throughput requirement for fine-tuned models makes the minimum monthly hosting cost dramatically higher than Azure’s. For infrequent fine-tuned model inference, Azure is materially cheaper. For high-throughput fine-tuned model inference (where PT utilization is ≥80%), the cost structures become more comparable.

6.6 Observability and Logging Costs

Azure Log Analytics:

  • Ingestion: $2.30/GB (Pay-As-You-Go); commitment tier at $1.50–$2.00/GB at volume
  • Verbose Azure OpenAI logging (request + response bodies): can generate 5–15 KB per request
  • At 10M requests/day × 10 KB average = 100 GB/day = $230/day = $6,900/month at PAYG ingestion rate
  • This is the hidden cost trap. Verbose logging at production scale makes Log Analytics more expensive than the API itself.
  • Mitigation: 5–10% sampling in production, structured metrics only (no request bodies) for cost attribution

AWS CloudWatch / CUR:

  • CUR 2.0 data export: storage in S3 (~$0.023/GB/month); negligible
  • CloudWatch Logs ingestion for Bedrock: $0.50/GB ingested
  • At 10M requests/day × 1 KB structured log = 10 GB/day = $5/day = $150/month — significantly cheaper than Azure Log Analytics at equivalent verbose logging
  • IAM principal attribution data in CUR 2.0 adds zero marginal cost beyond enabling the export

Observability cost verdict: AWS CloudWatch is materially cheaper for high-volume logging. Azure Log Analytics is more powerful for ad-hoc KQL queries but costs 4.6× more per GB at PAYG rates. For FinOps-only attribution (no full request body needed), Azure structured metrics + Cost Management tags at resource level is comparably cheap.

7. Full 12-Month TCO Model — Mid-Size Enterprise (10M Tokens/Day)

Scenario Assumptions

Parameter Value
Daily volume 10M tokens total
Input:Output split 70:30 (typical RAG/chat)
Peak hours 10 hours/day at 2× average rate
Primary model Claude Sonnet 4.6 (both platforms) + GPT-4o (Azure-only)
GPT-4o share 30% of volume on Azure scenario
RAG deployment Yes — vector search required
Fine-tuning No (excluded to isolate platform economics)
Team size 15 engineers, 5 AI applications

Azure TCO (Monthly)

Line Item Calculation Monthly Cost
Claude Sonnet 4.6 PAYG (7M tokens/day × 70% input) 147M input tokens/month × $3/M $441
Claude Sonnet 4.6 PAYG (7M tokens/day × 30% output) 63M output tokens/month × $15/M $945
GPT-4o PAYG (3M tokens/day × 70% input) 63M input tokens/month × $2.50/M $157
GPT-4o PAYG (3M tokens/day × 30% output) 27M output tokens/month × $10/M $270
Embeddings (text-embedding-3-small, 5% of volume) 15M tokens/month × $0.02/M $0.30
Azure AI Search (Standard tier, 4 SU) Fixed $292
Log Analytics (10% sampling, structured only, ~10GB/day) 300 GB/month × $2.30/GB $690
Networking (intra-region, minimal) — $0
API + Platform Subtotal $2,795/month
Azure Monitor / Policy / Entra overhead ~10% of platform cost ~$280
Total Monthly (Azure, PAYG) ~$3,075
Total 12-Month (Azure, PAYG) ~$36,900

Azure with PTU (at 10M tokens/day, evaluating PTU viability):

  • Monthly volume: 90M Claude Sonnet tokens + 90M GPT-4o tokens = 300M tokens total
  • PTU break-even for Claude Sonnet at this volume: requires ~1 PTU for Sonnet at estimated $2,448/month — marginal at this volume, PAYG likely still competitive
  • Recommendation: stay PAYG until volume exceeds 500M tokens/month consistently

AWS Bedrock TCO (Monthly)

Line Item Calculation Monthly Cost
Claude Sonnet 4.6 on-demand (10M tokens/day, 70% input) 210M input tokens/month × $3/M $630
Claude Sonnet 4.6 on-demand (10M tokens/day, 30% output) 90M output tokens/month × $15/M $1,350
Embeddings (Amazon Titan Embed, 5% of volume) 15M tokens/month × $0.02/M $0.30
OpenSearch Serverless (1 collection, 2 OCU minimum) 2 OCU × $0.24/hr × 720 hrs $346
CloudWatch Logs (10% sampling, ~10GB/day) 300 GB/month × $0.50/GB $150
CUR 2.0 / S3 export storage ~5 GB/month × $0.023 $0.12
Networking (intra-region) — $0
API + Platform Subtotal $2,476/month
IAM/Organizations overhead ~5% ~$124
Total Monthly (Bedrock, on-demand) ~$2,600
Total 12-Month (Bedrock, on-demand) ~$31,200

TCO Comparison Summary

Scenario Monthly Annual Delta vs Bedrock
Azure PAYG (Claude + GPT-4o mixed) ~$3,075 ~$36,900 +18%
Bedrock on-demand (Claude only) ~$2,600 ~$31,200 baseline
Azure PAYG (Claude only, no GPT-4o) ~$2,263 ~$27,156 -13%
Bedrock with RST (at 80% utilization) ~$2,200 ~$26,400 -15%
Azure with PTU (at >80% utilization, annual) ~$2,100 ~$25,200 -19%

Key finding: At 10M tokens/day, PAYG pricing is still the dominant mode. The Azure premium is driven by GPT-4o usage (higher per-token rate than Claude on equivalent tasks) and Log Analytics ingestion costs. Claude-only workloads on Azure are slightly cheaper than Claude on Bedrock at PAYG due to lower observability costs when structured metrics replace Log Analytics verbose logging.

Commitment tier savings: Both RST (Bedrock) and PTU (Azure) require the workload to scale to where the commitment makes sense. At 10M tokens/day (~300M/month), the break-even is borderline. At 1B tokens/month, both commitment tiers become compelling (20–40% savings).

8. Decision Framework

8.1 Standardize on Azure When:

  1. GPT-4o is a hard model requirement — no equivalent on Bedrock; no path to arbitrage
  2. Existing Azure EA with significant committed spend — Azure AI credits or EA discounts can offset API costs materially; check if AI Foundry spend counts against your EA commitment
  3. Microsoft 365 / Entra ID integration is the primary control plane — Entra ID as the identity layer for AI API access simplifies access management for teams already managing M365 identity
  4. Regulated industry already on Azure Government — FedRAMP High workloads are easier to stand up when the entire stack (compute, storage, AI) is in AzureGov; cross-cloud certification burden is significant
  5. Azure Policy + Resource Groups are your primary cost allocation mechanism — teams already enforcing tag policies across Azure subscriptions get cost attribution “for free”

8.2 Standardize on AWS Bedrock When:

  1. Primary application stack is AWS-native — Lambda, ECS, SageMaker, DynamoDB; keeping AI inference within the same account eliminates egress and simplifies IAM
  2. Llama 3.x or Amazon Nova models are required — open-weight model access without self-hosting is Bedrock-exclusive
  3. IAM principal-level cost attribution is a FinOps requirement — Bedrock’s April 2026 line_item_iam_principal feature provides agent-level cost visibility with no additional tooling; Azure requires custom logging pipelines for equivalent granularity
  4. AWS EDP (Enterprise Discount Program) covers AI spend — if negotiating an EDP, confirm that Bedrock inference counts toward the commitment; this can shift the economics significantly
  5. Existing AWS Organizations structure — account-per-team cost isolation is the strongest attribution model; organizations already using this pattern get Bedrock attribution nearly for free

8.3 Run Multi-Cloud AI When:

  1. Model portfolio spans both platforms — GPT-4o (Azure) + Llama/Nova (Bedrock) in the same product
  2. Platform redundancy is required — regulated industries may require multi-cloud AI for BCP; LiteLLM provides the routing layer
  3. Comparative evaluation is ongoing — during a 90-day model evaluation period before committing to a platform; run both behind LiteLLM proxy, then choose

Multi-cloud cost overhead: The LiteLLM proxy adds $300–800/month infrastructure cost and 5–20ms latency. Worth it for active platform evaluation. Not worth it long-term unless model diversity genuinely requires it.

8.4 Commitment Tier Decision Tree

Is monthly token volume > 300M tokens/month?
├── No → Stay on PAYG / on-demand; revisit in 90 days
└── Yes → Is utilization predictable (±20% variance)?
    ├── No → Stay on PAYG; use Batch API (50% off) for async workloads
    └── Yes → Can you sustain ≥50% utilization (Azure) or ≥80% (Bedrock)?
        ├── Azure PTU: ≥50% utilization → evaluate PTU, annual for best rate
        └── Bedrock RST: ≥80% utilization → evaluate RST, 3-month term

For PTU/RST sizing: measure actual throughput over 30–60 days before committing.
Under-sized commitments throttle; over-sized commitments waste spend.

8.5 Organizational Considerations

Existing EA vs EDP negotiation:

  • Azure EA customers should ask: does Azure AI Foundry / OpenAI consumption count toward the EA monetary commitment? As of 2026, it typically does. This can make the effective Azure API rate lower than list price.
  • AWS EDP customers should confirm Bedrock is included in EDP eligible services — it is in most 2025+ EDPs but confirm in writing.

Model preference is a stronger signal than platform economics at most scales. Below 500M tokens/month, the TCO difference between Azure and Bedrock (Claude-only) is within 10–20% — well within the range of negotiated discounts either provider will offer to lock in a commitment. Pick the platform where the team operates best, then optimize the commitment tier.

The LiteLLM hedge: For organizations that genuinely cannot pick a model preference, deploying LiteLLM as an internal API gateway with routing by model/capability (not by platform preference) is the right architectural choice. It normalizes cost attribution, enables instant re-routing if a provider has an outage, and defers the platform commitment decision. The operational cost ($300–800/month + DevOps time) is a reasonable insurance premium against multi-year platform lock-in.

Appendix: Quick Reference

On-Demand Pricing Summary (June 2026, per 1M tokens)

Model Input Output Platform
GPT-4o $2.50 $10.00 Azure only
GPT-4o mini $0.15 $0.60 Azure only
Claude Sonnet 4.6 $3.00 $15.00 Azure + Bedrock (same)
Claude Haiku 3.5 $0.80 $4.00 Azure + Bedrock
Llama 3.1 70B $0.35 $0.45 Bedrock only
Llama 3.1 405B $0.65 $0.80 Bedrock only
text-embedding-3-small $0.02 — Azure
Titan Embed Text V2 $0.02 — Bedrock

Batch API Discount: 50% off on-demand for both platforms

PTU / RST Key Numbers

Azure PTU Bedrock RST
Commitment unit PTU (≈1K output TPM) Input TPM + Output TPM (separate)
Monthly cost per unit ~$2,448 (monthly) / ~$1,591 (annual) Model-dependent
Discount vs on-demand Up to 70% (annual, high utilization) 15–40%
Break-even utilization ~50% ~80–85%

Vector DB Cost at Production Scale (10M token/day RAG)

Option Monthly Notes
Azure AI Search Standard (4 SU) ~$292 No per-query charge
OpenSearch Serverless (2 OCU) ~$346+ Per-collection minimum
Pinecone Serverless ~$10–50 Pay-per-read, cloud-agnostic

Sources used in this synthesis are listed below. Pricing verified June 2026; both platforms update list prices without advance notice — validate against official pricing pages before budget submission.

Sources