Checking Claude Platform on AWS Costs and Usage from Both AWS Billing and the Claude Console

Claude Platform on AWS became generally available (GA) on May 11, 2026. Usage charges are integrated into AWS billing, but when I actually checked the CUR, costs were aggregated per CCU, and I couldn't see a breakdown by model or token type.

This article summarizes how costs appear in AWS Cost Explorer, the CUR, and the Claude Console, based on cross-checking them against each other.

Note that the content of this article is based on results confirmed in the author's environment.

Previous articles:

https://dev.classmethod.jp/articles/claude-platform-on-aws-bedrock-differences/

https://dev.classmethod.jp/articles/claude-platform-on-aws-ga-setup/

How It Appears in Cost Explorer

First, I checked how Claude Platform on AWS usage charges are displayed in AWS Cost Explorer.

Conditions checked:

• Date Range: 2026-05-07 to 2026-05-13
• Granularity: Daily
• Group by: Service
• Filters: None
• Cost metric: Unblended cost

"Claude Platform" is displayed independently as a service name. When grouped by Service, it appears at the same granularity as other AWS services.

Displayed results:

• Claude Platform: $0.29 (5/13)
• Tax: $0.03 (5/12)
• Total: $0.32

The * mark on a date indicates an estimated value.

Note that the dates displayed in Cost Explorer may be affected by the usage date, the billing recording timing, and the reflection timing. In this article, they are treated as the displayed results at the time of checking.

Checking the CUR (Cost and Usage Report)

CUR Report Settings

The CUR I checked has the following settings.

• Format: Parquet
• TimeUnit: DAILY
• AdditionalSchemaElements: RESOURCES
• AdditionalArtifacts: ATHENA

Claude Platform CUR Records

I extracted the Claude Platform records from the CUR. Here are excerpts of the main columns.

{
  "bill_billing_entity": "AWS Marketplace",
  "line_item_line_item_type": "Usage",
  "line_item_product_code": "esti5tvyutkn1ray5q4banb5x",
  "line_item_usage_type": "MP:ccu-Units",
  "line_item_operation": "Usage",
  "line_item_usage_amount": 29.0,
  "line_item_unblended_rate": "0.0100000000",
  "line_item_unblended_cost": 0.29,
  "line_item_resource_id": "arn:aws:aws-external-anthropic:us-east-1:123456789012:workspace/wrkspc_xxx",
  "line_item_legal_entity": "Anthropic Claude for Enterprise",
  "product_product_name": "Claude Platform",
  "product_region": "us-east-1",
  "pricing_term": "OnDemand",
  "pricing_unit": "Units"
}

The actual CUR has many more columns, but only the main ones are excerpted here because the rest include account information and the like.

Explanation of the main fields:

The Product Code and ARN format may change depending on the time of checking, the contract channel, the region, and so on. In this article, they are presented as values confirmed in the author's environment.

The CUR also contained a Tax record. In the author's environment, the tax type was CT (Consumption Tax), and $0.03 was confirmed as the tax amount related to the Marketplace usage charge for Claude Platform.

What You Can and Cannot Tell from the CUR

What you can tell:

