AWS Billing and Cost Management

AWS Billing and Cost Management MCP Server

Billing and cost management.

What is an MCP Server?⁠

MCP Info

Image Building Info

Attribute	Details
Dockerfile	https://github.com/awslabs/mcp/blob/636aca8e109b5559006044f035bb89c16e9e5410/src/billing-cost-management-mcp-server/Dockerfile⁠
Commit	636aca8e109b5559006044f035bb89c16e9e5410
Docker Image built by	Docker Inc.
Docker Scout Health Score
Verify Signature	COSIGN_REPOSITORY=mcp/signatures cosign verify mcp/billing-cost-management-mcp-server --key https://raw.githubusercontent.com/docker/keyring/refs/heads/main/public/mcp/latest.pub
Licence	Apache License 2.0

Available Tools (33)

Tools Details

Tool: aws-pricing

Comprehensive AWS pricing analysis tool that provides access to AWS service pricing information and cost analysis capabilities.

This tool supports four main operations:

1. get_service_codes: Get a comprehensive list of AWS service codes from the AWS Price List API
2. get_service_attributes: Get filterable attributes for a specific AWS service's pricing
3. get_attribute_values: Get all valid values for a specific attribute of an AWS service
4. get_pricing_from_api: Get detailed pricing information from AWS Price List API with optional filters

USE THE OPERATIONS IN THIS ORDER:

1. get_service_codes: Entry point - discover available AWS services and their unique service codes. Note that service codes may not match your expectations, so it's best to get service codes first.
2. get_service_attributes: Second step - understand which dimensions affect pricing for a chosen service
3. get_attribute_values: Third step - get possible values you can use in pricing filters
4. get_pricing_from_api: Final step - retrieve actual pricing data based on service and filters If you deviate from this order of operations, you will struggle to form the correct filters, and you will not get results from the API

IMPORTANT GUIDELINES:

• When retrieving foundation model pricing, always use the latest models for comparison
• For database compatibility with services, only include confirmed supported databases
• Providing less information is better than giving incorrect information
• Price list APIs can return large data volumes. Use narrower filters to retrieve less data when possible
• Service codes often differ from AWS console names (e.g., 'AmazonES' for OpenSearch) Parameters|Type|Description -|-|- operation|string|The pricing operation to perform ('get_service_codes', 'get_service_attributes', 'get_attribute_values', 'get_pricing_from_api') attribute_name|stringoptional|Attribute name (e.g., 'instanceType', 'location', 'storageClass'). Required for get_attribute_values operation. filters|stringoptional|Optional filters for pricing queries as a JSON string. Format: '{"instanceType": "t3.medium", "location": "US East (N. Virginia)"}' max_results|stringoptional|Maximum number of results to return (optional) service_code|stringoptional|AWS service code (e.g., 'AmazonEC2', 'AmazonS3', 'AmazonES'). Required for get_service_attributes, get_attribute_values, and get_pricing_from_api operations.

Tool: bcm-pricing-calc

Allows working with workload estimates using the AWS Billing and Cost Management Pricing Calculator API.

IMPORTANT USAGE GUIDELINES:

• Always first check the rate preference setting for the authorized principal by calling the get_preferences operation.
• DO NOT state assumptions about Free Tier API

USE THIS TOOL FOR:

• Listing available workload estimates for the logged in account.
• Filter list of available workload estimates using name, status, created date, or expiration date.
• Get details of a workload estimate.
• Get the list of services, usage type, operation, and usage amount modeled within a workload estimate.
• Get rate preferences set for Pricing Calculator. These rate preferences denote what rate preferences can be used by each account type in your organization.

OPERATIONS

1. list_workload_estimates - list of available workload estimates Required: operation="list_workload_estimates" Optional: created_after, created_before, expires_after, expires_before, status_filter, name_filter, name_match_option, next_token, max_results Returns: List of all workload estimates for the account.

2. get_workload_estimate - get details of a workload estimate Required: operation="get_workload_estimate", identifier Returns: Details of a specific workload estimate.

3. list_workload_estimate_usage - list of modeled usage lines within a workload estimate Required: operation="get_workload_estimate", identifier Optional: usage_account_id_filter, service_code_filter, usage_type_filter, operation_filter, location_filter, usage_group_filter, next_token, max_results Returns: List of usage associated with a workload estimate.

4. get_preferences - get the rate preferences available to an account Required: operation="get_preferences" Returns: Retrieves the current preferences for AWS Billing and Cost Management Pricing Calculator. Parameters|Type|Description -|-|- operation|string| created_after|stringoptional| created_before|stringoptional| expires_after|stringoptional| expires_before|stringoptional| identifier|stringoptional| location_filter|stringoptional| max_pages|stringoptional| max_results|stringoptional| name_filter|stringoptional| name_match_option|stringoptional| next_token|stringoptional| operation_filter|stringoptional| service_code_filter|stringoptional| status_filter|stringoptional| usage_account_id_filter|stringoptional| usage_group_filter|stringoptional| usage_type_filter|stringoptional|

Tool: budgets

Retrieves AWS budget information using the AWS Budgets API.

This tool uses the DescribeBudgets API to retrieve all budgets for an account.

The API returns information about:

• Budget names, types, and time periods
• Budget limits (amount and unit)
• Current actual spend
• Forecasted spend
• Cost filters applied to budgets

With this information, you can determine which budgets have been exceeded or are projected to exceed their limits.

The tool automatically retrieves the AWS account ID of the calling identity or uses the provided account_id.

Tool: compute-optimizer

Retrieves recommendations from AWS Compute Optimizer.

IMPORTANT USAGE GUIDELINES:

• Focus on recommendations with the highest estimated savings first
• Include all relevant details when presenting specific recommendations

USE THIS TOOL FOR:

• Performance optimization (CPU, memory, network utilization analysis)
• Performance-based rightsizing (not cost-based)

DO NOT USE FOR: Cost optimization or idle detection (use cost-optimization-hub)

Note: Compute Optimizer is a regional service. Specify a region to get recommendations for resources in that region. If omitted, defaults to AWS_REGION env var or us-east-1.

This tool supports the following operations:

1. get_ec2_instance_recommendations: Get recommendations for EC2 instances
2. get_auto_scaling_group_recommendations: Get recommendations for Auto Scaling groups
3. get_ebs_volume_recommendations: Get recommendations for EBS volumes
4. get_lambda_function_recommendations: Get recommendations for Lambda functions
5. get_rds_recommendations: Get recommendations for RDS instances
6. get_ecs_service_recommendations: Get recommendations for ECS services

Each operation can be filtered by AWS account IDs, regions, finding types, and more.

Common finding types include:

• UNDERPROVISIONED: The resource doesn't have enough capacity
• OVERPROVISIONED: The resource has excess capacity and could be downsized
• OPTIMIZED: The resource is already optimized
• NOT_OPTIMIZED: The resource can be optimized but specific finding type isn't available Parameters|Type|Description -|-|- operation|string|The operation to perform (e.g., 'get_ec2_instance_recommendations') account_ids|stringoptional|Optional list of AWS account IDs as JSON array string filters|stringoptional|Optional filter expression as JSON string max_results|stringoptional|Maximum number of results to return (1-100) next_token|stringoptional|Optional pagination token from a previous response region|stringoptional|AWS region to query (e.g., 'us-west-2'). Defaults to AWS_REGION env var or us-east-1.

