Skip to main content
Glama
AWS Pricing MCP Server

AWS Pricing MCP Server

by sebdroid

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, no AWS_PROFILE needed

  • No boto3 dependency — uses httpx for direct HTTP requests to the public Bulk API

  • Local filtering — filters are applied locally after fetching price lists, supporting EQUALS, ANY_OF, CONTAINS, and NONE_OF filter types

  • Index-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

  1. Install uv from Astral or the GitHub README

  2. Install Python using uv python install 3.10

No AWS credentials or IAM permissions are needed — this fork uses the public Bulk API.

Installation

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 sync

Then 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

FASTMCP_LOG_LEVEL

WARNING

Log level (ERROR, WARNING, INFO, DEBUG)

AWS_REGION

us-east-1

Fallback region for get_pricing_service_attributes and get_pricing_attribute_values when no region parameter is provided. All three discovery tools accept an explicit region parameter that overrides this.

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 tools
analyze_cdk_projectA
Read-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_projectA
Read-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_reportA
Read-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_patternsA
Read-only

Get architecture patterns for Amazon Bedrock applications, including component relationships and cost considerations

Inputs: no named parameters. Returns: result

get_price_list_urlsA
Read-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_pricingA
Read-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_valuesA
Read-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_attributesA
Read-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_codesA
Read-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

    A4.5/5.0

    Scored across 9 tools

    Disambiguation5/5

    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.

    Naming Consistency5/5

    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.

    Tool Count5/5

    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.

    Completeness5/5

    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

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers