fec-mcp-server
The FEC MCP Server provides tools to research and analyze U.S. federal campaign finance data from the FEC API:
Search Candidates (
search_candidates): Find federal candidates by name, election year, office (House/Senate/President), state, or party.Get Committee Finances (
get_committee_finances): Retrieve financial summaries including receipts, disbursements, cash on hand, debts, loans, and burn rate.Get Receipts (
get_receipts): Access itemized contributions (Schedule A) with donor details, PAC classification, and optional notable analysis.Get Disbursements (
get_disbursements): Retrieve itemized expenditures (Schedule B) filterable by amount or purpose, with optional notable analysis.Get Independent Expenditures (
get_independent_expenditures): Track Super PAC/outside group spending (Schedule E) for or against candidates, filterable by support/oppose indicator.Get Committee Flags (
get_committee_flags): Check committees for compliance red flags like RFAIs, amended filings, and late reports.Search Donors (
search_donors): Find individual donors across all FEC filings by name, employer, or occupation.Search Spending (
search_spending): Search campaign expenditures across all committees by description or recipient to identify spending patterns.
FEC MCP Server
fec-mcp-server is a command-line Model Context Protocol server for federal campaign-finance research. It has no web interface. It queries the OpenFEC API and returns formatted text for an MCP client.
Install and configure
Install Node.js 20 or later. Get an API key from the OpenFEC developer site. Keep the key private.
npm install -g fec-mcp-serverSet FEC_API_KEY in the MCP server environment. For example, this Claude Desktop configuration starts the installed command-line server.
{
"mcpServers": {
"fec": {
"command": "fec-mcp-server",
"env": {
"FEC_API_KEY": "your-api-key-here"
}
}
}
}You can also run the package through npx fec-mcp-server.
Related MCP server: @cyanheads/openfec-mcp-server
Tools
The server exposes eight tools.
search_candidatesfinds federal candidate records and principal committee IDs.get_committee_financesreturns cycle totals and latest final-report balances.get_receiptsreturns itemized Schedule A receipts for one committee.get_disbursementsreturns itemized Schedule B disbursements for one committee.get_independent_expendituresreturns Schedule E spending by a committee or against or for a candidate.get_committee_flagslists RFAI and amended-filing records for one committee.search_donorssearches individual Schedule A records across committees.search_spendingsearches Schedule B records across committees.
Resolve a candidate or committee before you request committee-level data. Keep cycle and two_year_transaction_period equal when you compare a financial summary with receipts or disbursements.
Output and result limits
Each transaction or search query returns one OpenFEC page. The displayed "showing" value is the number of rows in that response. The accompanying count comes from OpenFEC pagination. It does not mean that the tool returned every matching filing.
OpenFEC limits each API call to 100 results per page. The tools that accept limit accept values from 1 through 100. Their default is 20. Large OpenFEC result counts can be approximate. Narrow the query before you draw a conclusion.
Continue a result set
These tools support continuation: search_candidates, get_receipts, get_disbursements, get_independent_expenditures, search_donors, and search_spending. When OpenFEC supplies continuation state, the result includes a paste-ready value such as {"continuation":"fecp1..."}. Pass the token as the tool's continuation field in the next call.
Continuation tokens are unsigned, stateless, opaque cursors. The server binds each token to the effective filters and the tool that created it. If you change a filter or use the token with another tool, the server rejects the request before it calls OpenFEC. Candidate continuation uses OpenFEC page numbers. Transaction continuation uses OpenFEC keyset cursor values. A final nonempty keyset page can include another token. Continue until the footer says Continuation: none; the terminal response can contain no records. Candidate page contents are not guaranteed to remain stable across OpenFEC refreshes.
The footer reports the OpenFEC count status as exact, approximate, or unspecified. Exact counts are marked exact (N records). Approximate counts are marked approximate (N reported records). Missing or unclassified counts are marked unspecified (or unspecified (N reported records) when OpenFEC supplies a value). The response preserves source record IDs and URLs returned by OpenFEC. Treat those IDs and URLs as upstream evidence, not as values created by this package.
get_committee_finances uses /committee/{id}/totals/ for cycle receipts, disbursements, contribution categories, and loan values. It uses the latest final report for cash and debt balances. Every amount is labeled by its period model. get_committee_flags reports filing records. An RFAI or amendment is a review lead, not proof of a violation.
Docker
Build the command-line server image locally.
docker build -t fec-mcp-server .Run the image with an API key.
docker run --rm -i -e FEC_API_KEY=your-api-key-here fec-mcp-serverData freshness and use
OpenFEC updates its data nightly. Its API cache can delay a refreshed value for up to one hour. Treat a result as a dated API response, not a real-time ledger. The base limit for a registered API key is 1,000 requests per hour. See the OpenFEC documentation and the api.data.gov developer manual for current limits and API-key rules.
Attribute official records to the Federal Election Commission and OpenFEC. This package does not alter the source of record. Review the FEC Terms of Service and FEC Acceptable Use Policy before you use the API. The policy restricts commercial use of campaign-finance data. Federal law also restricts contributor-data use for commercial purposes and contribution solicitations. Keep API keys private. Keep contributor data within the approved research purpose.
Optional analyst enrichment
get_receipts and get_disbursements can add a flagged-notables block when you explicitly set include_notable: true. This block uses bundled third-party analyst reference data. It is not FEC data, a legal finding, or a factual classification. Treat each flag as a lead. Confirm it with the official filing fields and an independent source before you report it.
The four bundled CSV snapshots are derived from DGA-Research/FEC_Coder_Project_Streamlit under Databases/. The provenance manifest records the import commit, date, hashes, method, and recorded license status. The source has no recorded license in this package. Review rights before you redistribute or refresh the snapshots.
Development
npm install
npm run build
npm run typecheck
npm testLicense
MIT. See LICENSE.
Available Tools
8 toolsget_committee_financesA
Retrieve comprehensive financial summary for a campaign committee from official FEC filings. Returns total receipts, disbursements, cash on hand, debts, loans (including candidate loans), and calculates burn rate (spending/income ratio). Includes Schedule C loans and Schedule D debts for complete financial picture. Essential for understanding campaign financial health and transparency research.
| Name | Required | Description | Default |
|---|---|---|---|
| committee_id | Yes | FEC committee ID (e.g., "C00401224") | |
| cycle | No | Two-year election cycle (e.g., 2024). Defaults to most recent. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It details the returned metrics (receipts, disbursements, cash, debts, loans, burn rate) and mentions Schedule C/D inclusion. Does not disclose potential limitations like data freshness or rate limits, but is thorough for a read tool.
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?
Three sentences with no waste. The main action is first, followed by contents, then use case. Efficient and well-structured.
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, so description explains return values clearly. Covers the main aspects of the financial summary, but missing details on error handling or pagination, which may be acceptable for this 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 covers 100% of parameters with descriptions. The description adds no extra meaning beyond the schema; it restates the default for cycle which is already in 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?
Clearly states it retrieves a comprehensive financial summary for a campaign committee from official FEC filings. Specific verb, resource, and scope distinguish it from more specific sibling tools like get_disbursements and get_receipts.
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 it is essential for understanding campaign financial health and transparency research, implying the appropriate use case. However, it does not explicitly exclude when to use sibling tools for detailed breakdowns.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_committee_flagsA
Check a campaign committee for compliance red flags including RFAIs (Requests for Additional Information from the FEC) and amended filings. Essential for identifying campaign finance compliance issues that merit closer research review.
| Name | Required | Description | Default |
|---|---|---|---|
| committee_id | Yes | FEC committee ID to check for compliance flags | |
| cycle | No | Two-year election cycle to check (e.g., 2024) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description indicates a read-only check for specific flag types, but does not detail side effects, auth requirements, or rate limits. Adequate but not exhaustive.
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, front-loaded with action and purpose, no superfluous content.
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?
Simple tool with two parameters and no output schema; description covers purpose, output type, and rationale. Lacks mention of return format or pagination, but sufficient for a straightforward check.
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?
Input schema has 100% coverage with clear descriptions for both parameters. Description adds no semantic value beyond what schema provides, meeting baseline.
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 explicitly states it checks a campaign committee for compliance red flags (RFAIs, amended filings). Clearly distinguishes from sibling tools that focus on financial data.
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 it is essential for identifying compliance issues meriting closer review, implying use when investigating compliance. While it doesn't explicitly exclude scenarios, the context is clear given sibling tool names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_disbursementsA
Retrieve itemized expenditures (Schedule B) made by a campaign committee. Shows payment recipients, amounts, and stated purposes. Supports filtering by amount for researching significant spending patterns and campaign finance transparency.
| Name | Required | Description | Default |
|---|---|---|---|
| committee_id | Yes | FEC committee ID (e.g., "C00401224") | |
| min_amount | No | Minimum disbursement amount to filter (default: $1,000) | |
| two_year_transaction_period | No | Two-year period (e.g., 2024 covers 2023-2024). | |
| cycle | No | Alias for two_year_transaction_period to align with finance cycle filters. | |
| purpose | No | Filter by disbursement purpose keyword (e.g., "CONSULTING", "MEDIA") | |
| include_notable | No | Include flagged-first notable analysis block in output (default: true) | |
| fuzzy_threshold | No | Fuzzy match confidence threshold for reference list matching (default: 90) | |
| limit | No | Number of results to return (default: 20, max: 100) | |
| sort_by | No | Sort results by "amount" (descending) or "date" (most recent first) | amount |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It correctly portrays the tool as read-only ('Retrieve'), but omits any mention of authentication, rate limits, or whether any state changes occur. While 'Retrieve' is suggestive, an explicit safety statement would improve 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 consists of two short sentences, each serving a clear purpose: first to state the action and resource, second to explain utility. It is front-loaded and free of 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?
With 9 parameters and no output schema, the description provides a high-level overview but does not detail the response structure or pagination. An agent might need to infer the output format. The description is adequate but not fully 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?
Schema coverage is 100%, fulfilling the baseline. The description adds only generic value ('filtering by amount') beyond what the schema's parameter descriptions already convey. No additional parameter-specific context is provided.
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 ('Retrieve') and resource ('itemized expenditures (Schedule B)'), clearly distinguishing from sibling tools like get_receipts or get_independent_expenditures. It also lists the key data fields (recipients, amounts, purposes), leaving no ambiguity about the tool's function.
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 mentions 'researching significant spending patterns and campaign finance transparency' as a use case, but does not provide explicit guidance on when to avoid this tool or compare it with alternatives like get_committee_finances or get_independent_expenditures. The usage context is implied, not articulated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_independent_expendituresA
Retrieve independent expenditures (Schedule E) - money spent by PACs and Super PACs to support or oppose candidates without coordinating with campaigns. Critical for understanding outside money influence in elections. Can filter by candidate targeted, committee spending, or support/oppose indicator.
| Name | Required | Description | Default |
|---|---|---|---|
| candidate_id | No | FEC candidate ID to find expenditures targeting this candidate | |
| committee_id | No | FEC committee ID to find expenditures made by this committee | |
| support_oppose | No | Filter by support or oppose indicator | |
| min_amount | No | Minimum expenditure amount to include | |
| cycle | No | Two-year election cycle (e.g., 2024) | |
| limit | No | Maximum number of results to return (default: 20) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It explains the nature of the data (outside money, no coordination) but does not disclose behavioral traits like read-only nature, rate limits, pagination, or response format. Some transparency is gained through the context, but it is incomplete.
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?
Three sentences, each earning its place: first defines purpose, second adds importance, third lists key filters. No wasted words, front-loaded with the action.
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 tool with 6 parameters (all documented), no output schema, and no annotations, the description adequately explains the use case and filters. However, it omits any description of the output format (e.g., what fields are returned), which is a gap given the absence of an output 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?
Schema coverage is 100%, so baseline is 3. The description mentions 'candidate targeted' (candidate_id), 'committee spending' (committee_id), and 'support/oppose indicator' (support_oppose), adding minimal context beyond the schema. It does not cover min_amount or cycle, but these are well-documented in 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 the verb 'retrieve' and the resource 'independent expenditures (Schedule E)', explaining that they are money spent by PACs and Super PACs to support or oppose candidates. This distinguishes it from sibling tools like 'get_committee_finances' or 'get_receipts'.
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 'Critical for understanding outside money influence in elections' and lists filters like candidate targeted and support/oppose indicator, implying when to use the tool. However, it does not explicitly state when not to use it or compare it to alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_receiptsA
Retrieve itemized contributions (Schedule A) received by a campaign committee. Shows individual and organizational donors, amounts, and contributor details. Automatically classifies PAC contributions by type (Corporate, Labor, Trade, Leadership PAC) for deeper analysis. Supports filtering by amount threshold for researching significant contributions and campaign finance patterns.
| Name | Required | Description | Default |
|---|---|---|---|
| committee_id | Yes | FEC committee ID (e.g., "C00401224") | |
| min_amount | No | Minimum contribution amount to filter (default: $1,000) | |
| two_year_transaction_period | No | Two-year period (e.g., 2024 covers 2023-2024). | |
| cycle | No | Alias for two_year_transaction_period to align with finance cycle filters. | |
| contributor_type | No | Filter by contributor type: "individual" or "committee" (PAC) | |
| include_notable | No | Include flagged-first notable analysis block in output (default: true) | |
| fuzzy_threshold | No | Fuzzy match confidence threshold for reference list matching (default: 90) | |
| limit | No | Number of results to return (default: 20, max: 100) | |
| sort_by | No | Sort results by "amount" (descending) or "date" (most recent first) | amount |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It notes the auto-classification of PAC contributions and filtering, but does not state that it is read-only, describe pagination, or mention any rate limits. Adequate but lacks full 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?
Three sentences, each adding value. The most important information (action and resource) comes first. No extraneous content, though structure could be slightly improved with bullet points.
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 mentions output includes donors, amounts, and details, but lacks specifics on return structure or pagination. Given 9 parameters and no output schema, more detail on the response format would enhance 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 coverage is 100%, so baseline is 3. The description adds value by explaining auto-classification of PAC types (related to contributor_type) and the 'notable analysis block' (include_notable), providing context beyond parameter 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?
Clearly states it retrieves itemized contributions (Schedule A) for a campaign committee, distinguishing it from sibling tools like get_disbursements or get_independent_expenditures. The verb 'Retrieve' and the specific reference to contributions make the purpose unambiguous.
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 the tool is for contributions received, but does not explicitly state when to use it versus alternatives. Given sibling tools exist, explicit guidance on when to use this tool (e.g., for receipts, not disbursements) would improve clarity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_candidatesA
Search FEC records for candidates by name. Returns candidate identifiers and their principal campaign committee IDs, which are required for retrieving detailed financial information. Useful for campaign finance research and transparency investigations.
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | Candidate name to search for (e.g., "John Smith" or "Smith") | |
| election_year | No | Filter by election year (e.g., 2024) | |
| office | No | Filter by office: H=House, S=Senate, P=President | |
| state | No | Filter by state (2-letter code, e.g., "CA") | |
| party | No | Filter by party code (e.g., "DEM", "REP", "LIB") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It correctly implies a read-only operation via 'search' and 'returns,' but does not explicitly state that no data is modified or mention rate limits, authentication needs, or any side effects.
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?
Three short, front-loaded sentences convey the purpose, output, and use case with no redundancy or unnecessary words. Every sentence adds value.
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 covers the tool's actions and output (identifiers and committee IDs) and provides a use case. It lacks information about pagination, result limits, or error handling, but the schema and multiple parameters make it fairly complete for a search 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?
With 100% schema coverage, each parameter already has a clear description (e.g., q as candidate name, election_year with range). The tool description adds no additional parameter-level detail beyond the schema, meeting the baseline expectation.
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 FEC records for candidates by name' and explains what it returns (candidate identifiers and committee IDs). It distinguishes from sibling tools like get_committee_finances or search_donors by focusing on candidates.
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 notes that the returned IDs are 'required for retrieving detailed financial information,' implying this tool should be used before committee finance lookups. However, it does not explicitly state when to avoid using it or provide direct comparisons to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_donorsB
Search for individual donors across all FEC filings by name, employer, or occupation. Essential for tracking donor patterns, identifying industry contributions, or researching specific individuals' political giving. Supports searching by employer (e.g., "Goldman Sachs") or occupation (e.g., "Lobbyist", "Government Affairs").
| Name | Required | Description | Default |
|---|---|---|---|
| contributor_name | No | Donor name to search for (partial match supported) | |
| contributor_employer | No | Employer name to search for (e.g., "Google", "Goldman Sachs") | |
| contributor_occupation | No | Occupation to search for (e.g., "Attorney", "Government Affairs", "Lobbyist") | |
| contributor_state | No | Two-letter state code to filter by (e.g., "CA", "NY") | |
| min_amount | No | Minimum contribution amount to include | |
| cycle | No | Two-year election cycle (e.g., 2024) | |
| limit | No | Maximum number of results to return (default: 20) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only describes the search scope ('across all FEC filings') but does not disclose behavioral traits such as pagination, rate limits, authentication needs, or what happens with no results. The behavioral context is minimal.
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 three sentences: first states the action, second lists use cases, third provides examples. It is front-loaded and concise, with no superfluous information. Every sentence contributes to understanding.
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 has 7 optional parameters and no output schema or annotations, the description adequately explains what the tool does and gives examples. However, it lacks discussion of result format, error handling, or how parameters combine, leaving some gaps for an agent.
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 100%, so each parameter is already documented. The description adds marginal value with examples (employer: 'Goldman Sachs', occupation: 'Lobbyist'), which clarifies usage but does not significantly deepen understanding 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 the verb 'Search for individual donors' and specifies the resource as 'all FEC filings' with search dimensions name, employer, or occupation. It distinguishes from sibling tools by focusing on donors, but does not explicitly differentiate from other search tools like search_candidates.
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 use cases like 'tracking donor patterns' and examples of searching by employer or occupation, implying when to use. However, it lacks explicit when-not-to-use guidance or references to alternative tools for other purposes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_spendingB
Search campaign spending (Schedule B) across all committees by description or recipient. Use to find questionable expenditures like "steak dinner", "event tickets", "travel", "Disney", "golf", or payments to specific vendors. Essential for identifying spending patterns and potential misuse of campaign funds.
| Name | Required | Description | Default |
|---|---|---|---|
| description | No | Search disbursement descriptions for keywords (e.g., "dinner", "travel", "event tickets", "Disney") | |
| recipient_name | No | Search for payments to a specific recipient/vendor | |
| recipient_state | No | Two-letter state code to filter by (e.g., "FL", "NV") | |
| min_amount | No | Minimum disbursement amount to include | |
| cycle | No | Two-year election cycle (e.g., 2024) | |
| limit | No | Maximum number of results to return (default: 20) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only implies a read operation via the word 'search' and notes that it operates 'across all committees'. It does not disclose potential rate limits, pagination, data freshness, or whether it requires authentication. This is minimal for a tool with no other behavioral hints.
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 extremely concise: two sentences and a line, front-loading the core purpose and specific search examples. Every sentence adds value, and there is no redundant or vague language.
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 having 6 parameters and no output schema, the description does not mention the return format or structure (e.g., list of disbursements). It also lacks information on default behavior, such as ordering or result limit details beyond what the 'limit' parameter specifies. This leaves the agent uncertain about what to expect from the response.
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 input schema covers all 6 parameters with descriptions (100% coverage). The description adds value by providing concrete examples for the 'description' parameter (e.g., 'dinner', 'travel', 'Disney') but does not add meaning beyond the schema for other parameters. Baseline 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 campaign spending by description or recipient across all committees, with specific examples like 'steak dinner' and 'Disney'. However, it does not explicitly differentiate from the sibling tool 'get_disbursements', which also searches disbursements, missing an opportunity to clarify distinct use cases.
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 clear usage context by listing example searches (e.g., 'event tickets', 'golf') and states its purpose for identifying spending patterns. However, it does not mention when to use this tool versus alternatives like 'get_disbursements' or 'get_committee_finances', nor does it specify when not to use it.
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.
1 tool update
- Changed
get_independent_expenditures1 field changed- changed
Input schema / properties / candidate_id / patternPrevious value: -"^[A-Z]\\d{8}$"New value: +"^(?:[HS]\\d[A-Z]{2}\\d{5}|P\\d{8})$"
8 tool updates
v1.0.0- First observed
get_committee_finances - First observed
get_committee_flags - First observed
get_disbursements - First observed
get_independent_expenditures - First observed
get_receipts - First observed
search_candidates - First observed
search_donors - First observed
search_spending
TDQS
Each tool targets a distinct FEC data type or search entity: committee finances vs. compliance flags vs. specific schedules (disbursements, receipts, independent expenditures) vs. searches (candidates, donors, spending). No ambiguity.
All tools follow a consistent 'verb_noun' pattern with lowercase underscore separation: get_*, search_*. No mixing of conventions.
8 tools is a well-scoped count for campaign finance research. Covers committee summary, key schedules, and targeted searches without being overwhelming or too thin.
Covers core CRUD-like operations (retrieve summaries, itemized receipts/disbursements, independent expenditures, compliance flags) and search. Minor gap: no dedicated tool for committee details beyond finances, but searches provide identifiers. Solid for the domain.
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
Access FEC campaign finance data. Query data about candidates, money trails, and election filings.
FEC campaign finance data: candidate fundraising, donors, and spending
OpenFEC MCP — Federal Election Commission campaign finance data
U.S. federal policy data — bills, Congress members, voting records, and civic info.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceConnects the OpenFEC API to AI assistants for investigating US federal campaign finance through natural language conversations.1MIT
- AlicenseNot gradedqualityAmaintenanceAccess FEC campaign finance data through MCP. Query data about candidates, money trails, and election filings. STDIO & Streamable HTTP.3382Apache 2.0
- AlicenseBqualityBmaintenanceEnables querying state-level campaign finance data, including donors, expenditures, committees, and candidates, from multiple state disclosure systems via a unified MCP interface.9MIT
- AlicenseNot gradedqualityDmaintenanceEnables searching political donations, donors, and lobbying data from any AI assistant using Federal Election Commission data.15MIT
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/sh-patterson/fec-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server