Tool: cost-anomaly

Retrieves AWS cost anomalies using the Cost Explorer GetAnomalies API.

This tool allows you to retrieve cost anomalies detected on your AWS account during a specified time period. Anomalies are available for up to 90 days.

You can filter anomalies by:

• Date range (required)
• Monitor ARN (optional)
• Feedback status (optional)
• Total impact (optional)

Note: Both start_date and end_date are INCLUSIVE. To get anomalies including today, use today's date as end_date.

Feedback status options:

• YES: Anomalies marked as accurate
• NO: Anomalies marked as inaccurate
• PLANNED_ACTIVITY: Anomalies marked as planned activities Parameters|Type|Description -|-|- end_date|string|End date in YYYY-MM-DD format (inclusive — use today's date to include today's anomalies). Required. start_date|string|Start date in YYYY-MM-DD format (inclusive). Required. feedback|stringoptional|Optional filter for anomalies by feedback status (YES, NO, PLANNED_ACTIVITY). max_results|stringoptional|Optional maximum number of results to return. monitor_arn|stringoptional|Optional ARN of a specific cost anomaly monitor to filter results. total_impact_end|stringoptional|Optional end value for total impact filter (required when using BETWEEN operator). total_impact_operator|stringoptional|Optional numeric operator for filtering by total impact (EQUAL, GREATER_THAN, LESS_THAN, GREATER_THAN_OR_EQUAL, LESS_THAN_OR_EQUAL, BETWEEN). total_impact_start|stringoptional|Optional start value for total impact filter.

Tool: cost-comparison

Retrieves AWS cost comparisons between two one-month periods.

Do not use this tool except for comparing the costs of one month to the costs of another month. This tool should not be used for week-over-week or quarter-over-quarter (e.g., comparing Q2 vs. Q1) analysis.

USE THIS TOOL ONLY FOR:

• Month-to-month cost variance analysis (e.g., January vs February)
• Root cause analysis of cost changes between specific months
• Detailed cost driver identification (what exactly caused the cost change)
• Service-level impact analysis for month-over-month changes
• Executive reporting on monthly cost variances

STRICT LIMITATIONS:

• ONLY compares exactly one month to another month
• Both periods must start on 1st day of month, end on 1st day of next month
• Cannot compare weeks, quarters, or custom periods
• DO NOT USE for general cost analysis or flexible time periods

This tool supports two main operations:

1. getCostAndUsageComparisons: Compare costs between two time periods with flexible grouping and filtering
2. getCostComparisonDrivers: Identify key factors driving cost changes between two time periods

Both operations require:

• BaselineTimePeriod: Earlier time period for comparison (must be exactly one month)
• ComparisonTimePeriod: Later time period for comparison (must be exactly one month)
• MetricForComparison: The cost metric to compare (e.g., BlendedCost, UnblendedCost)

Supported metrics for comparison include:

• AmortizedCost: Costs with upfront and recurring reservation fees spread across the period
• BlendedCost: Average cost of all usage throughout the billing period
• NetAmortizedCost: Amortized cost after discounts
• NetUnblendedCost: Unblended cost after discounts
• NormalizedUsageAmount: Normalized usage amount
• UnblendedCost: Actual costs incurred during the specified period
• UsageQuantity: Usage amounts in their respective units

You can group results by dimensions such as:

• SERVICE: AWS service (e.g., Amazon EC2, Amazon S3)
• LINKED_ACCOUNT: Member accounts in an organization
• REGION: AWS Region
• USAGE_TYPE: Type of usage (e.g., BoxUsage:t2.micro)
• INSTANCE_TYPE: EC2 instance type (e.g., t2.micro, m5.large)
• PLATFORM: Operating system (e.g., Windows, Linux)
• TENANCY: Instance tenancy (e.g., shared, dedicated)
• RECORD_TYPE: Record type (e.g., Usage, Credit, Tax)
• LEGAL_ENTITY_NAME: AWS seller of record

Note:

• Time periods must start and end on the first day of a month, with a duration of exactly one month
• The getCostComparisonDrivers operation automatically includes SERVICE and USAGE_TYPE dimensions
• Data is available for the last 13 months, or up to 38 months if multi-year data is enabled Parameters|Type|Description -|-|- baseline_end_date|string|Baseline period end date in YYYY-MM-DD format (must be first day of next month) baseline_start_date|string|Baseline period start date in YYYY-MM-DD format (must be first day of month) comparison_end_date|string|Comparison period end date in YYYY-MM-DD format (must be first day of next month) comparison_start_date|string|Comparison period start date in YYYY-MM-DD format (must be first day of month) metric_for_comparison|string|The cost metric to compare (e.g., BlendedCost, UnblendedCost, AmortizedCost) operation|string|The operation to perform: 'getCostAndUsageComparisons' or 'getCostComparisonDrivers' billing_view_arn|stringoptional|Optional ARN of a specific billing view filter|stringoptional|Optional filter to apply to the results as a JSON string group_by|stringoptional|Optional grouping of results as a JSON string (e.g., '[{"Type": "DIMENSION", "Key": "SERVICE"}]') max_results|stringoptional|Maximum number of results to return (default: 10, max: 2000 for comparisons, max: 10 for drivers)

Tool: cost-explorer

Retrieves AWS cost and usage data using the Cost Explorer API.

IMPORTANT USAGE GUIDELINES:

• Use UnblendedCost metric by default (not BlendedCost) unless user specifies otherwise
• Exclude record_types 'Credit' and 'Refund' by default unless user requests inclusion
• Choose DAILY granularity for periods <3 months, MONTHLY for longer periods
• Start with high-level dimensions (SERVICE, LINKED_ACCOUNT) before detailed ones
• Always remember that the end_date is exclusive

USE THIS TOOL FOR:

• Historical cost trends and spending analysis (any time period)
• Usage pattern analysis over time
• Cost breakdown by service, account, region, or any dimension
• Forecasting future costs and usage
• Resource-level cost analysis (last 14 days)
• Multi-dimensional cost analysis with complex grouping

OPERATIONS

1. getCostAndUsage — account-level historical cost/usage Required: operation="getCostAndUsage", start_date, end_date, granularity, metrics Optional: group_by, filter, next_token, max_pages, billing_view_arn Example: {"operation": "getCostAndUsage", "start_date": "2024-01-01", "end_date": "2024-02-01", "granularity": "DAILY", "metrics": ["UnblendedCost"], "group_by": "[{"Type": "DIMENSION", "Key": "SERVICE"}]"}

1. getCostAndUsageWithResources - Resource-level cost data (limited to last 14 days) Required: operation="getCostAndUsageWithResources", filter, granularity, start_date, end_date Optional: metrics, group_by, next_token, max_pages, billing_view_arn Notes: RESOURCE_ID must be included in either filter OR group_by parameters. This operation is limited to past 14 days of data from current date. Hourly granularity is only available for EC2-Instances resource-level data. All other resource-level data is available at daily granularity. Example: {"operation": "getCostAndUsageWithResources", "start_date": "2025-08-07", "end_date": "2025-08-21", "granularity": "DAILY", "filter": "{"Dimensions": {"Key": "SERVICE", "Values": ["Amazon Elastic Compute Cloud - Compute"]}}", "group_by": "[{"Type": "DIMENSION", "Key": "RESOURCE_ID"}]"} Returns: Cost data with resource-level granularity

