ASCENDING Blog Home
Jarvis AI
Cloud Services
Talent Solutions
Public Sector
About

Amazon Bedrock Cost Allocation: Track AI Spend by Team

Read Time: 8 min read Publish Date:

Kelvin Yu portrait

Kelvin Yu

Contributing Writer · AWS Agents

Share on LinkedIn
On this page
Three teams send model requests through tagged Bedrock resources, producing separate lines in a shared AWS cost report.

Amazon Bedrock cost allocation starts with a simple question: which team should own each part of the bill? The answer has to survive the request path. A department name in a spreadsheet won’t help if every application calls Bedrock through one unlabelled role.

You can do much of this with AWS’s native features. Start by checking the API your application uses, choose an attribution method, and reconcile the resulting team totals. Add a separate monitoring platform when you have a specific gap to close.

This guide covers that setup. For the wider distinction between billing, traces and spending controls, see our AI token cost tracking guide.

Key Takeaways

  • Match the method to the API. Application inference profiles aren’t supported by every Bedrock API.
  • Activate cost allocation tags before relying on them in a report.
  • Keep unattributed spend visible. A report that accounts for only part of the bill isn’t ready for chargeback.

AWS documentation checked November 11, 2026. The example amounts below are illustrative, not customer results.

Choose the method that matches your Bedrock calls

Bedrock has several ways to assign costs. The right choice depends on whether you need ownership by caller, by application, or by individual request.

Your application usesPractical starting pointWhat to watch
InvokeModel or Converse on bedrock-runtimeTagged application inference profiles for application or team costsEach profile is tied to a model
Responses or Chat Completions on bedrock-mantleProjects for application costsCheck the endpoint before choosing this route
Responses or Chat Completions on bedrock-runtimeStart with IAM principal attributionApplication profiles aren’t supported; Projects apply to Mantle
IAM roles or federated sessions representing teamsIAM principal attribution, with team tags where neededA shared caller needs extra work to preserve ownership
Supported Runtime calls where you need prompt-level detailRequest metadata and model invocation logsToken-based cost calculations remain estimates

The AWS application inference profile documentation explicitly excludes Responses and Chat Completions on both endpoints. Passing an application profile as their inference target returns a 400 error.

Projects apply only to Mantle. The table covers common starting points, rather than every Bedrock cost-management feature.

This matters for coding agents and OpenAI-compatible clients. Using Bedrock doesn’t establish that a client can use an application inference profile. Inspect its actual calls before changing the configuration.

IAM principal attribution works across Runtime and Mantle APIs. It can run alongside application profiles or Projects. You don’t have to choose one mechanism for every application.

1. Agree on the ownership fields

Pick a few fields that finance and engineering can maintain together. More tags don’t automatically produce a better report.

FieldExample valueDecision it supports
teamcustomer-supportWhich manager owns the spend?
applicationticket-assistantWhich workflow produced it?
environmentproductionIs this customer use or testing?
cost-centercc-104Where should finance assign it?

Keep values stable. If engineering uses support and finance uses customer-service, agree on one mapping before the first monthly report.

Give each application an owner who can explain an increase. Keep an explicit unallocated category for incomplete records. Don’t spread those costs across teams just to make the report look finished.

Use internal identifiers rather than personal or customer details. Tags are operational data that may appear in billing exports and logs.

2. Use application profiles at a manageable level

For InvokeModel and Converse workloads, create application inference profiles for the ownership groups you need to distinguish. Then configure calls to use the profile ARN in place of the model ID.

A system-defined profile handles AWS-defined routing. An application profile adds a resource you can tag for your own workload. Our Bedrock inference profiles guide explains that difference and the setup steps.

Start with team, application and environment. Creating one profile per employee quickly becomes expensive to maintain in administrative terms.

For example, two teams using two models in two environments could require eight profiles, if every combination needs separate tags. Another model version adds more resources. That is a planning example, not an AWS quota.

Keep an inventory with the profile ARN, underlying model, tags, application configuration and owner. A model upgrade should update that inventory as well as the code.

The trade-off is clear: profiles make ownership explicit, but somebody must maintain them. Where roles already represent teams, principal attribution may be the simpler starting point.

3. Activate the tags and prove they reach billing

Tagging a profile isn’t the last step. Activate the relevant keys under Cost allocation tags in AWS Billing and Cost Management.

AWS’s tag activation guide describes two separate delays. New keys can take up to 24 hours to appear for activation. Activation can then take up to another 24 hours.

Make this a small acceptance test:

  1. Create or select one tagged application profile.
  2. Record its ARN, model, tags and activation status.
  3. Send a short, non-sensitive test request through that profile.
  4. Note the account, Region and time of the call.
  5. After billing updates, check the expected tag value and spend group.

In an AWS Organization, coordinate activation with the management or payer account. Don’t assume an application developer can complete the billing step from a member account.

