azure-pricing-mcp
Click on "Install 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., "@azure-pricing-mcpwhat is the price of a D2s v3 VM in East US?"
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.
azure-pricing-mcp
An MCP (Model Context Protocol) server that lets LLMs query Azure service pricing using the public Azure Retail Prices API.
No Azure credentials required — the API is free and public.
Quick Start
Run directly with uvx:
uvx azure-pricing-mcpOr install and run:
uv pip install azure-pricing-mcp
azure-pricing-mcpRelated MCP server: Azure Pricing MCP Server
Tools
Tool | Description |
| Search Azure retail prices by service, region, SKU, or product name |
| Estimate monthly cost for a service given quantity and usage hours |
| Compare prices for a service/SKU across Azure regions (sorted cheapest first) |
| Discover available Azure services (with optional text search) |
| List Azure regions (optionally filtered by service) |
All tools support a currency_code parameter (default: USD). Examples: EUR, BRL, GBP, JPY.
Usage Examples
Once connected to an MCP client (Claude Desktop, Cursor, Claude Code, etc.), you can ask:
"What's the price of a D2 v3 VM in East US?"
"Estimate the monthly cost for 5 Standard_LRS storage accounts in West Europe"
"Compare Virtual Machines D4 v3 pricing across all regions"
"List all Azure services related to 'database'"
"What regions offer Azure Cosmos DB?"
Configuration
Using mcp.json (VS Code / GitHub Copilot)
Create an mcp.json file in your project's .vscode folder (.vscode/mcp.json) to share the server with your team:
{
"servers": {
"azure-pricing": {
"command": "uvx",
"args": ["azure-pricing-mcp"]
}
}
}Or add it at the user level (~/.vscode/mcp.json) to make it available across all projects.
Tip: When opening a project with an
mcp.json, VS Code will prompt you to start the MCP server automatically.
Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"azure-pricing": {
"command": "uvx",
"args": ["azure-pricing-mcp"]
}
}
}Claude Code
claude mcp add azure-pricing -- uvx azure-pricing-mcpCursor
Add to your Cursor MCP settings (.cursor/mcp.json):
{
"mcpServers": {
"azure-pricing": {
"command": "uvx",
"args": ["azure-pricing-mcp"]
}
}
}Windsurf
Add to your Windsurf MCP config (~/.windsurf/mcp.json):
{
"mcpServers": {
"azure-pricing": {
"command": "uvx",
"args": ["azure-pricing-mcp"]
}
}
}Development
# Clone and install
git clone https://github.com/pimentelleo/azure-pricing-mcp.git
cd azure-pricing-mcp
uv sync
# Run locally
uv run azure-pricing-mcp
# Test with MCP Inspector
npx -y @modelcontextprotocol/inspector uv run azure-pricing-mcpHow It Works
This server uses the Azure Retail Prices REST API to fetch real-time public pricing data for Azure services. Key characteristics:
No authentication required — the API is publicly accessible
Real-time data — prices are updated regularly by Microsoft
Public retail prices only — does not include enterprise agreements or negotiated rates
Supports all Azure services — VMs, Storage, Databases, Networking, AI/ML, and more
License
MIT
Available Tools
5 toolscompare_regionsA
Compare prices for an Azure service/SKU across multiple regions.
Results are sorted by price (cheapest first).
Args: service_name: Azure service name (e.g. "Virtual Machines") arm_sku_name: ARM SKU name for exact match (e.g. "Standard_D8s_v5") sku_name: SKU display name (e.g. "D2 v3") product_name: Product name for more specific filtering regions: List of region names to compare. If omitted, shows all available regions. currency_code: Currency code (default: USD)
| Name | Required | Description | Default |
|---|---|---|---|
| regions | No | ||
| sku_name | No | ||
| arm_sku_name | No | ||
| product_name | No | ||
| service_name | Yes | ||
| currency_code | No | USD |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that results are sorted by price (cheapest first) and that omitting regions shows all available regions. However, it doesn't mention read-only status, potential side effects, or error behavior, so it's somewhat limited.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description opens with a one-sentence purpose, includes the sorting note, then a clear Args list. Each parameter description is concise and necessary. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema, so return format is covered elsewhere. All 6 parameters are explained with semantics and defaults. The description covers core behavior (sorting, region default). It lacks only usage guidance vs siblings, but that's a separate dimension. Overall quite complete for a query tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has no descriptions (0% coverage), so the description fully compensates. It explains each parameter with examples: service_name (e.g., 'Virtual Machines'), arm_sku_name (exact match), sku_name (display name), product_name (more specific filtering), regions (with default behavior), currency_code (default USD). This provides clear meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description states 'Compare prices for an Azure service/SKU across multiple regions' – a specific verb and resource. It clearly distinguishes from sibling tools like search_prices (single price) or list_regions (just listing regions) by focusing on cross-region price comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives like search_prices or estimate_cost. The use case is implied by the description, but there is no 'use this when' or 'for X, use Y' statement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
estimate_costA
Estimate monthly cost for an Azure service based on quantity and usage hours.
The estimation multiplies the unit retail price by the quantity and hours. For storage or data services priced per GB/month, set hours_per_month to 1.
Args: service_name: Azure service name (e.g. "Virtual Machines") arm_sku_name: ARM SKU name for exact match (e.g. "Standard_D8s_v5") sku_name: SKU display name to narrow down (e.g. "D2 v3") arm_region_name: Azure region (e.g. "eastus") quantity: Number of units (e.g. VM instances, GB of storage). Default: 1 hours_per_month: Usage hours per month (default: 730 = 24/7). Set to 1 for flat monthly rates. currency_code: Currency code (default: USD)
| Name | Required | Description | Default |
|---|---|---|---|
| quantity | No | ||
| sku_name | No | ||
| arm_sku_name | No | ||
| service_name | Yes | ||
| currency_code | No | USD | |
| arm_region_name | No | ||
| hours_per_month | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description explains the calculation formula ('multiplies the unit retail price by the quantity and hours') and the special case for flat monthly rates, which adds behavioral context. However, it does not disclose other traits such as whether the estimate includes discounts, taxes, or if it is a read-only operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-organized: a one-sentence purpose, a short formula explanation, a practical special-case note, and a bulleted parameter list. Every sentence adds value with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, multiple SKU/region combinations), the description covers the key inputs and usage nuances, including how to handle storage pricing. An output schema exists, so return values need not be described here. It is nearly complete, though it could mention that prices vary by region or that SKU matching may require precise naming.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds substantial meaning to every parameter, including clear differentiation between arm_sku_name ('ARM SKU name for exact match') and sku_name ('SKU display name to narrow down'). It also explains the semantics of hours_per_month with a concrete example, which the schema alone does not provide. This fully compensates for the 0% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with 'Estimate monthly cost for an Azure service based on quantity and usage hours', which clearly states the tool's specific function. It distinguishes itself from siblings like search_prices by focusing on cost estimation rather than price lookup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides practical usage hints, such as 'For storage or data services priced per GB/month, set hours_per_month to 1', but it does not explicitly compare to sibling tools or mention when to prefer this over search_prices, list_services, etc. The context is implied but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_regionsA
List available Azure regions.
Args: service_name: If provided, only show regions where this service is available
| Name | Required | Description | Default |
|---|---|---|---|
| service_name | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. The verb 'List' implies a read operation, but the description doesn't explicitly state the operation is safe/read-only, nor does it disclose any response format, pagination, or error behavior. It adds minimal information beyond the basic purpose.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact, front-loaded with the purpose, and includes an args section that is directly useful. Every sentence earns its place, with no redundancy or fluff. The structure is ideal for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and the existence of an output schema, the description is minimally sufficient. It covers the core purpose and parameter semantics, but lacks any extra context such as typical use cases, comparison with siblings, or explicit read-only confirmation. It is adequate but has noticeable gaps for a tool without annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides only the parameter name/type (service_name, string/null, default null) with 0% schema description coverage. The description meaningfully explains the parameter's role: 'If provided, only show regions where this service is available.' This compensation is precise and helpful.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'List available Azure regions,' which is a specific verb+resource statement that clearly distinguishes this tool from its siblings (search_prices, estimate_cost, list_services, compare_regions). It also adds a useful qualifier about filtering by service_name, making the behavior explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for listing Azure regions but provides no explicit guidance on when to use this tool over alternatives like compare_regions or list_services. There is no mention of exclusions or context. The purpose is clear enough to infer, but the tool lacks any direct guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_servicesA
List available Azure services in the pricing API.
Args: search: Optional text to filter service names (case-insensitive substring match)
| Name | Required | Description | Default |
|---|---|---|---|
| search | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the search parameter's case-insensitive substring behavior, but does not mention pagination, result limits, ordering, or whether it returns only service names or additional metadata. This is a gap for a list operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is succinct: a one-sentence purpose and a clearly formatted args block. Every piece of text adds value, with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and an output schema, the description is reasonably complete. It covers the core purpose and parameter semantics, and the output schema handles return values. However, it does not address how this tool fits into the larger pricing API workflow, though that is not critical for basic use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by thoroughly explaining the only parameter 'search', including its optionality and case-insensitive substring matching. This adds meaningful value beyond the schema's type/default info.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'List available Azure services in the pricing API.' It uses a specific verb and resource, and is distinct from sibling tools like list_regions (regions) or search_prices (prices).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (when you need a list of Azure services) but provides no explicit guidance on when to prefer this tool over alternatives like search_prices or estimate_cost. It does not mention any exclusions or integration context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_pricesA
Search Azure retail prices by service, region, SKU, or product name.
Args: service_name: Azure service name (e.g. "Virtual Machines", "Storage") arm_region_name: Azure region (e.g. "eastus", "westeurope", "brazilsouth") arm_sku_name: ARM SKU name for exact match (e.g. "Standard_D8s_v5", "Standard_B2s") sku_name: SKU display name (e.g. "D2 v3", "Standard_LRS"). Use arm_sku_name for exact VM matching. product_name: Product name (e.g. "Virtual Machines Dv3 Series") price_type: Price type filter: "Consumption" (pay-as-you-go), "Reservation" (reserved instances), or "DevTestConsumption" currency_code: Currency code (default: USD). Examples: USD, EUR, BRL, GBP max_results: Maximum number of results to return (default: 10, max: 50)
| Name | Required | Description | Default |
|---|---|---|---|
| sku_name | No | ||
| price_type | No | ||
| max_results | No | ||
| arm_sku_name | No | ||
| product_name | No | ||
| service_name | No | ||
| currency_code | No | USD | |
| arm_region_name | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It adds useful details like max_results caps and the exact-match semantics of arm_sku_name, but it does not explicitly state that the tool is read-only, how results are returned, or potential rate limits/side effects. This is a moderate level of transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a one-sentence summary followed by a clean Args list. Every line is informative, using brief but concrete examples, with no fluff or repetition. It is appropriately sized for an 8-parameter search tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description thoroughly documents all parameters and the main purpose, and an output schema exists so return specifics are not needed. However, it lacks guidance on when to choose this tool over sibling tools (e.g., estimate_cost, compare_regions), which is a notable gap given the sibling set and absence of annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates richly. Every parameter is documented with examples and clarifications (e.g., 'Use arm_sku_name for exact VM matching', price_type options, currency examples). This adds substantial meaning beyond the bare schema properties.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Search Azure retail prices by service, region, SKU, or product name' — a specific verb and resource with explicit filter criteria. It distinguishes itself from sibling tools (estimate_cost, list_services, etc.) by focusing on searching prices rather than estimating, listing, or comparing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like estimate_cost or compare_regions. The description explains what the tool does but does not offer exclusions, prerequisites, or alternative tool recommendations, leaving the agent to infer usage solely from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
5 tool updates
v0.1.3- First observed
compare_regions - First observed
estimate_cost - First observed
list_regions - First observed
list_services - First observed
search_prices
TDQS
Each tool has a clear, distinct purpose: searching prices, estimating costs, listing services, listing regions, and comparing regional prices. No two tools overlap in a way that would cause an agent to pick the wrong one.
All tool names follow a consistent verb_noun pattern with lowercase and underscores (search_prices, estimate_cost, list_services, list_regions, compare_regions). This makes the API predictable and easy to navigate.
With 5 tools, the server is well-scoped for its purpose. Each tool addresses a core aspect of Azure pricing: discovery, search, estimation, and regional comparison, without unnecessary redundancy.
The tool surface covers the main pricing workflow: discovering services and regions, searching for price data, comparing prices across regions, and estimating costs. No significant gaps are apparent for a read-only pricing API.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Pay-per-use tool marketplace for AI agents. Search, price-check, and call APIs via MCP.
Live LLM API pricing: token prices, comparisons, cheapest-model lookups. No key required.
Extract structured pricing tiers and addons from any SaaS pricing page URL. Built for AI agents.
Verified cloud cost forecasting for AI agents. AWS, GCP, Azure pricing matrix.
Related MCP Servers
- AlicenseAqualityDmaintenanceProvides AI assistants with real-time access to Azure retail pricing information, enabling price searches, regional cost comparisons, monthly bill estimates, and SKU discovery through natural language queries.1355MIT
- FlicenseNot gradedqualityDmaintenanceEnables querying Azure retail pricing information, comparing costs across regions and SKUs, estimating usage-based expenses, and discovering Azure services with savings plan information through the Azure Retail Prices API.16-
- AlicenseAqualityBmaintenanceEnables coding agents to query AI model API prices, including historical point-in-time lookups with cited sources, using a bundled dated dataset and requiring no API keys.579MIT
- FlicenseNot gradedqualityDmaintenanceEnables cost analysis, price comparison across regions, and savings plan calculations for Azure services through the Azure Retail Prices API.-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/pimentelleo/azure-pricing-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server