2. getDimensionValues - List of available values for specified dimension Required: operation="getDimensionValues", dimension, start_date, end_date Optional: context, search_string, filter, max_results, billing_view_arn Example: {"operation": "getDimensionValues", "dimension": "SERVICE", "start_date": "2024-01-01", "end_date": "2024-02-01"} Returns: List of values for specified dimension with automatic pagination

3. getCostForecast - Future cost projections Required: operation="getCostForecast", metric, granularity, start_date, end_date Optional: filter, prediction_interval_level, billing_view_arn Example: {"operation": "getCostForecast", "metric": "UNBLENDED_COST", "granularity": "MONTHLY", "start_date": "2025-08-22", "end_date": "2025-11-22"} Notes: metric value for this operation should be in all caps Returns: Cost forecast for specified time period and granularity

4. getUsageForecast - Future usage projections Required: operation="getUsageForecast", metric, granularity, start_date, end_date, filter Optional: prediction_interval_level, billing_view_arn Example 1: {"operation": "getUsageForecast", "metric": "USAGE_QUANTITY", "granularity": "MONTHLY", "start_date": "2025-08-22", "end_date": "2025-11-22", "filter": "{"Dimensions": {"Key": "USAGE_TYPE_GROUP", "Values": ["EC2-Instance"]}}"} Example 2: {"operation": "getUsageForecast", "metric": "USAGE_QUANTITY", "granularity": "MONTHLY", "start_date": "2025-08-22", "end_date": "2025-11-22", "filter": "{"And": [{"Dimensions": {"Key": "SERVICE", "Values": ["Amazon Elastic Compute Cloud - Compute"]}}, {"Dimensions": {"Key": "USAGE_TYPE", "Values": ["BoxUsage:p4de.24xlarge"]}}]}"} Example 3: {"operation": "getUsageForecast", "metric": "USAGE_QUANTITY", "granularity": "MONTHLY", "start_date": "2025-08-22", "end_date": "2025-11-22", "filter": "{"Dimensions": {"Key": "USAGE_TYPE", "Values": ["BoxUsage:p4de.24xlarge", "Reservation:p4de.24xlarge", "UnusedBox:p4de.24xlarge"]}}", "group_by": "[{"Type": "DIMENSION", "Key": "REGION"}]"} Notes: Valid values for metric is: USAGE_QUANTITY, NORMALIZED_USAGE_AMOUNT. Valid values for granularity is: DAILY, MONTHLY. Filter is REQUIRED and must specify USAGE_TYPE or USAGE_TYPE_GROUP to define what usage units to forecast. Returns: Usage forecast for specified time period and granularity

5. getTagsOrValues - Available cost allocation tags or values Required: operation="getTagsOrValues" Optional: start_date, end_date, search_string, next_token, max_pages, billing_view_arn Example 1: {"operation": "getTagsOrValues"} Example 2: {"operation": "getTagsOrValues", "tag_key": "Environment"} Returns: List of available cost allocation tags with automatic pagination. If tag values for a particular key are needed, pass the tag key as a parameter.

6. getCostCategories - Available cost categories or values inside a category Required: operation="getCostCategories", start_date, end_date Optional: cost_category_name, search_string, next_token, max_pages, billing_view_arn Example 1 (list category names): {"operation": "getCostCategories", "start_date": "2024-01-01", "end_date": "2024-08-01"} Example 2 (list values inside a category): {"operation": "getCostCategories", "cost_category_name": "CostCenters", "start_date": "2024-01-01", "end_date": "2024-08-01"} Notes: Without cost_category_name the response contains CostCategoryNames. With cost_category_name set the response contains CostCategoryValues for that category. Pagination is automatic.

7. getSavingsPlansUtilization - Savings Plans utilization data Required: operation="getSavingsPlansUtilization", start_date, end_date Optional: granularity, filter Example: {"operation": "getSavingsPlansUtilization", "granularity": "MONTHLY"} Notes: This operation supports only DAILY and MONTHLY granularity Returns: Savings Plans utilization for the specified time period

DIMENSION REFERENCE:

• AZ: The Availability Zone (e.g., us-east-1a)
• DATABASE_ENGINE: The Amazon RDS database (e.g., Aurora, MySQL)
• DEPLOYMENT_OPTION: RDS deployment scope (SingleAZ, MultiAZ)
• INSTANCE_TYPE: The EC2 instance type (e.g., m4.xlarge)
• INSTANCE_TYPE_FAMILY: Family of instances (e.g., Compute Optimized, Memory Optimized)
• LINKED_ACCOUNT: AWS member accounts
• OPERATING_SYSTEM: OS type (e.g., Windows, Linux)
• PLATFORM: EC2 operating system
• PURCHASE_TYPE: Reservation type (e.g., On-Demand, Reserved)
• REGION: AWS Region
• SERVICE: AWS service (e.g., Amazon DynamoDB)
• TAG: Cost allocation tag
• TENANCY: EC2 tenancy (shared, dedicated)
• USAGE_TYPE: Usage type (e.g., DataTransfer-In-Bytes)
• RECORD_TYPE: Charge types (e.g., RI fees, usage costs)

BILLING VIEW SUPPORT: Most Cost Explorer operations support an optional billing_view_arn parameter that allows you to scope your query to a specific billing view. If not provided, the query defaults to the account's primary billing view. You can use the list-billing-views and get-billing-view tools upon request to discover available billing views and their ARNs.

Billing view types:

• PRIMARY: Default view with all cost data for the account/org. Use for standard cost analysis.
• BILLING_GROUP: AWS managed view for Billing Conductor billing groups with pro forma cost data.
• CUSTOM: Customer-created views with filtered cost data that can be shared across accounts and organizations. Use for business-unit, team, or cross-org cost visibility without management account access.
• BILLING_TRANSFER: Available to Bill Transfer (bill receiver) account, who is responsible for paying the consolidated bill on behalf of the other organization. AWS managed view containing chargeable data, which is what the Bill Transfer (bill receiver) account owes to AWS for their Bill Source accounts' cloud consumption.
• BILLING_TRANSFER_SHOWBACK: Available to Bill Transfer (bill receiver) account. AWS managed view showing pro forma showback/chargeback data (what Bill Source account owe their partner). Use for showback/chargeback reporting in billing transfer scenarios. Parameters|Type|Description -|-|- operation|string|The operation to perform billing_view_arn|stringoptional|Optional ARN of a billing view to scope the query cost_category_name|stringoptional|Cost category to get values for dimension|stringoptional|Dimension to get values for (getDimensionValues) end_date|stringoptional|End date for cost data in YYYY-MM-DD format (exclusive) filter|stringoptional|Filter to apply to the results granularity|stringoptional|Granularity of the returned data (DAILY, MONTHLY, etc.) group_by|stringoptional|How to group the results max_pages|stringoptional|Maximum number of pages to retrieve max_results|stringoptional|Maximum number of results to return metric|stringoptional|Metric for cost forecasts metrics|stringoptional|Metrics to include in the response next_token|stringoptional|Pagination token prediction_interval_level|integeroptional|Confidence level for forecasts search_string|stringoptional|Search string to filter dimension values start_date|stringoptional|Start date for cost data in YYYY-MM-DD format tag_key|stringoptional|Tag key to get values for

Tool: cost-optimization

Retrieves cost optimization recommendations from AWS Cost Optimization Hub.

