USAspending MCP Server
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., "@USAspending MCP ServerFind top recipients for semiconductor spending in FY2025"
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.
USAspending MCP Server
Read-only Model Context Protocol server for exploring federal spending through the USAspending.gov API.
Use it from Claude Desktop, Codex, Cursor, VS Code, or any MCP-compatible AI tool to ask questions like:
"Which agencies awarded the most climate-related obligations in FY2025?"
"Find top recipients for semiconductor-related federal spending."
"Show spending over time for affordable housing."
"Get the details behind this USAspending award ID."
"Search transactions for Department of Energy clean energy awards."
USAspending.gov does not require an API key for these endpoints. This server is intentionally read-only and uses local stdio transport.
Why This Exists
USAspending.gov is powerful, but the API has many endpoints and detailed filter shapes. This MCP server gives AI agents a safer, typed tool layer for common federal-spending workflows:
agency and recipient lookup
award and transaction search
spending aggregation by category, geography, and time
award profile lookup
recipient new-award momentum
safe generic calls for documented
/api/v2/endpoints
It is useful for public-sector market analysis, policy research, impact-investing screens, federal contractor diligence, grant monitoring, and thematic government-spending research.
Related MCP server: USA Spending MCP Server
Tools
Tool | What it does |
| List federal toptier agencies and summary budgetary fields. |
| Find recipient names, UEIs, and DUNS values. |
| Find awarding or funding agency offices. |
| Search awards/subawards with Advanced Search filters and selected fields. |
| Aggregate spending by agency, recipient, NAICS, PSC, federal account, state, and more. |
| Aggregate by state, county, district, or country. |
| Aggregate by fiscal year, calendar year, quarter, or month. |
| Count new awards for a recipient by fiscal year, quarter, or month. |
| Search individual transaction records. |
| Count matching transactions by award category. |
| Fetch detailed award profile data. |
| Safely call documented read-only |
The generic endpoint tool blocks job/file-generating download paths, while allowing the read-only /api/v2/download/count/ preflight endpoint.
Requirements
Node.js 20 or newer
npm
No USAspending API key is required.
Install From Source
git clone https://github.com/haydentbs/usaspending-mcp-server.git
cd usaspending-mcp-server
npm install
npm run buildRun a live API smoke test:
npm run smokeRun the MCP regression suite:
npm run test:mcpAdd It To An AI Tool
Build the project first, then point your MCP client at dist/index.js.
Claude Desktop
Add this to your Claude Desktop MCP config:
{
"mcpServers": {
"usaspending": {
"command": "node",
"args": ["/absolute/path/to/usaspending-mcp-server/dist/index.js"]
}
}
}On macOS, Claude Desktop config is commonly located at:
~/Library/Application Support/Claude/claude_desktop_config.jsonRestart Claude Desktop after editing the config.
Codex
Add this to ~/.codex/config.toml:
[mcp_servers.usaspending]
command = "node"
args = ["/absolute/path/to/usaspending-mcp-server/dist/index.js"]Restart or reload your Codex session so the new MCP namespace is discovered.
Cursor, VS Code, And Other MCP Clients
Most MCP clients use the same server definition shape:
{
"mcpServers": {
"usaspending": {
"command": "node",
"args": ["/absolute/path/to/usaspending-mcp-server/dist/index.js"]
}
}
}If your tool supports per-project MCP config, place the same server definition there. If it supports global config, add it globally.
Example Prompts
After connecting the MCP server, try:
List the top FY2025 awarding agencies for clean energy spending.Compare FY2021-FY2025 federal spending over time for semiconductor-related awards.Find the top recipients for wastewater-related spending in FY2025 and show their NAICS concentration.Search FY2025 Department of Energy contract awards mentioning hydrogen and return award IDs, recipients, amounts, and descriptions.Example Filters
USAspending Advanced Search filters are passed through as JSON. Most analysis should include an explicit time_period.
Defense contract awards in FY2025:
{
"filters": {
"time_period": [{ "start_date": "2024-10-01", "end_date": "2025-09-30" }],
"agencies": [{ "type": "awarding", "tier": "toptier", "name": "Department of Defense" }],
"award_type_codes": ["A", "B", "C", "D"]
},
"limit": 10,
"page": 1
}Spending by NAICS for a keyword:
{
"category": "naics",
"filters": {
"keywords": ["semiconductor"],
"time_period": [{ "start_date": "2024-10-01", "end_date": "2025-09-30" }]
}
}Recipient new-award trend:
{
"group": "fiscal_year",
"filters": {
"recipient_id": "5ad7895c-192b-21cd-8baf-92c6dce0b593-C",
"time_period": [{ "start_date": "2020-10-01", "end_date": "2025-09-30" }]
}
}Notes And Limitations
USAspending values are obligations/outlays from federal reporting, not company revenue.
Keyword screens are directional. For production research, combine keywords with NAICS, PSC, agency, assistance listing, and award-type filters.
Some USAspending endpoints enforce award-type group constraints. For example, award search should not mix contracts, grants, loans, direct payments, and IDVs in a single
award_type_codesfilter.Large federal-spending queries can be slow. The server uses a request timeout, configurable with
USASPENDING_TIMEOUT_MS.
Development
npm install
npm run build
npm run test:mcpRun the server locally:
npm startRun against TypeScript source during development:
npm run devLicense
MIT
Available Tools
12 toolsusaspending_autocomplete_agencyAutocomplete USAspending AgenciesCRead-onlyIdempotent
Search awarding or funding agency offices for USAspending AdvancedFilterObject agency filters.
| Name | Required | Description | Default |
|---|---|---|---|
| search_text | Yes | ||
| agency_kind | No | awarding | |
| limit | No | ||
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, so the safety profile is clear. The description adds that it searches 'awarding or funding agency offices', which provides some behavioral context, but does not disclose rate limits, pagination, or empty result behavior. No contradiction with annotations.
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 a single, concise sentence that front-loads the key purpose. Every word serves a function, with no fluff. However, it could be slightly more structured for readability.
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 no output schema and low parameter coverage, the description lacks sufficient context. It does not explain the return format (autocomplete suggestions), the meaning of results, or how to interpret agent responses. Important details like the 'response_format' parameter's effect are left to the schema.
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?
With only 25% schema description coverage (only response_format has a description), the description should compensate, but it does not explain search_text (format/length), agency_kind (beyond enum), or limit. The phrase 'awarding or funding agency offices' hints at agency_kind usage, but it is insufficient for the four parameters.
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 uses a specific verb 'Search' and identifies the resource 'awarding or funding agency offices', which clearly distinguishes it from sibling tools like 'usaspending_autocomplete_recipient'. However, the mention of 'AdvancedFilterObject agency filters' is somewhat jargon-heavy.
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, nor are there any exclusions or prerequisites. The description fails to indicate that this is specifically for autocomplete suggestions, which could lead to misuse.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_autocomplete_recipientAutocomplete USAspending RecipientsARead-onlyIdempotent
Search recipient names, UEIs, and DUNS values for use in USAspending filters.
| Name | Required | Description | Default |
|---|---|---|---|
| search_text | Yes | ||
| limit | No | ||
| recipient_levels | No | ||
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate read-only, non-destructive, idempotent behavior. The description adds context about searching specific identifiers, but does not detail partial matching or case sensitivity.
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?
Single sentence that conveys the core purpose efficiently with no superfluous 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?
Given the 4 parameters and lack of output schema, the description provides only basic context; more detail on return structure or parameter options would improve completeness.
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 low (25% only for response_format). The description does not elaborate on search_text, limit, or recipient_levels beyond the schema, leaving their semantics unclear.
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 action ('Search') and the resource ('recipient names, UEIs, and DUNS values'), distinguishing it from sibling tools that autocomplete agencies.
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 vs. alternatives (e.g., autocomplete_agency) is provided, but the name and description imply its purpose for filtering recipients.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_call_endpointCall Safe USAspending EndpointARead-onlyIdempotent
Call a documented read-only USAspending v2 endpoint that is not covered by a purpose-built tool. Blocks download and bulk_download paths. Use only with official /api/v2/ endpoints.
| Name | Required | Description | Default |
|---|---|---|---|
| method | No | GET | |
| endpoint_path | Yes | ||
| body | No | Raw USAspending API JSON object. Use official field names from the endpoint docs. | |
| query | No | ||
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that it blocks download and bulk_download paths, which is useful behavioral context beyond what annotations provide.
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 two concise sentences, front-loading the purpose and constraints without any unnecessary 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?
For a general endpoint-calling tool with good annotations and sibling tools covering common cases, the description is mostly complete. It could mention that the tool returns the API response, but overall it provides sufficient context.
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 40%, but the tool description does not add parameter-level details for method, endpoint_path, or query. Only body and response_format have schema descriptions. The description lacks explanation of parameter usage and constraints.
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 calls a documented read-only USAspending v2 endpoint not covered by purpose-built tools. It distinguishes from siblings by specifying it is for endpoints lacking dedicated tools.
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 says to use only with official /api/v2/ endpoints and implies using purpose-built tools when available. However, it does not explicitly list alternative tools or provide when-not-to-use scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_count_transactionsCount USAspending TransactionsARead-onlyIdempotent
Count matching transaction records grouped by award category: contracts, grants, direct payments, loans, IDVs, and other.
| Name | Required | Description | Default |
|---|---|---|---|
| filters | No | USAspending AdvancedFilterObject. Common keys include time_period, keywords, agencies, recipient_search_text, award_type_codes, award_ids, naics_codes, psc_codes, and place_of_performance_locations. Specify an explicit time_period for time-sensitive analysis. | |
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds that the tool groups results by award category, providing behavioral context beyond the annotations. No contradictions.
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 a single sentence that directly states the tool's purpose and key behavior. No unnecessary words, and it is efficiently front-loaded.
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 (two parameters, no output schema, good annotations), the description adequately covers the core functionality and return structure. Minor improvement could be specifying the exact output format or example categories.
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 coverage is 100%, so baseline 3 applies. The description does not add extra meaning to the parameters; it only explains the output grouping. The parameters are well-described in the schema itself.
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 counts transaction records and groups them by award category (contracts, grants, etc.). This specific verb+resource+grouping distinguishes it from siblings like search_awards or search_transactions which retrieve lists, not grouped counts.
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 use for grouped counts but does not explicitly state when to use this tool over alternatives like usaspending_spending_by_category or usaspending_search_awards. No exclusions or context for when not to use it are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_get_awardGet USAspending Award DetailBRead-onlyIdempotent
Get detailed USAspending award profile data by generated unique award ID or internal award database ID.
| Name | Required | Description | Default |
|---|---|---|---|
| award_id | Yes | ||
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey readOnly, idempotent, and openWorld hints. Description adds no further behavioral details (e.g., rate limits, data freshness). No contradiction with annotations.
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?
Single sentence, no redundancy, direct. Front-loaded with verb and resource.
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?
Adequate for a simple read-only tool with good annotations, but could mention typical usage or field coverage. No output schema increases burden slightly.
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?
Description clarifies the purpose of award_id (by unique ID or database ID), but does not describe response_format beyond schema. Schema covers 50% of parameters, and description partially compensates.
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 clearly states the tool retrieves detailed award profile data by award ID or internal database ID. It distinguishes from search-oriented siblings like usaspending_search_awards, though not explicitly.
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 on when to use this tool vs alternatives. Does not mention prerequisites, limitations, or exclude cases like unknown awards.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_list_toptier_agenciesList USAspending Toptier AgenciesARead-onlyIdempotent
List federal toptier agencies with current USAspending budgetary, obligation, and outlay summary fields. No authentication required.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true. Description adds only 'no authentication required,' which is useful but minimal. Does not mention rate limits, pagination, or response size despite limit parameter.
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?
Two concise sentences: first states purpose and result, second states authentication requirement. No fluff, front-loaded with essential information.
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 list tool with no output schema, description covers core purpose and authentication. Lacks details on default sort order, data freshness (real-time vs cached), or how many agencies are typically returned. Sufficient for basic understanding but not fully complete.
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 2 parameters with 50% description coverage (response_format described, limit not). Tool description provides no parameter details, failing to compensate for undocumented limit parameter. Agents must infer limit usage from constraints alone.
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 clearly states verb (list), resource (federal toptier agencies), and specific data fields (budgetary, obligation, outlay summary). Distinguishes from sibling autocomplete tool by focusing on listing all toptier agencies with summary fields.
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?
States 'no authentication required' but does not specify when to use this tool versus alternatives like usaspending_autocomplete_agency or search tools. Implicitly, it's for getting an overview of all agencies, but lacks explicit comparison or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_new_awards_over_timeCount New USAspending Awards Over TimeARead-onlyIdempotent
Count new awards for a specific USAspending recipient over fiscal years, quarters, or months. Requires a recipient_id hash such as values returned by /api/v2/recipient/duns/.
| Name | Required | Description | Default |
|---|---|---|---|
| group | No | quarter | |
| filters | Yes | ||
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint, covering core behavioral traits. The description adds context about the recipient_id source but does not explain limitations like 'new' award definition, pagination, or zero-count behavior. Overall adequate but not enriched beyond annotations.
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 two sentences with no superfluous words. It front-loads the core purpose and immediately follows with a critical prerequisite. Every sentence earns its place.
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?
Despite the tool's complexity (grouping, date ranges, counting), the description lacks details on return format, definition of 'new awards', or handling of edge cases. No output schema exists, and the openWorldHint is not explained. The description is insufficient for a non-trivial counting 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 description coverage is low (33%), and the description only adds meaning for the recipient_id parameter by linking to the DUNS endpoint. The group and response_format parameters are not mentioned, and time_period is not explained beyond its schema description. The description does not compensate for the schema gaps.
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 'Count new awards for a specific USAspending recipient over fiscal years, quarters, or months.' It uses a specific verb ('count') and resource ('new awards'), and implies distinction from sibling tools that handle spending or search. The mention of requiring a recipient_id hash adds specificity.
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 a prerequisite (recipient_id hash from another endpoint) but lacks explicit guidance on when to use this tool versus alternatives like usaspending_spending_over_time. It doesn't state when not to use or compare with siblings, only implying usage from the purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_search_awardsSearch USAspending AwardsARead-onlyIdempotent
Search prime awards or subawards with USAspending AdvancedFilterObject filters and selected fields. Use for questions like top awards for a recipient, agency, date range, award type, NAICS, PSC, or keyword.
| Name | Required | Description | Default |
|---|---|---|---|
| filters | No | USAspending AdvancedFilterObject. Common keys include time_period, keywords, agencies, recipient_search_text, award_type_codes, award_ids, naics_codes, psc_codes, and place_of_performance_locations. Specify an explicit time_period for time-sensitive analysis. | |
| fields | No | Fields to return. Examples: Award ID, Recipient Name, Award Amount, Awarding Agency, Description, generated_internal_id. | |
| limit | No | Results per page. | |
| page | No | Page number to return. | |
| sort | No | ||
| order | No | desc | |
| spending_level | No | awards | |
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the tool as read-only and non-destructive. The description adds context about searching both prime awards and subawards, but does not disclose potential behavioral traits like pagination limits, rate constraints, or data freshness. Given the annotation coverage, the description adds moderate value.
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 two sentences with no unnecessary words. It front-loads the core action and immediately provides use-case examples, making it efficient for an agent to quickly understand the tool's purpose.
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 (8 parameters, nested filter object, no output schema), the description gives a high-level overview but lacks details on constructing the filter object, handling pagination, or understanding the response structure. It is adequate but not comprehensive.
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 mentions the 'AdvancedFilterObject' and provides example keys, adding value beyond the schema's parameter descriptions. However, with 63% schema coverage, it does not fully compensate for missing descriptions on parameters like 'sort' or 'spending_level'. The examples help but are not exhaustive.
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 searches prime awards or subawards using AdvancedFilterObject filters and selected fields, with concrete use case examples. It effectively distinguishes from sibling tools like usaspending_search_transactions or usaspending_get_award by specifying the scope.
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 explicit examples of when to use the tool ('top awards for a recipient, agency, date range...'), which guides the agent. However, it does not explicitly state when not to use it or compare with sibling alternatives, leaving room for improvement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_search_transactionsSearch USAspending TransactionsARead-onlyIdempotent
Search individual transaction records with USAspending AdvancedFilterObject filters. Use when award-level results are too aggregated and you need action dates, modifications, or transaction amounts.
| Name | Required | Description | Default |
|---|---|---|---|
| filters | No | USAspending AdvancedFilterObject. Common keys include time_period, keywords, agencies, recipient_search_text, award_type_codes, award_ids, naics_codes, psc_codes, and place_of_performance_locations. Specify an explicit time_period for time-sensitive analysis. | |
| fields | No | Transaction fields to return. Examples: Award ID, Mod, Recipient Name, Action Date, Transaction Amount, Awarding Agency, Award Type. | |
| limit | No | Results per page. | |
| page | No | Page number to return. | |
| sort | No | Transaction Amount | |
| order | No | desc | |
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint. The description adds that it searches individual transaction records and mentions result fields, consistent with annotations. No contradictions.
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?
Two sentences directly addressing purpose and usage. No wasted words; front-loaded with the key verb and resource.
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 params, nested objects) and lack of output schema, the description covers purpose and usage well but could elaborate on filter structure. Remains sufficient for most use cases.
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 71%. The description adds minimal param insight beyond the schema, though it does note to specify time_period for time-sensitive analysis. Baseline score of 3 is appropriate.
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 it searches individual transaction records and specifies the use case when award-level results are too aggregated, distinguishing from sibling tools like usaspending_search_awards.
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?
Explicitly says when to use: when award-level results are too aggregated and you need action dates, modifications, or transaction amounts. Provides clear context but no when-not-to-use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_spending_by_categoryAggregate USAspending By CategoryBRead-onlyIdempotent
Aggregate obligations/outlays by category such as awarding_agency, recipient_duns, naics, psc, federal_account, state_territory, cfda, or defc.
| Name | Required | Description | Default |
|---|---|---|---|
| category | Yes | ||
| filters | No | USAspending AdvancedFilterObject. Common keys include time_period, keywords, agencies, recipient_search_text, award_type_codes, award_ids, naics_codes, psc_codes, and place_of_performance_locations. Specify an explicit time_period for time-sensitive analysis. | |
| limit | No | Results per page. | |
| page | No | Page number to return. | |
| spending_level | No | transactions | |
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, so the description is not required to repeat safety traits. It adds no further behavioral context (e.g., data freshness, rate limits), but does not contradict annotations.
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 a single sentence that is concise and front-loaded with the key verb 'Aggregate'. It could be more informative by adding a differentiating sentence, but the current structure is efficient and clear.
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 (6 parameters, nested filters, 3 enums for category, no output schema), the description is too minimal. It lacks details on output format, filter usage, and category semantics, leaving the agent with insufficient context for effective 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 67% (4/6 parameters have descriptions in schema). The tool description adds examples of category values but does not describe other parameters like spending_level, response_format, or the complex filters object. It provides marginal added value 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?
The description clearly states that the tool aggregates obligations/outlays by a specified category, listing examples. However, it does not differentiate from sibling tools like usaspending_spending_by_geography or usaspending_spending_over_time, which have similar purposes but different category scopes.
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 no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or constraints. Sibling tools are listed but not referenced, leaving the agent without decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_spending_by_geographyAggregate USAspending By GeographyARead-onlyIdempotent
Aggregate spending by state, county, congressional district, or country using place of performance or recipient location.
| Name | Required | Description | Default |
|---|---|---|---|
| filters | No | USAspending AdvancedFilterObject. Common keys include time_period, keywords, agencies, recipient_search_text, award_type_codes, award_ids, naics_codes, psc_codes, and place_of_performance_locations. Specify an explicit time_period for time-sensitive analysis. | |
| scope | No | place_of_performance | |
| geo_layer | No | state | |
| geo_layer_filters | No | ||
| spending_level | No | transactions | |
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the description does not need to repeat them. The description adds context about aggregation but no extra behavioral details. No contradiction.
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?
A single, clear sentence with no fluff. Title and description are front-loaded and efficient.
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?
No output schema exists, yet the description does not explain the output format or structure. The response_format parameter hints at options but is not described. The tool has 6 parameters and nested filters, but the description only gives a high-level overview.
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 coverage is low (33%), but the description adds no explanations for the 4 parameters with enums (scope, geo_layer, spending_level, geo_layer_filters). Only filters and response_format have schema descriptions.
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 aggregates spending by geography (state, county, district, country) using place of performance or recipient location. It effectively distinguishes from sibling tools like spending_by_category and spending_over_time.
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 geographic aggregation but provides no explicit guidance on when to use this tool versus alternatives, nor any prerequisites or limitations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usaspending_spending_over_timeAggregate USAspending Over TimeCRead-onlyIdempotent
Aggregate obligations and outlays over fiscal years, calendar years, quarters, or months for a USAspending filter set.
| Name | Required | Description | Default |
|---|---|---|---|
| group | No | fiscal_year | |
| filters | No | USAspending AdvancedFilterObject. Common keys include time_period, keywords, agencies, recipient_search_text, award_type_codes, award_ids, naics_codes, psc_codes, and place_of_performance_locations. Specify an explicit time_period for time-sensitive analysis. | |
| spending_level | No | transactions | |
| response_format | No | Output format: markdown for readable summaries, json for raw structured data. | markdown |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, non-destructive, idempotent behavior. The description adds that it aggregates spending data, which is consistent but does not disclose additional behavioral traits such as rate limits, data freshness, or pagination. No contradiction with annotations.
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?
A single, clear sentence that efficiently conveys the core functionality. No redundancy or unnecessary 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?
No output schema exists, yet the description does not explain what the aggregated output looks like (e.g., time series, totals, format). With 4 parameters including nested filters, more detail on output structure is needed for an agent to use the tool effectively.
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 50% (only filters and response_format have descriptions). The tool description does not explain parameters beyond what's in the schema. It mentions 'filter set' but adds no new meaning for group, spending_level, or response_format.
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 it aggregates obligations and outlays over time periods (fiscal years, calendar years, quarters, months) using a filter set. It distinguishes itself from siblings like usaspending_new_awards_over_time by focusing on obligations/outlays rather than new awards, but does not highlight this distinction explicitly.
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 on when to use this tool versus alternatives like usaspending_new_awards_over_time or usaspending_spending_by_category. No mention of prerequisites, contexts, or limitations.
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.
12 tool updates
v0.1.0- First observed
usaspending_autocomplete_agency - First observed
usaspending_autocomplete_recipient - First observed
usaspending_call_endpoint - First observed
usaspending_count_transactions - First observed
usaspending_get_award - First observed
usaspending_list_toptier_agencies - First observed
usaspending_new_awards_over_time - First observed
usaspending_search_awards - First observed
usaspending_search_transactions - First observed
usaspending_spending_by_category - First observed
usaspending_spending_by_geography - First observed
usaspending_spending_over_time
TDQS
Scored across 12 tools
Each tool targets a distinct operation on USAspending data, from autocomplete to searching, counting, and aggregation. No two tools have overlapping purposes, ensuring clear selection by an agent.
All tools follow a consistent 'usaspending_verb_noun' pattern with snake_case, making it predictable which action and resource a tool handles.
With 12 tools covering core operations on federal spending data, the count is well-scoped. Each tool serves a clear purpose without unnecessary redundancy.
The tool set covers all major aspects of USAspending: autocomplete, search, count, aggregation, and listing, plus a generic endpoint caller for edge cases. There are no obvious gaps for common queries.
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
USAspending MCP — Federal spending data from USAspending.gov API
Access US federal award, recipient, agency, and spending analytics data from USAspending.gov.
MCP access to the U.S. federal procurement graph: contracts, opportunities, entities, and more.
Search verified-open US grants (federal, state, foundation). Read-only MCP for AI agents.
Related MCP Servers
- FlicenseNot gradedqualityCmaintenanceMCP server for querying U.S. Federal Procurement Data System (FPDS-NG) to search federal contract actions by keyword, agency, NAICS, or vendor, with USDC micropayments via x402.-

USA Spending MCP Serverofficial
FlicenseBqualityDmaintenanceAn MCP server for interacting with the USAspending.gov API, supporting local use with Claude Desktop and cloud deployment with login.gov authentication.310-- AlicenseNot gradedqualityDmaintenanceA free, key-less MCP server for querying U.S. federal spending data from USAspending.gov, including contracts, grants, loans, recipients, agencies, and geographic breakdowns.MIT
- AlicenseNot gradedqualityAmaintenanceAccess US federal award, recipient, agency, and spending analytics data from USAspending.gov via MCP, with 18 tools for searching and retrieving detailed records.3253Apache 2.0