• Total CCU count and amount
• Workspace ID (resource-level tracking)
• Usage date and period (daily granularity with this CUR's settings)
• That it is billed via Marketplace

What you cannot tell:

What I found especially important in this check was that the following information could not be confirmed from the CUR alone.

• Which model (Sonnet / Opus) was used
• How many input and output tokens were consumed respectively
• Per-service breakdowns such as web search, Code Execution, and session runtime
• Cache usage

In other words, within the scope of this check, the Claude Platform Usage record was aggregated into a single row: "29 CCU = $0.29". If you want to allocate costs by model or by project, the CUR I checked is not sufficient on its own.

With the Bedrock version, CUR records are split per token type, so at least cost analysis per token type is easy to do with the CUR alone (see the Bedrock comparison below).

How to Check the CUR

The CUR 2.0 I used supports Athena integration, but since there were few target records, I downloaded the Parquet files from S3 and checked them locally. For ongoing analysis, consider using Athena or similar.

aws s3 cp s3://your-cur-bucket/cur-reports/your-report/your-report/year=2026/month=5/ /tmp/cur/ --recursive

import pandas as pd
import glob

files = glob.glob('/tmp/cur/**/*.parquet', recursive=True)

if not files:
    raise RuntimeError('Parquet files were not found under /tmp/cur')

df = pd.concat([pd.read_parquet(f) for f in files], ignore_index=True)

# Extract Claude Platform records
claude = df[df['product_product_name'].eq('Claude Platform')]
print(f'Claude Platform レコード数: {len(claude)}')

# Display only columns that have values (excluding empty and 0)
for i, row in claude.iterrows():
    print('---')
    for col in claude.columns:
        val = row[col]
        if pd.notna(val) and val != '' and val != 0:
            print(f'  {col}: {val}')

Checking in the Claude Console

We found that the model-level breakdown cannot be confirmed from the CUR alone. So let's see how much is visible on the Claude Console (Claude admin screen) side.

Cost Dashboard

On the Claude Console "Analytics > Cost" screen, I could confirm the following.

• Total token cost: 29 CCUs / $0.29
• Total web search cost: 1 CCU / $0.01
• Total code execution cost: 0 CCUs / $0.00
• Total session runtime cost: 0 CCUs / $0.00

In the daily token cost graph, a stacked bar for 5/13 shows Sonnet 4.6 (pink) / Opus 4.7 (light purple) / Opus 4.6 (green). The 29 CCU that was aggregated into one row in the CUR can be seen here by model.

Usage Dashboard

On the "Analytics > Usage" screen, I could confirm detailed token counts.

• Total input tokens: 48,659
• Total output tokens: 4,923
• Total web searches: 1

CSV Download

Two types of CSV can be downloaded from the Claude Console.

① Cost CSV (claude_api_cost)

It records cost (USD) and token counts by model and by day (the table shows only the main columns).

② Token CSV (claude_api_tokens)

It records a breakdown by token type (input / cache write 5 min and 1 hour / cache read / output).

From the perspective of token types, you can obtain information at a granularity close to the Bedrock CUR. On the other hand, you cannot perform analysis along the AWS billing axis that links to resource information such as the Workspace ARN, as you can with the CUR.

The dates in the CSV downloaded from the Claude Console are usage_date_utc. When cross-checking against the display periods in AWS Cost Explorer or the CUR, be careful about the UTC/JST difference.

Cross-Checking the AWS Side and the Claude Side

I cross-checked against the CSVs to see which Claude-side usage the CUR's "29 CCU = $0.29" corresponds to.

Amount Cross-Check

The handling of web search is especially noteworthy. It could be confirmed as 1 CCU ($0.01) in the Claude Console, but no corresponding record was found in the CUR at the time of checking.

Because there is a delay in how CUR / Cost Explorer reflect data, it may be reflected later. This article describes the results at the time of checking.

The token total of $0.2873 in the cost CSV was displayed as 29 CCU ($0.29) on the dashboard. The difference of $0.0027 is thought to be due to display and rounding in CCU units.

Comparison Table

Comparison with the Bedrock Version

I compare this with the CUR from when the author used Claude Sonnet 4.6 via Bedrock in February 2026. The Bedrock version is an example of use in the Tokyo region (ap-northeast-1). Model unit prices and Usage Types are those at the time of checking.

While Claude Platform on AWS was aggregated per CCU within the scope of this check, the Bedrock version had Usage Types split per token type:

Comparison summary:

In addition, on the Bedrock side, features that increase analysis granularity in the CUR have been expanded, such as cost allocation by IAM principal (April 2026).

Application of AWS Credits

In the CUR I checked, Credit records were applied only to services with bill_billing_entity: AWS, and were not applied to Claude Platform, which has bill_billing_entity: AWS Marketplace.

Summary

The cost of Claude Platform on AWS can be seen in Cost Explorer under the service name "Claude Platform", and it was recorded as MP:ccu-Units in the CUR. On the other hand, the CUR I checked did not let me confirm a breakdown by model or token type.

The total billed amount is managed on the AWS side, and the cost breakdown by model and token is checked on the Claude Console side.

References

• Claude Platform on AWS is now GA. I tried the setup and API calls - DevelopersIO
• Claude Platform on AWS was announced, so I organized the differences from Bedrock - DevelopersIO
• AWS Cost and Usage Reports - AWS official
• Claude Platform on AWS - Official documentation
• Amazon Bedrock now supports cost allocation by IAM users and roles - AWS