IMPORTANT USAGE GUIDELINES:

• Focus on recommendations with the highest estimated savings first
• Include all relevant details when presenting specific recommendations

USE THIS TOOL FOR:

• Idle/unused resource detection (EC2, RDS, EBS, Lambda, etc.)
• Cost savings recommendations (rightsizing, stopping, deleting resources)
• Reserved Instance and Savings Plans purchase recommendations
• Cross-service cost optimization analysis
• Monthly cost reduction opportunities

DO NOT USE FOR: Performance optimization (use compute-optimizer)

Supported Operations:

1. list_recommendation_summaries: High-level overview of savings opportunities grouped by a dimension
2. list_recommendations: Detailed list of specific recommendations
3. get_recommendation: Get detailed information about a specific recommendation

IMPORTANT: 'list_recommendation_summaries' operation REQUIRES a 'group_by' parameter. Valid 'group_by' values: AccountId, Region, ActionType, ResourceType, RestartNeeded, RollbackPossible, ImplementationEffort

CRITICAL PARAMETER REQUIREMENTS:

• 'filters' parameter must be passed as JSON string format
• 'max_results' must be integer (not string)
• 'get_recommendation' requires both 'resource_id' AND 'resource_type' parameters
• Service only available in us-east-1 region

Available Filter Parameters (pass as JSON string):

• resourceTypes: ['Ec2Instance', 'LambdaFunction', 'EbsVolume', 'EcsService', 'Ec2AutoScalingGroup', 'Ec2InstanceSavingsPlans', 'ComputeSavingsPlans', 'SageMakerSavingsPlans', 'Ec2ReservedInstances', 'RdsReservedInstances', 'OpenSearchReservedInstances', 'RedshiftReservedInstances', 'ElastiCacheReservedInstances', 'RdsDbInstanceStorage', 'RdsDbInstance', 'DynamoDbReservedCapacity', 'MemoryDbReservedInstances']
• actionTypes: ['Rightsize', 'Stop', 'Upgrade', 'PurchaseSavingsPlans', 'PurchaseReservedInstances', 'MigrateToGraviton', 'Delete', 'ScaleIn']
• implementationEfforts: ['VeryLow', 'Low', 'Medium', 'High', 'VeryHigh']
• regions: AWS region codes (e.g., ["us-east-1", "us-west-2"])
• accountIds: List of AWS account IDs
• restartNeeded: boolean
• rollbackPossible: boolean

Cost Optimization Hub provides recommendations across multiple AWS services, including:

• EC2 instances (right-sizing, Graviton migration)
• EBS volumes (unused volumes, IOPS optimization)
• RDS instances (right-sizing, engine optimization)
• Lambda functions (memory size optimization)
• SP/RI
• And more

Each recommendation includes:

• The resource ARN and ID
• The estimated monthly savings
• The current state of the resource
• The recommended state of the resource Parameters|Type|Description -|-|- operation|string|The operation to perform ('list_recommendations', 'get_recommendation', or 'list_recommendation_summaries') filters|stringoptional|Optional filter expression as JSON string group_by|stringoptional|Optional grouping parameter for list_recommendation_summaries include_all_recommendations|stringoptional|Whether to include all recommendations max_results|stringoptional|Maximum total results to return across all pages; None means all available results resource_id|stringoptional|Resource ID for get_recommendation operation resource_type|stringoptional|Resource type for get_recommendation operation

Tool: describe-cost-category-definition

Returns the full definition of a cost category using the DescribeCostCategoryDefinition API.

Cost categories group AWS costs using rule-based expressions that match line items by dimensions (SERVICE, LINKED_ACCOUNT, USAGE_TYPE), resource tags, or other cost category values. Each matched line item is assigned a category value such as "Production" or "Development". Rules can be REGULAR (explicit match) or INHERITED_VALUE (dynamic value from a tag key or account name). A DefaultValue catches costs that do not match any rule.

The tool returns a CostCategory object containing:

• Name (1-50 chars, unique per account, case-sensitive), CostCategoryArn
• RuleVersion (always "CostCategoryExpression.v1")
• Rules array with Value, Rule expression (Dimensions/Tags/CostCategories with And/Or/Not), and Type
• DefaultValue, SplitChargeRules (PROPORTIONAL, FIXED, or EVEN allocation methods)
• EffectiveStart/EffectiveEnd (null if still active)
• ProcessingStatus: APPLIED (rules reflected in data) or PROCESSING (backfill in progress)

Linked accounts can describe cost categories from their management account.

Required parameters:

• cost_category_arn: ARN of the cost category (arn:aws:ce::<account_id>:costcategory/). Use list-cost-category-definitions to discover ARNs.

Optional parameters:

• effective_on: ISO 8601 datetime (e.g., 2024-01-01T00:00:00Z) to retrieve the version active at that time. Defaults to the current version.

Example 1 - Get current definition: {"cost_category_arn": "arn:aws:ce::123456789012:costcategory/abcd-1234"} Example 2 - Get historical version: {"cost_category_arn": "arn:aws:ce::123456789012:costcategory/abcd-1234", "effective_on": "2024-06-01T00:00:00Z"}

Tool: free-tier-usage

Retrieves AWS Free Tier usage information using the Free Tier Usage API.

This tool provides insights into your AWS Free Tier usage across services:

1. get_free_tier_usage: Shows your current Free Tier usage across AWS services
   • Helps identify where you are approaching Free Tier limits
   • Shows actual usage against Free Tier allocations
   • Supports filtering by service, region, or usage type
   • Possible Dimensions values are: 'SERVICE'|'OPERATION'|'USAGE_TYPE'|'REGION'|'FREE_TIER_TYPE'|'DESCRIPTION'|'USAGE_PERCENTAGE'
   • Possible MatchOptions are: 'EQUALS'|'STARTS_WITH'|'ENDS_WITH'|'CONTAINS'|'GREATER_THAN_OR_EQUAL' Parameters|Type|Description -|-|- filter|stringoptional|Optional filter to apply to the results as a JSON string. max_results|stringoptional|Maximum number of results to return per page (1-1000). Defaults to 100. operation|stringoptional|The operation to perform: 'get_free_tier_usage'

Tool: get-billing-group-cost-report

Retrieves the margin summary report for a specific billing group, which includes the AWS cost and charged amount (pro forma cost) broken down by attributes such as AWS service name or billing period.

This tool retrieve detailed cost reports for a single billing group, optionally broken down by product name and/or billing period.

The tool returns margin summary report results for the billing group:

• Billing group ARN
• Attributes (key-value pairs for grouping, e.g., PRODUCT_NAME: "S3", BILLING_PERIOD: "Nov 2023")
• AWS cost (actual AWS charges)
• Proforma cost (hypothetical charges based on the associated pricing plan)
• Margin (billing group margin)
• Margin percentage (percentage of billing group margin)
• Currency (displayed currency)

You can customize the report by:

• BillingPeriodRange: JSON string specifying a time range (up to 12 months)
• GroupBy: JSON array string with values "PRODUCT_NAME" and/or "BILLING_PERIOD"

Example 1: {"arn": "arn:aws:billingconductor::123456789012:billinggroup/abc", "group_by": "["PRODUCT_NAME"]"} Example 2: {"arn": "arn:aws:billingconductor::123456789012:billinggroup/abc", "group_by": "["PRODUCT_NAME", "BILLING_PERIOD"]", "billing_period_range": "{"InclusiveStartBillingPeriod": "2025-01", "ExclusiveEndBillingPeriod": "2025-07"}"}