Plan activation before the reporting period you intend to use. Attaching a tag today doesn’t automatically repair earlier untagged costs.

Tagged Bedrock requests feed Cost Explorer and CUR billing totals, while CloudWatch provides a separate view of supported usage metrics.

Cost Explorer and CUR supply billed totals. CloudWatch supplies supported usage metrics; separate invocation logs help explain individual calls.

4. Build a report you can reconcile

In Cost Explorer, filter to the accounts and Bedrock usage you want to review. Group by the activated team tag. Add application or environment views when someone needs to investigate a change.

Before sharing the report, write down its date range, currency, accounts, service filters and cost measure. Use the same settings for the overall total and every team subtotal.

If you use AWS Cost and Usage Reports, confirm which export you have. AWS’s cost attribution FAQ distinguishes tag columns from caller identity data. The automatic caller identity column requires CUR 2.0 with the caller-identity option selected.

Billing rows aren’t individual prompt receipts. Compare logs and billing at a compatible level, such as model, usage type and day. Don’t join a daily cost row to every request and count the same dollars repeatedly.

Also record what’s outside the report. A view of model inference doesn’t establish the full cost of an assistant. Supporting compute, storage and operating work may sit elsewhere.

5. Handle shared roles without guessing the end user

One application role can serve several departments. AWS can identify that role, but the role name alone doesn’t say which employee initiated a request.

Where billing needs to distinguish sessions, the gateway or application can assume a role with appropriate session tags. This needs a reviewed trust policy and a reliable mapping from signed-in user to team.

Avoid trusting a team name supplied freely in a request body. The layer assigning ownership should obtain it from an approved identity or application record.

For supported Runtime APIs, request metadata can add identifiers to model invocation logs. It doesn’t turn each call into an itemized billing row, and it isn’t supported on Mantle.

Keep the purposes separate. Session or resource tags help assign billed costs. Request records explain retries, token use and failed runs. Our OpenTelemetry article covers the trace context needed to investigate those runs.

A worked example: account for the missing $60

Suppose a monthly report covers $1,000 of Bedrock inference charges. All amounts in this example are invented to show the reconciliation method.

GroupAllocated costFollow-up
Customer support$420Owner confirms the ticket-assistant workload
Finance$280Owner confirms the document-review workload
Engineering$240Split testing from production before chargeback
Unallocated$60Investigate calls without the expected ownership tags
Total$1,000Matches the report’s defined cost scope

The allocated teams account for $940. That leaves $60 to investigate, rather than silently assigning it to engineering.

Check direct model calls, older client settings, missing tag activation and shared-role traffic. Then rerun the same report for the same period. Record any remaining gap and who owns it.

If tracing estimates a different amount, don’t force it to match. Check model rates, caching, discounts, usage categories and data timing. State which figure is billed cost and which is a calculated estimate.

Check the setup before charging teams

Run the reporting process with the people who will use it. A finance analyst should be able to reproduce a team total without asking an engineer to explain every row.

Test a second team, a model change and a call that bypasses the expected profile. Keep the bypass visible in the report. If every cost still lands in one group, the setup hasn’t proved team allocation.

Finally, separate cost ownership from spending control. A tagged profile or cost report doesn’t stop another request. Assign an owner for alerts and test any proposed enforcement separately.

If this work accompanies a provider change, add the reporting checks to your Bedrock migration acceptance plan. Agree on the cost boundary before comparing the old and new application.

ASCENDING Inc maintains the open source Jarvis project. Our Claude-on-Bedrock governance offering includes cost attribution as part of deployment planning. Bring the APIs, identity path and billing view you need to reconcile.

References

Bedrock cost allocation questions

How do I track Amazon Bedrock costs by team?

Choose an attribution method that matches your API. Tag IAM roles or sessions for team ownership, use application inference profiles with InvokeModel or Converse, or use Projects for supported bedrock-mantle workloads. Activate the relevant cost allocation tags, then verify the team totals in AWS Cost Explorer or CUR.

Can one application inference profile track several models?

An application inference profile is model-specific. A cross-Region profile can route requests for that model across Regions, but it isn't a bucket for unrelated models. Keep a profile inventory as teams add models and versions.

Why aren't my Bedrock tags showing in Cost Explorer?

Check that calls used the tagged resource, the tag keys were activated for cost allocation, and enough time has passed for billing data to update. In an AWS Organization, activation is managed from the payer account. A resource tag alone doesn't establish that the spend is correctly attributed.

Does Cost Explorer show the cost of each AI prompt?

No. Billing-based methods produce aggregated costs. For supported APIs, model invocation logs and request metadata can show individual calls and token counts. A cost calculated from those tokens is an estimate that should be reconciled with billing totals.

Kelvin Yu portrait

About the author

Kelvin Yu

Contributing Writer · AWS Agents

Covers AWS-native agent infrastructure: Bedrock, AgentCore Runtime, and the deployment patterns that survive enterprise security review.

Keep reading