AWS Pricing MCP Server
Provides real-time AWS pricing data and cost analysis, including service discovery, pricing queries, multi-region comparisons, and cost optimization recommendations.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@AWS Pricing MCP Server How much does a gp3 EBS volume cost per GB in us-west-2?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
AWS Pricing MCP Server (Fork)
An MCP server for accessing real-time AWS pricing information and providing cost analysis capabilities. Forked from awslabs/mcp.
Important Note: This server provides real-time pricing data from the public AWS Price List Bulk API. We cannot guarantee that AI assistants will always construct filters correctly or identify the absolute cheapest options. All API calls are free of charge and require no AWS credentials.
Changes from Upstream
This fork replaces the AWS Pricing Query API (boto3) with the public AWS Price List Bulk API, which means:
No AWS credentials required — no IAM permissions, no
aws configure, noAWS_PROFILEneededNo
boto3dependency — useshttpxfor direct HTTP requests to the public Bulk APILocal filtering — filters are applied locally after fetching price lists, supporting
EQUALS,ANY_OF,CONTAINS, andNONE_OFfilter typesIndex-based pagination — uses simple integer offsets instead of AWS API pagination tokens
Related MCP server: Cost Management MCP
Features
AWS Pricing Discovery & Information
Service catalog exploration: Discover all AWS services with available pricing information
Pricing attribute discovery: Identify filterable dimensions (instance types, regions, storage classes, etc.) for any AWS service
Real-time pricing queries: Access current pricing data with advanced filtering capabilities including multi-option comparisons and pattern matching
Multi-region pricing comparisons: Compare pricing across different AWS regions in a single query
Bulk pricing data access: Download complete pricing datasets in CSV/JSON formats for historical analysis and offline processing
Cost Analysis & Planning
Detailed cost report generation: Create comprehensive cost analysis reports with unit pricing, calculation breakdowns, and usage scenarios
Infrastructure project analysis: Scan CDK and Terraform projects to automatically identify AWS services and their configurations
Architecture pattern guidance: Get detailed architecture patterns and cost considerations, especially for Amazon Bedrock services
Cost optimization recommendations: Receive AWS Well-Architected Framework aligned suggestions for cost optimization
Query pricing data with natural language
Ask questions about AWS pricing in plain English, no complex query languages required
Get instant answers from the AWS Price List Bulk API for any AWS service
Retrieve comprehensive pricing information with flexible filtering options
Prerequisites
Install
uvfrom Astral or the GitHub READMEInstall Python using
uv python install 3.10
No AWS credentials or IAM permissions are needed — this fork uses the public Bulk API.
Installation
From GitHub (recommended)
Configure the MCP server in your MCP client configuration:
For Linux/MacOS:
{
"mcpServers": {
"aws-pricing": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/sebdroid/aws-pricing-mcp-server",
"awslabs.aws-pricing-mcp-server"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
}
}
}
}For Windows:
{
"mcpServers": {
"aws-pricing": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/sebdroid/aws-pricing-mcp-server",
"awslabs.aws-pricing-mcp-server.exe"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
}
}
}
}From a local clone
git clone https://github.com/sebdroid/aws-pricing-mcp-server.git
cd aws-pricing-mcp-server
uv syncThen configure your MCP client to use the local directory:
{
"mcpServers": {
"aws-pricing": {
"command": "uv",
"args": [
"run",
"--directory",
"/path/to/aws-pricing-mcp-server",
"awslabs.aws-pricing-mcp-server"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
}
}
}
}Using Docker
After a successful docker build -t awslabs/aws-pricing-mcp-server .:
{
"mcpServers": {
"aws-pricing": {
"command": "docker",
"args": [
"run",
"--rm",
"--interactive",
"--env",
"FASTMCP_LOG_LEVEL=ERROR",
"awslabs/aws-pricing-mcp-server:latest"
]
}
}
}Configuration
Variable | Default | Description |
|
| Log level ( |
|
| Fallback region for |
No AWS credentials are needed — all data comes from the public Bulk API.
"env": {
"FASTMCP_LOG_LEVEL": "ERROR",
"AWS_REGION": "us-east-1"
}Available Tools
9 toolsanalyze_cdk_projectARead-only
Analyze a CDK project to identify AWS services used. This tool dynamically extracts service information from CDK constructs without relying on hardcoded service mappings.
Inputs: project_path (required). Returns: result
analyze_terraform_projectARead-only
Analyze a Terraform project to identify AWS services used. This tool dynamically extracts service information from Terraform resource declarations.
Inputs: project_path (required). Returns: result
generate_cost_reportARead-only
Generate a detailed cost analysis report based on pricing data for one or more AWS services.
This tool requires AWS pricing data and provides options for adding detailed cost information.
IMPORTANT REQUIREMENTS:
ALWAYS include detailed unit pricing information (e.g., "$0.0008 per 1K input tokens")
ALWAYS show calculation breakdowns (unit price × usage = total cost)
ALWAYS specify the pricing model (e.g., "ON DEMAND")
ALWAYS list all assumptions and exclusions explicitly
Output Format Options:
'markdown' (default): Generates a well-formatted markdown report
'csv': Generates a CSV format report with sections for service information, unit pricing, cost calculations, etc.
Example usage:
{
// Required parameters
"pricing_data": {
// This should contain pricing data retrieved from get_pricing
"status": "success",
"service_name": "bedrock",
"data": "... pricing information ...",
"message": "Retrieved pricing for bedrock from AWS Pricing url"
},
"service_name": "Amazon Bedrock",
// Core parameters (commonly used)
"related_services": ["Lambda", "S3"],
"pricing_model": "ON DEMAND",
"assumptions": [
"Standard ON DEMAND pricing model",
"No caching or optimization applied",
"Average request size of 4KB"
],
"exclusions": [
"Data transfer costs between regions",
"Custom model training costs",
"Development and maintenance costs"
],
"output_file": "cost_analysis_report.md", // or "cost_analysis_report.csv" for CSV format
"format": "markdown", // or "csv" for CSV format
// Advanced parameter for complex scenarios
"detailed_cost_data": {
"services": {
"Amazon Bedrock Foundation Models": {
"usage": "Processing 1M input tokens and 500K output tokens with Claude 3.5 Haiku",
"estimated_cost": "$80.00",
"free_tier_info": "No free tier for Bedrock foundation models",
"unit_pricing": {
"input_tokens": "$0.0008 per 1K tokens",
"output_tokens": "$0.0016 per 1K tokens"
},
"usage_quantities": {
"input_tokens": "1,000,000 tokens",
"output_tokens": "500,000 tokens"
},
"calculation_details": "$0.0008/1K × 1,000K input tokens + $0.0016/1K × 500K output tokens = $80.00"
},
"AWS Lambda": {
"usage": "6,000 requests per month with 512 MB memory",
"estimated_cost": "$0.38",
"free_tier_info": "First 12 months: 1M requests/month free",
"unit_pricing": {
"requests": "$0.20 per 1M requests",
"compute": "$0.0000166667 per GB-second"
},
"usage_quantities": {
"requests": "6,000 requests",
"compute": "6,000 requests × 1s × 0.5GB = 3,000 GB-seconds"
},
"calculation_details": "$0.20/1M × 0.006M requests + $0.0000166667 × 3,000 GB-seconds = $0.38"
}
}
},
// Recommendations parameter - can be provided directly or generated
"recommendations": {
"immediate": [
"Optimize prompt engineering to reduce token usage for Claude 3.5 Haiku",
"Configure Knowledge Base OCUs based on actual query patterns",
"Implement response caching for common queries to reduce token usage"
],
"best_practices": [
"Monitor OCU utilization metrics and adjust capacity as needed",
"Use prompt caching for repeated context across API calls",
"Consider provisioned throughput for predictable workloads"
]
}
}Inputs: pricing_data (required), service_name (required), format, exclusions, +6 more. Returns: result
get_bedrock_patternsARead-only
Get architecture patterns for Amazon Bedrock applications, including component relationships and cost considerations
Inputs: no named parameters. Returns: result
get_price_list_urlsARead-only
Get download URLs for bulk pricing data files.
**PURPOSE:** Access complete AWS pricing datasets as downloadable files for historical analysis and bulk processing.
**WORKFLOW:** Use this for historical pricing analysis or bulk data processing when current pricing from get_pricing() isn't sufficient.
**PARAMETERS:**
- Service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonS3')
- AWS region (e.g., 'us-east-1', 'eu-west-1')
- Optional: effective_date for historical pricing (default: current date)
**RETURNS:** Dictionary with download URLs for different formats:
- 'csv': Direct download URL for CSV format
- 'json': Direct download URL for JSON format
**USE CASES:**
- Historical pricing analysis (get_pricing() only provides current pricing)
- Bulk data processing without repeated API calls
- Offline analysis of complete pricing datasets
- Savings Plans analysis across services
**FILE PROCESSING:**
- CSV files: Lines 1-5 are metadata, Line 6 contains headers, Line 7+ contains pricing data
- Use `tail -n +7 pricing.csv | grep "t3.medium"` to filter data
Inputs: region (required), service_code (required). Returns: result
get_pricingARead-only
Get detailed pricing information from AWS Price List API with optional filters.
**PARAMETERS:**
- service_code (required): AWS service code (e.g., 'AmazonEC2', 'AmazonS3', 'AmazonES')
- region (optional): AWS region string (e.g., 'us-east-1') OR list for multi-region comparison (e.g., ['us-east-1', 'eu-west-1']). Omit for global services like DataTransfer or CloudFront that don't have region-specific pricing.
- filters (optional): List of filter dictionaries in format {'Field': str, 'Type': str, 'Value': str}
- max_allowed_characters (optional): Response size limit in characters (default: 100,000, use -1 for unlimited)
- output_options (optional): OutputOptions object for response transformation and size reduction
- max_results (optional): Maximum number of results to return per page (default: 100, min: 1, max: 100)
- next_token (optional): Pagination token from previous response to get next page of results
**MANDATORY WORKFLOW - ALWAYS FOLLOW:**
**Step 1: Discover Available Options**
```python
service_codes = get_pricing_service_codes() # Find correct service (skip if known)
attributes = get_pricing_service_attributes('AmazonEC2') # Discover filterable dimensions
attribute_values = get_pricing_attribute_values('AmazonEC2', 'memory') # Get valid values for filtering
```
**Step 2: Build Precise Filters**
```python
# Use ONLY values discovered in Step 1
filters = [
{"Field": "memory", "Value": ["8 GiB", "16 GiB", "32 GiB"], "Type": "ANY_OF"}, # Multiple options
{"Field": "instanceType", "Value": "m5", "Type": "CONTAINS"}, # Pattern matching
{"Field": "instanceType", "Value": ["t2", "m4"], "Type": "NONE_OF"} # Exclude older
] ```
**Step 3: Execute Query**
```python
pricing = get_pricing('AmazonEC2', 'us-east-1', filters)
```
**FILTER TYPES:**
- **EQUALS**: Exact match (default) - `{"Field": "instanceType", "Value": "m5.large"}`
- **ANY_OF**: Multiple options - `{"Field": "memory", "Value": ["8 GiB", "16 GiB"], "Type": "ANY_OF"}`
- **CONTAINS**: Pattern match - `{"Field": "instanceType", "Value": "m5", "Type": "CONTAINS"}`
- **NONE_OF**: Exclusion - `{"Field": "instanceType", "Value": ["t2", "m4"], "Type": "NONE_OF"}`
**CRITICAL: ANY_OF FILTER VALUE LIMITS:**
- **1024 CHARACTER LIMIT**: Total length of all values in ANY_OF arrays cannot exceed 1024 characters
- **PROGRESSIVE FILTERING**: Start with minimal qualifying options, expand if needed
- **EXAMPLE VIOLATION**: `["8 GiB", "16 GiB", "32 GiB", "64 GiB", "96 GiB", "128 GiB", ...]` (TOO LONG)
- **CORRECT APPROACH**: `["8 GiB", "16 GiB", "32 GiB", "36 GiB", "48 GiB"]` (TARGETED LIST)
**COMMON USE CASES:**
**COST OPTIMIZATION - EXHAUSTIVE MINIMUM-FIRST APPROACH:** When users ask for "lowest price", "cheapest", or cost optimization
- **LOWER = CHEAPER ASSUMPTION**: For cost optimization, assume lower capabilities cost less than higher ones
* 32 GB storage is cheaper than 300 GB storage
* 8 GiB RAM is cheaper than 64 GiB RAM
- **CRITICAL FOR COST QUERIES**: Start IMMEDIATELY above minimum requirement and test ALL options incrementally
- **EXHAUSTIVE ENUMERATION REQUIRED**: Each storage/memory tier is MUTUALLY EXCLUSIVE - must list each one explicitly
- **STOP AT REASONABLE UPPER BOUND**: For cost optimization, limit upper bound to 2-3x minimum requirement to avoid expensive options
- **exclude_free_products**: ESSENTIAL for cost analysis - removes $0.00 reservation placeholders, SQL licensing variants, and special pricing entries that obscure actual billable instances when finding cheapest options
- Use ANY_OF for efficient multi-option comparison in single API call
- Multi-attribute capability filtering for minimum requirements
- Combine CONTAINS + NONE_OF for refined discovery
**OUTPUT OPTIONS (Response Size & Performance Control):**
- **PURPOSE**: Transform and optimize API responses for ALL services, especially critical for large services (EC2, RDS)
- **IMMEDIATE COMBINED APPROACH**: `{"pricing_terms": ["OnDemand", "FlatRate"], "product_attributes": ["instanceType", "location", "memory"]}`
- **ATTRIBUTE DISCOVERY**: Use get_pricing_service_attributes() - same names for filters and output_options
- **SIZE REDUCTION**: 80%+ reduction with combined pricing_terms + product_attributes
- **exclude_free_products**: Remove products with $0.00 OnDemand pricing (useful when you know service has paid tiers)
- **WHEN TO USE**: Always for large services, recommended for all services to improve performance
**CRITICAL REQUIREMENTS:**
- **NEVER GUESS VALUES**: Always use get_pricing_attribute_values() to discover valid options
- **EXHAUSTIVE ENUMERATION**: For cost optimization, list ALL qualifying tiers individually - they are mutually exclusive
- **USE SPECIFIC FILTERS**: Large services (EC2, RDS) require 2-3 filters minimum
- **NEVER USE MULTIPLE CALLS**: When ANY_OF can handle it in one call
- **VERIFY EXISTENCE**: Ensure all filter values exist in the service before querying
- **FOR "CHEAPEST" QUERIES**: Focus on lower-end options that meet minimum requirements, test incrementally
- **EXPLORE ALTERNATIVES**: When response includes "alternatives" field, MUST fetch their pricing if applicable to the use case before answering
**CONSTRAINTS:**
- **CURRENT PRICING ONLY**: Use get_price_list_urls for historical data
- **NO SPOT/SAVINGS PLANS**: Only OnDemand, FlatRate, and Reserved Instance pricing available (ANY combination possible)
- **CHARACTER LIMIT**: 100,000 characters default response limit (use output_options to reduce)
- **REGION AUTO-FILTER**: Region parameter automatically creates regionCode filter
**ANTI-PATTERNS:**
- DO NOT make multiple API calls that could be combined with ANY_OF
- DO NOT build cross-products manually when API can handle combinations
- DO NOT call get_pricing_service_codes() when service code is already known (e.g., "AmazonEC2")
- DO NOT use EQUALS without first checking get_pricing_attribute_values()
- DO NOT skip discovery workflow for any use case
- DO NOT use broad queries without specific filters on large services
- DO NOT assume attribute values exist across different services/regions
- DO NOT skip intermediate tiers: Missing 50GB, 59GB options when testing 32GB → 75GB jump
- DO NOT set upper bounds too high: Including 500GB+ storage when user needs ≥30GB (wastes character limit)
- DO NOT ignore alternatives field or use only ["OnDemand"] in output_options
**EXAMPLE USE CASES:**
**1. Cost-Optimized Multi-Attribute Filtering (CORRECT APPROACH):**
```python
# Find cheapest EC2 instances meeting minimum requirements (>= 8 GiB memory, >= 30 GB storage)
# EXHAUSTIVE ENUMERATION of qualifying tiers - each is mutually exclusive
filters = [
{"Field": "memory", "Value": ["8 GiB", "16 GiB", "32 GiB"], "Type": "ANY_OF"}, # All tiers ≥8GB up to reasonable limit
{"Field": "storage", "Value": ["1 x 32 SSD", "1 x 60 SSD", "1 x 75 NVMe SSD"], "Type": "ANY_OF"}, # All tiers ≥30GB up to reasonable limit
{"Field": "instanceType", "Value": ["t2", "m4"], "Type": "NONE_OF"}, # Exclude older generations
{"Field": "tenancy", "Value": "Shared", "Type": "EQUALS"} # Exclude more expensive dedicated
]
pricing = get_pricing('AmazonEC2', 'us-east-1', filters)
```
**2. Efficient Multi-Region Comparison:**
```python
# Compare same configuration across regions - use region parameter for multi-region
filters = [{"Field": "instanceType", "Value": "m5.large", "Type": "EQUALS"}]
pricing = get_pricing('AmazonEC2', ['us-east-1', 'us-west-2', 'eu-west-1'], filters)
```
**3. Large service with output optimization (recommended approach):**
```python
output_options = {"pricing_terms": ["OnDemand", "FlatRate"], "product_attributes": ["instanceType", "location"], "exclude_free_products": true}
pricing = get_pricing('AmazonEC2', 'us-east-1', filters, output_options=output_options)
```
**4. Pattern-Based Discovery:**
```python
# Find all Standard storage tiers except expensive ones
filters = [
{"Field": "storageClass", "Value": "Standard", "Type": "CONTAINS"},
{"Field": "storageClass", "Value": ["Standard-IA"], "Type": "NONE_OF"}
]
```
**FILTERING STRATEGY:**
- **Large Services (EC2, RDS)**: ALWAYS use 2-3 specific filters to prevent 200+ record responses
- **Small Services**: May work with single filter or no filters
- **Multi-Option Analysis**: Use ANY_OF instead of multiple API calls
- **Pattern Discovery**: Use CONTAINS for finding families or tiers
- **Smart Exclusion**: Use NONE_OF for compliance or cost filtering
**SUCCESS CRITERIA:**
- Used discovery workflow (skip get_pricing_service_codes() if service known)
- Applied appropriate filters for the service size
- Used exact values from get_pricing_attribute_values()
- Used ANY_OF for multi-option scenarios instead of multiple calls
- For cost optimization: tested ALL qualifying tiers exhaustively (in a reasonable range)
- Included ["OnDemand", "FlatRate"] in output_options and explored all alternatives
Inputs: service_code (required), region, filters, next_token, +3 more. Returns: result
get_pricing_attribute_valuesARead-only
Get valid values for pricing filter attributes.
**PURPOSE:** Discover what values are available for specific pricing filter attributes of an AWS service.
**WORKFLOW:** Use this after get_pricing_service_attributes() to see valid values for each filter attribute.
**PARAMETERS:**
- Service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonRDS')
- region (optional): AWS region (e.g., 'us-east-1', 'eu-west-2'). Defaults to AWS_REGION env var. Set this to match the region you plan to query with get_pricing().
- List of attribute names from get_pricing_service_attributes() (e.g., ['instanceType', 'location'])
- filters (optional): Dictionary mapping attribute names to regex patterns (e.g., {'instanceType': 't3'})
**RETURNS:** Dictionary mapping attribute names to their valid values. Filtered attributes return only matching values, unfiltered attributes return all values.
**EXAMPLE RETURN:**
```
{
'instanceType': ['t2.micro', 't3.medium', 'm5.large', ...],
'location': ['US East (N. Virginia)', 'EU (London)', ...]
}
```
**NEXT STEPS:** Use these values in get_pricing() filters to get specific pricing data.
**ERROR HANDLING:** Uses "all-or-nothing" approach - if any attribute fails, the entire operation fails.
**EXAMPLES:**
- Single attribute: ['instanceType'] returns {'instanceType': ['t2.micro', 't3.medium', ...]}
- Multiple attributes: ['instanceType', 'location'] returns both mappings
- Partial filtering: filters={'instanceType': 't3'} applies only to instanceType, location returns all values
Inputs: service_code (required), attribute_names (required), region, filters. Returns: result
get_pricing_service_attributesARead-only
Get filterable attributes available for an AWS service in the Pricing API.
**PURPOSE:** Discover what pricing dimensions (filters) are available for a specific AWS service.
**WORKFLOW:** Use this after get_pricing_service_codes() to see what filters you can apply to narrow down pricing queries.
**PARAMETERS:**
- service_code: AWS service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonRDS')
- region (optional): AWS region (e.g., 'us-east-1', 'eu-west-2'). Defaults to AWS_REGION env var. Set this to match the region you plan to query with get_pricing().
- filter (optional): Case-insensitive regex pattern to filter attribute names (e.g., "instance" matches "instanceType", "instanceFamily")
**RETURNS:** List of attribute names (e.g., 'instanceType', 'location', 'storageClass') that can be used as filters.
**NEXT STEPS:**
- Use get_pricing_attribute_values() to see valid values for each attribute
- Use these attributes in get_pricing() filters to get specific pricing data
**EXAMPLE:** For 'AmazonRDS' you might get ['engineCode', 'instanceType', 'deploymentOption', 'location'].
Inputs: service_code (required), filter, region. Returns: result
get_pricing_service_codesARead-only
Get AWS service codes available in the Price List API.
**PURPOSE:** Discover which AWS services have pricing information available in the AWS Price List API.
**PARAMETERS:**
- filter (optional): Case-insensitive regex pattern to filter service codes (e.g., "bedrock" matches "AmazonBedrock", "AmazonBedrockService")
**WORKFLOW:** This is the starting point for any pricing query. Use this first to find the correct service code.
**RETURNS:** List of service codes (e.g., 'AmazonEC2', 'AmazonS3', 'AWSLambda') that can be used with other pricing tools.
**NEXT STEPS:**
- Use get_pricing_service_attributes() to see what filters are available for a service
- Use get_pricing() to get actual pricing data for a service
**NOTE:** Service codes may differ from AWS console names (e.g., 'AmazonES' for OpenSearch, 'AWSLambda' for Lambda).
Inputs: filter. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Each tool has a distinct role: service discovery, attribute discovery, value discovery, pricing retrieval, bulk download, report generation, project type analysis, and Bedrock patterns. The discovery tools follow a clear progression with no overlap.
All tool names use a verb_noun pattern in snake_case. The verbs vary (get, analyze, generate) but the pattern is consistent and the nouns clearly describe the target resource or action.
Nine tools is well-scoped for an AWS pricing server. It covers the full discovery-to-pricing workflow, plus bulk data access, project analysis, and report generation without unnecessary bloat.
The set covers the complete pricing data lifecycle: discover service codes, attributes, attribute values, fetch current pricing, access historical/bulk data, and generate cost reports. Project analyzers fill the gap of identifying relevant services from code.
Maintenance
Related MCP Connectors
Hosted MCP server for AWS cloud spend: service breakdowns, anomalies, savings and forecasts.
Free hosted MCP server: US healthcare procedure cost estimates and provider pricing. No API key.
Hosted Amazon Seller and Vendor MCP server for Claude, ChatGPT, Cursor, Codex, Gemini, Copilot.
An MCP server giving access to Grafana dashboards, data and more.
Related MCP Servers
- AlicenseNot gradedqualityFmaintenanceAn MCP server that exposes AWS EC2 pricing data with an option to search by CPU, RAM, networking21PythonMIT
- AlicenseBqualityCmaintenanceAn MCP server for unified cost tracking and analysis across AWS, OpenAI, and Anthropic. It enables users to query expenditures, compare costs across providers, and analyze usage trends through natural language.10MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that provides tools for automating AWS Pricing Calculator estimate generation.MIT
- AlicenseAqualityDmaintenanceMCP server for generating upfront AWS service cost estimates and providing cost insights.5Apache 2.0