Tool: get-billing-view

Returns the metadata associated to the specified billing view ARN.

A billing view is an AWS resource that defines a segment of AWS cost management data. There are four types of billing views:

• PRIMARY: The default billing view containing all cost management data for an account. For management accounts in an organization, this includes all data across the organization.
• BILLING_GROUP: Billing views corresponding to billing groups created in AWS Billing Conductor.
• CUSTOM: Customer-created billing views that provide filtered cost visibility across organizations. These can be shared with other accounts.
• BILLING_TRANSFER: Views available when using billing transfer, including "My view" and "Showback/chargeback view".
• BILLING_TRANSFER_SHOWBACK: Shows billing data configured for showback or chargeback purposes.

The tool returns information about:

• Billing view ARN, name, and description
• Billing view type (PRIMARY, BILLING_GROUP, CUSTOM, BILLING_TRANSFER, BILLING_TRANSFER_SHOWBACK)
• Owner account ID and source account ID
• Data filter expression (dimensions, tags, cost categories, time range)
• Health status (status code and reasons)
• Derived view count and source view count
• Creation, update, and view definition last updated timestamps

Example: {"arn": "arn:aws:billing::123456789012:billingview/custom-view-abc123"}

Tool: get-resource-policy

Returns the resource-based policy document attached to the resource in JSON format.

Resource-based policies are used to control access to billing view resources. When a custom billing view is shared with other accounts (within or outside the organization) using AWS Resource Access Manager (AWS RAM), a resource-based policy is attached to the billing view resource defining the access permissions.

Use this tool to:

• Inspect the sharing permissions of a billing view to understand which accounts have access
• Audit resource-based policy configurations for compliance or security review
• Debug access issues by examining the policy document attached to a billing view
• Verify that sharing was configured correctly after sharing a custom billing view

The tool returns:

• The resource-based policy document in JSON format
• The ARN of the billing view resource the policy is attached to

Example: {"resource_arn": "arn:aws:billing::123456789012:billingview/custom-view-abc123"}

Tool: list-account-associations

Lists linked accounts associated with the payer account from AWS Billing Conductor.

This tool retrieve linked accounts for a given billing period. If no billing period is provided, the current billing period is used.

The tool returns information about each linked account:

• Account ID
• Account name
• Account email
• Billing group ARN (if associated to a billing group)

You can filter account associations by:

• AccountId: Filter by a specific AWS account ID
• AccountIds: Filter by a list of AWS account IDs (up to 30)
• Association: Filter by association status:
  • MONITORED: linked accounts associated to billing groups
  • UNMONITORED: linked accounts not associated to billing groups
  • Billing Group ARN: linked accounts associated to a specific billing group

The tool paginates through results up to max_pages pages (default 10). If more results are available after reaching the page limit, a next_token is returned. Pass the next_token back to this tool to continue fetching from where you left off.

Example 1: {"billing_period": "2025-01"} Example 2 (monitored only): {"filters": "{"Association": "MONITORED"}", "billing_period": "2025-01"} Example 3 (by account IDs): {"filters": "{"AccountIds": ["123456789012", "234567890123"]}"}

• AccountId: A single AWS account ID (12 digits)
• AccountIds: List of AWS account IDs (up to 30, each 12 digits)
• Association: One of "MONITORED", "UNMONITORED", or a billing group ARN max_pages|integeroptional|Maximum number of API pages to fetch. Defaults to 10. next_token|stringoptional|Optional pagination token from a previous response.

Tool: list-billing-group-cost-reports

Retrieves a summary report of actual AWS charges and calculated AWS charges based on the associated pricing plan of a billing group.

This tool retrieve cost reports for billing groups. If no billing period is provided, the current billing period is used.

The tool returns cost report information for each billing group:

• Billing group ARN
• AWS cost (actual AWS charges)
• Proforma cost (hypothetical charges based on the associated pricing plan)
• Margin (billing group margin)
• Margin percentage (percentage of billing group margin)
• Currency (displayed currency)

You can filter cost reports by:

• BillingGroupArns: Filter by specific billing group ARNs (1 to 100 ARNs)

Example 1: {"billing_period": "2025-01"} Example 2 (with filter): {"filters": "{"BillingGroupArns": ["arn:aws:billingconductor::123456789012:billinggroup/abc"]}", "billing_period": "2025-01"}

• BillingGroupArns: List of billing group ARNs (minimum 1, maximum 100) max_pages|integeroptional|Maximum number of API pages to fetch. Defaults to 10. next_token|stringoptional|Optional pagination token from a previous response.

Tool: list-billing-groups

Retrieves a list of billing groups from AWS Billing Conductor.

This tool retrieve billing groups for a given billing period. If no billing period is provided, the current billing period is used.

The tool returns information about:

• Billing group ARN, name, and description
• Billing group type (STANDARD or TRANSFER_BILLING)
• Billing group status (ACTIVE, PRIMARY_ACCOUNT_MISSING, or PENDING)
• Primary account ID
• Computation preference (pricing plan ARN)
• Account grouping settings (auto-associate, responsibility transfer ARN)
• Group size (number of member accounts)
• Creation and last modified timestamps

You can filter billing groups by:

• ARNs: Filter by specific billing group ARNs
• Names: Filter by billing group name (supports STARTS_WITH search)
• Statuses: Filter by status (ACTIVE, PRIMARY_ACCOUNT_MISSING, PENDING)
• Billing group types: Filter by type (STANDARD, TRANSFER_BILLING)
• Primary account IDs: Filter by primary account ID
• Pricing plan: Filter by pricing plan ARN
• Auto-associate: Filter by auto-associate setting
• Responsibility transfer ARNs: Filter by responsibility transfer ARNs

The tool paginates through results up to max_pages pages (default 10). If more results are available after reaching the page limit, a next_token is returned. Pass the next_token back to this tool to continue fetching from where you left off.

Example 1: {"billing_period": "2025-01"} Example 2 (with filter): {"filters": "{"Statuses": ["ACTIVE"], "BillingGroupTypes": ["STANDARD"]}", "billing_period": "2025-01"}

• Arns: List of billing group ARNs to retrieve
• Names: List of name search objects with SearchOption and SearchValue
• Statuses: List of statuses ("ACTIVE", "PRIMARY_ACCOUNT_MISSING", "PENDING")
• BillingGroupTypes: List of types ("STANDARD", "TRANSFER_BILLING")
• PrimaryAccountIds: List of primary account IDs
• PricingPlan: Pricing plan ARN
• AutoAssociate: Boolean for auto-associate filter
• ResponsibilityTransferArns: List of responsibility transfer ARNs max_pages|integeroptional|Maximum number of API pages to fetch. Defaults to 10. next_token|stringoptional|Optional pagination token from a previous response.

Tool: list-billing-views

Lists the billing views available for a given time period.

Every AWS account has a unique PRIMARY billing view that represents the billing data available by default. Accounts that use AWS Billing Conductor also have BILLING_GROUP billing views representing pro forma costs associated with each created billing group.

If activeTimeRange is provided, only billing views that were active during that time window are returned. Else, all billing views that ever existed are returned, including views for deleted billing groups and ended billing transfers.

The tool returns a list of billing views with information about:

• Billing view ARN, name, and description
• Billing view type (PRIMARY, BILLING_GROUP, CUSTOM, BILLING_TRANSFER, BILLING_TRANSFER_SHOWBACK)
• Owner account ID and source account ID
• Health status (status code and reasons)

You can filter billing views by:

• active_after_inclusive / active_before_inclusive: UTC time range for listing billing views (must be within one calendar month, both must be provided together). Format: YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS (all times are in UTC). PRIMARY billing views are always listed. BILLING_GROUP billing views are listed for time ranges when the associated billing group resource in AWS Billing Conductor is active.
• arns: Filter by specific billing view ARNs (maximum 10 items)
• billing_view_types: Filter by type (PRIMARY, BILLING_GROUP, CUSTOM, BILLING_TRANSFER, BILLING_TRANSFER_SHOWBACK)
• names: Filter by name using search criteria (supports STARTS_WITH search option)
• owner_account_id: Filter by owner account ID (12-digit AWS account ID)
• source_account_id: Filter by source account ID (12-digit AWS account ID)
• max_results: Maximum number of billing views per page (1-100, default 100)

The tool paginates through results up to max_pages pages (default 10). If more results are available after reaching the page limit, a next_token is returned. Pass the next_token back to this tool to continue fetching from where you left off.

Example 1: {} Example 2 (filter by type): {"billing_view_types": "["PRIMARY", "CUSTOM"]"} Example 3 (filter by owner): {"owner_account_id": "123456789012"} Example 4 (filter by name): {"names": "[{"searchOption": "STARTS_WITH", "searchValue": "MyView"}]"} Example 5 (with time range, date only): {"active_after_inclusive": "2024-01-01", "active_before_inclusive": "2024-01-31"} Example 6 (with time range, second precision): {"active_after_inclusive": "2024-01-01T00:00:00", "active_before_inclusive": "2024-01-31T23:59:59"} Example 7 (filter by ARNs): {"arns": "["arn:aws:billing::123456789012:billingview/custom-view-abc123"]"}

Tool: list-cost-allocation-tag-backfill-history

Retrieves the history of cost allocation tag backfill requests using the ListCostAllocationTagBackfillHistory API.

Backfill retroactively applies the current tag activation status to historical billing data. Without backfill, tag activation only affects future billing periods.

Backfill requests progress through these states:

• SCHEDULED: Initial state when the backfill is requested
• PROCESSING: System is rewriting historical tag data and reprocessing bills
• SUCCEEDED: Backfill completed, historical data updated
• FAILED: Processing error occurred (can be retried)

Constraints: Only one backfill can run at a time. There is a 24-hour cooldown between requests. Maximum lookback is 12 months. BackfillFrom must be the first day of a month at 00:00:00 UTC.

The tool returns CostAllocationTagBackfillRequest objects containing:

• BackfillFrom (start date, first of month UTC)
• BackfillStatus (SUCCEEDED, PROCESSING, or FAILED)
• RequestedAt, CompletedAt (null if still processing), LastUpdatedAt

You can control pagination with:

• max_results: Results per page (1-1000)
• max_pages: Max pages to auto-paginate through

Example 1 - Get latest backfill request: {"max_results": 1} Example 2 - Get full backfill history: {"max_pages": 10}

Tool: list-cost-allocation-tags

Lists cost allocation tags in the account using the ListCostAllocationTags API.

Cost allocation tags must be activated before they appear in Cost Explorer, CUR, and budgets. There are two types: AWSGenerated (auto-created by AWS services like aws:createdBy) and UserDefined (created by customers via resource tagging APIs).

The tool returns CostAllocationTag objects containing:

• TagKey, Type (AWSGenerated/UserDefined), Status (Active/Inactive)
• LastUpdatedDate (when activation status last changed)
• LastUsedDate (last month the tag appeared on a billed resource, for identifying stale tags)

You can filter tags by:

• status: Active or Inactive
• tag_keys: JSON array of tag key strings to look up (max 100, case-sensitive). Example: '["Environment", "Team", "CostCenter"]'
• tag_type: AWSGenerated or UserDefined
• max_results: Results per page (1-1000, default 100)
• max_pages: Max pages to auto-paginate through

Limits: 500 active cost allocation tag keys per payer account (adjustable via Service Quotas up to 1,000). Max 20 tags per UpdateCostAllocationTagsStatus request.

Example 1 - List active user-defined tags: {"status": "Active", "tag_type": "UserDefined"} Example 2 - Check specific tag keys: {"tag_keys": "["Environment", "Team"]"} Example 3 - List all tags with no filters: {}

Tool: list-cost-category-definitions

Lists all cost category definitions in the account using the ListCostCategoryDefinitions API.

Returns lightweight references for each cost category, not full rule definitions. Use describe-cost-category-definition with the returned ARN to get the complete rule set.

The tool returns CostCategoryReference objects containing:

• CostCategoryArn, Name (unique, case-sensitive), NumberOfRules
• EffectiveStart, EffectiveEnd (null if current)
• DefaultValue, Values (all category values defined in the rules)
• ProcessingStatus: APPLIED or PROCESSING
• SupportedResourceTypes

You can filter and paginate with:

• effective_on: ISO 8601 datetime to return only categories active at that time. Defaults to current date.
• supported_resource_types: JSON array to filter by resource type support. Valid values: "billing:rispgroupsharing", "billing:billingview" Example: '["billing:billingview"]' Returns only categories supporting all specified types.
• max_results: Results per page (1-100, default 20)
• max_pages: Max pages to auto-paginate through

Limits: 50 cost categories per management account, 500 rules per category (API), 100 rules per category (console), 10 split charge rules per category.

Example 1 - List all current categories: {} Example 2 - List categories active on a date: {"effective_on": "2024-06-01T00:00:00Z"} Example 3 - Filter by billing view support: {"supported_resource_types": "["billing:billingview"]"}

Tool: list-custom-line-item-versions

Retrieves a list of versions for a specific custom line item from AWS Billing Conductor.

This tool retrieve all versions of a custom line item. If no billing period is provided, the current billing period is used.

The tool returns information about each version including charge details, computation rule, billing periods, and timestamps.

You can filter versions by:

• BillingPeriodRange: Filter by start and/or end billing period

Example 1: {"arn": "arn:aws:billingconductor::123456789012:customlineitem/abcdef1234"} Example 2: {"arn": "...", "filters": "{"BillingPeriodRange": {"StartBillingPeriod": "2025-01", "EndBillingPeriod": "2025-06"}}"}

Tool: list-custom-line-items

Retrieves a list of custom line items (FFLIs) from AWS Billing Conductor.

Custom line items let you allocate costs and discounts to designated AWS accounts within a billing group. Common use cases include allocating support fees, shared service costs, managed service fees, taxes, credits, and distributing RI/Savings Plans savings.

This tool retrieve custom line items for a given billing period. If no billing period is provided, the current billing period is used.

The tool returns information about:

• Custom line item ARN, name, and description
• Account ID, billing group ARN
• Charge details (type: CREDIT or FEE, flat or percentage)
• Computation rule (CONSOLIDATED or ITEMIZED)
• Currency code, association size, product code
• Presentation details, creation and last modified timestamps

You can filter custom line items by:

• AccountIds: Filter by AWS account IDs (up to 30)
• Arns: Filter by specific custom line item ARNs (up to 100)
• BillingGroups: Filter by billing group ARNs (up to 100)
• Names: Filter by custom line item names (up to 100)

Example 1: {"billing_period": "2025-01"} Example 2 (with filter): {"filters": "{"Names": ["MyCustomLineItem"]}", "billing_period": "2025-01"}

Tool: list-pricing-plans

Retrieves a list of pricing plans from AWS Billing Conductor.

This tool retrieve pricing plans for a given billing period. If no billing period is provided, the current billing period is used.

The tool returns information about:

• Pricing plan ARN, name, and description
• Number of associated pricing rules (size)
• Creation and last modified timestamps

You can filter pricing plans by:

• Arns: Filter by specific pricing plan ARNs

Example 1: {"billing_period": "2025-01"} Example 2: {"filters": "{"Arns": ["arn:aws:billingconductor::123456789012:pricingplan/abc"]}", "billing_period": "2025-01"}

Tool: list-pricing-plans-for-rule

Lists the pricing plans associated with a specific pricing rule.

This tool retrieve pricing plans associated with a specific pricing rule If no billing period is provided, the current billing period is used.

The tool returns information about:

• The billing period for which the pricing rule associations are listed.
• The optional pagination token to be used on subsequent calls.
• The ARN of the pricing rule for which associations are listed.
• The list containing pricing plans that are associated with the requested pricing rule.

Example: {"pricing_rule_arn": "arn:aws:billingconductor::123456789012:pricingrule/abc"}

Tool: list-pricing-rules

Retrieves a list of pricing rules from AWS Billing Conductor.

This tool retrieve pricing rules for a given billing period.

The tool returns information about:

• Pricing rule ARN, name, and description
• Type (MARKUP, DISCOUNT, or TIERING)
• Scope (GLOBAL, SERVICE, BILLING_ENTITY, or SKU)
• Modifier percentage, associated pricing plan count
• Service, operation, usage type, billing entity
• Tiering configuration, creation and last modified timestamps

You can filter pricing rules by:

• Arns: Filter by specific pricing rule ARNs

Example 1: {"billing_period": "2025-01"} Example 2: {"filters": "{"Arns": ["arn:aws:billingconductor::123456789012:pricingrule/abc"]}", "billing_period": "2025-01"}

Tool: list-pricing-rules-for-plan

Lists the pricing rules associated with a specific pricing plan.

This tool retrieve pricing rules associated with a specific pricing plan If no billing period is provided, the current billing period is used.

The tool returns information about:

• The billing period for which the pricing rule associations are listed.
• The optional pagination token to be used on subsequent calls.
• The ARN of the pricing plan for which associations are listed.
• A list containing pricing rules that are associated with the requested pricing plan

Example: {"pricing_plan_arn": "arn:aws:billingconductor::123456789012:pricingplan/abc"}

Tool: list-resources-associated-to-custom-line-item

Lists the resources associated to a custom line item from AWS Billing Conductor.

This tool retrieve resources associated with a specific custom line item. If no billing period is provided, the current billing period is used.

The tool returns information about each associated resource:

• Resource ARN (can be a billing group or custom line item)
• End billing period of the association
• Relationship type (PARENT or CHILD)

You can filter associated resources by:

• Relationship: Filter by relationship type ("PARENT" or "CHILD")

Example 1: {"arn": "arn:aws:billingconductor::123456789012:customlineitem/abcdef1234"} Example 2: {"arn": "...", "filters": "{"Relationship": "CHILD"}", "billing_period": "2025-01"}

Tool: list-source-views-for-billing-view

Lists the source views (managed AWS billing views) that a custom billing view is built from.

A custom billing view is created as a "multi-source view" by combining cost management data from up to 20 source views. Source views are managed billing views (typically PRIMARY or other CUSTOM billing views) from the same or different AWS organizations. This enables consolidation of cost management data across multiple organizations into a single custom billing view.

Use this tool to:

• Understand the data lineage of a custom billing view (which source views feed its data)
• Debug health issues: if a custom view is UNHEALTHY with SOURCE_VIEW_UNHEALTHY or SOURCE_VIEW_ACCESS_DENIED, inspect its source views to identify the problem
• Audit cross-organization data consolidation (which orgs/accounts contribute to this view)
• Determine if the custom billing view aggregates data from a single org or multiple orgs

The tool paginates through results up to max_pages pages (default 10). If more results are available after reaching the page limit, a next_token is returned. Pass the next_token back to this tool to continue fetching from where you left off.

Example 1: {"arn": "arn:aws:billing::123456789012:billingview/custom-view-abc123"} Example 2 (with max_results): {"arn": "arn:aws:billing::123456789012:billingview/custom-view-abc123", "max_results": 5} Example 3 (with next_token): {"arn": "arn:aws:billing::123456789012:billingview/custom-view-abc123", "next_token": "token123"}

Tool: rec-details

Get detailed cost optimization recommendation with integrated data from multiple AWS services.

This tool combines data from:

• Cost Optimization Hub (base recommendation)
• AWS Compute Optimizer (detailed metrics for compute resources)
• Cost Explorer (Savings Plans/RI purchase recommendations)

It provides comprehensive analysis with utilization metrics, savings calculations, and implementation guidance.

RESPONSE FORMATTING INSTRUCTIONS: The tool may return both raw recommendation data and a formatting template. When presenting the recommendation:

1. If a template is provided, use it to organize your response
2. If no template is provided, structure your response in a clear, logical manner
3. Always include key information like resource details, savings amounts, and implementation steps
4. Ensure all numeric values (costs, savings, metrics) are included
5. Add natural language explanations to make the information more accessible Parameters|Type|Description -|-|- recommendation_id|string|ID of the recommendation to retrieve details for

Tool: ri-performance

Retrieves AWS Reserved Instance (RI) coverage and utilization data using the Cost Explorer API.

This tool provides insights into your Reserved Instance (RI) and Savings Plans usage patterns through two main operations:

1. get_reservation_coverage: Shows how much of your eligible usage is covered by RIs

   • Helps identify opportunities to purchase additional RIs
   • Supports grouping by dimensions like REGION, INSTANCE_TYPE, etc.
   • Can filter by specific services, regions, or instance types

2. get_reservation_utilization: Shows how effectively you're using your purchased RIs

   • Reveals underutilized or idle reserved capacity
   • Can be grouped by SUBSCRIPTION_ID to see utilization per RI
   • Helps identify RIs that could be modified or sold in the marketplace

Supported dimensions for grouping reservation coverage:

• AZ: Availability Zone
• INSTANCE_TYPE: Instance type (e.g., m4.xlarge)
• LINKED_ACCOUNT: Member accounts in organization
• PLATFORM: Operating system
• REGION: AWS Region
• SERVICE: AWS service (EC2, RDS, etc.)
• TENANCY: Instance tenancy (default, dedicated)

Reservation utilization can only be grouped by SUBSCRIPTION_ID.

Tool: session-sql

Execute SQL queries on the persistent session database.

This tool queries tables created by other tools (like cost_explorer_sql) within the current session. All tools share the same database, allowing cross-tool data analysis and joins.

Use this tool to:

• Query tables created by cost_explorer_sql and other tools
• Join data from multiple AWS APIs
• Perform complex analysis across different data sources

Common queries:

• SELECT name FROM sqlite_master WHERE type='table' -- List all tables
• SELECT * FROM [table_name] LIMIT 10 -- Preview table data Parameters|Type|Description -|-|- query|string|SQL query to execute data|stringoptional|Optional array of data rows to add to database before querying schema|stringoptional|Optional column definitions for user data (e.g. ["service TEXT", "cost REAL"]) table_name|stringoptional|Optional name for user data table (auto-generated if not provided)

Tool: sp-performance

Tool that retrieves AWS Savings Plans coverage and utilization data using the Cost Explorer API.

This tool provides insights into your Savings Plans usage patterns through three main operations:

1. get_savings_plans_coverage: Shows how much of your eligible usage is covered by Savings Plans
2. get_savings_plans_utilization: Shows overall utilization metrics for your Savings Plans
3. get_savings_plans_utilization_details: Shows detailed per-Savings Plan utilization Parameters|Type|Description -|-|- operation|string|The operation to perform: 'get_savings_plans_coverage', 'get_savings_plans_utilization', or 'get_savings_plans_utilization_details' end_date|stringoptional|End date in YYYY-MM-DD format (exclusive). Defaults to today if not provided. filter|stringoptional|Optional filter to apply to the results as a JSON string. granularity|stringoptional|Time granularity of the data (DAILY or MONTHLY). Defaults to DAILY. group_by|stringoptional|Optional grouping of results as a JSON string. For coverage, supports SERVICE, REGION, or INSTANCE_FAMILY. max_results|stringoptional|Maximum number of results to return per page. metrics|stringoptional|List of metrics to retrieve as a JSON string. For coverage, only 'SpendCoveredBySavingsPlans' is valid. start_date|stringoptional|Start date in YYYY-MM-DD format (inclusive). Defaults to 30 days ago if not provided.

Tool: storage-lens

Query S3 Storage Lens metrics data using Athena SQL.

IMPORTANT USAGE GUIDELINES:

• Before using this tool, provide a 1-3 sentence explanation starting with "EXPLANATION:"
• Use standard SQL syntax for Athena queries
• Use {table} as a placeholder for the Storage Lens metrics table name
• Perform aggregations (GROUP BY) when analyzing data across multiple dimensions

This tool allows you to analyze S3 Storage Lens metrics data using SQL queries. Storage Lens provides metrics about your S3 storage, including:

• Storage metrics: Total bytes, object counts by storage class
• Cost optimization metrics: Transition opportunities, incomplete multipart uploads
• Data protection metrics: Replication, versioning, encryption status
• Activity metrics: Upload, download, and request metrics

STORAGE LENS EXPORT SCHEMA: The Storage Lens export data has the following standard columns:

• version_number: The version of the S3 Storage Lens metrics being used
• configuration_id: The configuration_id of your S3 Storage Lens configuration
• report_date: The date that the metrics were tracked
• aws_account_number: Your AWS account number
• aws_region: The AWS Region for which the metrics are being tracked
• storage_class: The storage class (STANDARD, STANDARD_IA, GLACIER, etc.)
• record_type: The type of artifact being reported (ACCOUNT, BUCKET, PREFIX, STORAGE_LENS_GROUP_BUCKET, STORAGE_LENS_GROUP_ACCOUNT)
• record_value: The value of the record_type artifact (account ID, bucket name, prefix, or Storage Lens group ARN)
• bucket_name: The name of the bucket (when record_type is BUCKET or PREFIX)
• metric_name: The name of the metric (e.g., 'StorageBytes', 'ObjectCount', 'EncryptedStorageBytes')
• metric_value: The numeric value of the metric

IMPORTANT: Metrics are stored in rows, not columns. Each row represents one metric value for a specific combination of dimensions.

Environment variables:

• STORAGE_LENS_MANIFEST_LOCATION: S3 URI to manifest file or folder (required)
• STORAGE_LENS_OUTPUT_LOCATION: S3 location for Athena query results (optional)

Example queries:

1. Top 10 buckets by storage size: SELECT bucket_name, SUM(CAST(metric_value AS BIGINT)) as total_size FROM {table} WHERE metric_name = 'StorageBytes' GROUP BY bucket_name ORDER BY total_size DESC LIMIT 10

2. Storage distribution by storage class: SELECT storage_class, SUM(CAST(metric_value AS BIGINT)) as total_size FROM {table} WHERE metric_name = 'StorageBytes' GROUP BY storage_class ORDER BY total_size DESC

3. Buckets with incomplete multipart uploads: SELECT bucket_name, SUM(CAST(metric_value AS BIGINT)) as incomplete_bytes FROM {table} WHERE metric_name = 'IncompleteMultipartUploadStorageBytes' AND CAST(metric_value AS BIGINT) > 0 GROUP BY bucket_name ORDER BY incomplete_bytes DESC

4. Storage Distribution by Region and Storage Class: SELECT aws_region, storage_class, SUM(CAST(metric_value AS BIGINT)) as total_bytes FROM {table} WHERE metric_name = 'StorageBytes' GROUP BY aws_region, storage_class ORDER BY total_bytes DESC

5. Object Lifecycle Management Opportunities: SELECT aws_region, storage_class, SUM(CASE WHEN metric_name = 'NonCurrentVersionStorageBytes' THEN CAST(metric_value AS BIGINT) ELSE 0 END) as noncurrent_bytes, SUM(CASE WHEN metric_name = 'StorageBytes' THEN CAST(metric_value AS BIGINT) ELSE 0 END) as total_bytes FROM {table} WHERE metric_name IN ('NonCurrentVersionStorageBytes', 'StorageBytes') GROUP BY aws_region, storage_class HAVING SUM(CASE WHEN metric_name = 'NonCurrentVersionStorageBytes' THEN CAST(metric_value AS BIGINT) ELSE 0 END) > 0 ORDER BY noncurrent_bytes DESC

6. Lifecycle Rule Analysis: SELECT bucket_name, SUM(CASE WHEN metric_name = 'TotalLifecycleRuleCount' THEN CAST(metric_value AS INTEGER) ELSE 0 END) as lifecycle_rule_count, SUM(CASE WHEN metric_name = 'StorageBytes' THEN CAST(metric_value AS BIGINT) ELSE 0 END) as total_bytes FROM {table} WHERE metric_name IN ('TotalLifecycleRuleCount', 'StorageBytes') GROUP BY bucket_name ORDER BY lifecycle_rule_count ASC, total_bytes DESC Parameters|Type|Description -|-|- query|string|SQL query to execute against the data (use {table} as a placeholder for the table name) database_name|stringoptional|Athena database name (defaults to 'storage_lens_db') manifest_location|stringoptional|S3 URI to manifest file or folder (overrides environment variable) output_location|stringoptional|S3 location for Athena query results (overrides environment variable) table_name|stringoptional|Athena table name (defaults to 'storage_lens_metrics')

Use this MCP Server

{
  "mcpServers": {
    "awslabs-billing-cost-management": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "AWS_REGION",
        "-e",
        "AWS_PROFILE",
        "-e",
        "STORAGE_LENS_MANIFEST_LOCATION",
        "mcp/billing-cost-management-mcp-server"
      ],
      "env": {
        "AWS_REGION": "us-east-1",
        "AWS_PROFILE": "default",
        "STORAGE_LENS_MANIFEST_LOCATION": "s3://bucket-name/storage-lens/manifests/"
      }
    }
  }
}

Why is it safer to run MCP Servers with Docker?⁠