# FEC Campaign Finance Intelligence MCP (`andrew_avina/fec-intelligence-mcp`) Actor

Follow the money in US politics — FEC campaign finance data via MCP.

- **URL**: https://apify.com/andrew\_avina/fec-intelligence-mcp.md
- **Developed by:** [Andrew Avina](https://apify.com/andrew_avina) (community)
- **Categories:** MCP servers, Business
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 result item returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## fec-intelligence-mcp

**Follow the money in US politics — FEC campaign finance data via MCP.**

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-brightgreen)](https://apify.com/store)
[![Data Source](https://img.shields.io/badge/Data-FEC%20Open%20Data-orange)](https://www.fec.gov/data/)
[![Category](https://img.shields.io/badge/Category-Politics%20%2F%20Finance-purple)](https://apify.com/store)
[![MCP Ready](https://img.shields.io/badge/MCP-Server%20Ready-red)](https://modelcontextprotocol.io)
[![No API Key](https://img.shields.io/badge/API%20Key-Optional%20(DEMO_KEY)-success)](https://api.data.gov/signup/)

---

### What Is This?

The Federal Election Commission (FEC) collects and publishes every campaign contribution, disbursement, and fundraising report filed by candidates, PACs, and political parties in US federal elections. This data is public — but the FEC API is complex, rate-limited, and requires understanding of committee IDs, election cycles, form types, and filing schedules before you can extract useful information.

This actor wraps the FEC Open Data API into four clean, focused MCP tools: search candidates, search PACs and committees, retrieve candidate fundraising totals, and search individual contribution records. In MCP server mode, an AI assistant like Claude can answer *"Who are the top donors to Senate Democrats from the finance sector in 2024?"* by chaining `search_committees`, `search_contributions`, and summarizing — without you writing a single line of code.

Works with `DEMO_KEY` (no registration required) for moderate usage. Set your own free API key from [api.data.gov](https://api.data.gov/signup/) in the `FEC_API_KEY` environment variable for higher rate limits.

---

### Who Uses This

**Political Journalists and Investigative Reporters**
You're covering the 2026 midterms and need to know which super PACs are spending on behalf of a specific Senate candidate. Search committees filtered by state, then pull contribution totals. Find the employers of maximum donors to understand industry alignment. Build a complete follow-the-money narrative without a political intelligence subscription.

**Opposition Research Consultants**
You need to screen a candidate's donor base for controversial contributors, identify conflicts of interest in fundraising patterns, or compare a challenger's fundraising trajectory against incumbents at the same point in the campaign cycle. This actor gives you structured data fast.

**Compliance Lawyers at Law Firms and Corporations**
PACs, bundlers, and corporate donors all have reporting obligations. Verify that your client's contributions are reflected accurately in FEC records. Audit whether disclosed donor lists match actual FEC filings. Cross-reference your employees against FEC contribution records to identify potential earmarking violations.

**Political Scientists and Researchers**
You're studying money in politics — donation patterns, incumbency advantage in fundraising, PAC strategy across election cycles, or small-donor versus large-donor splits. This actor gives you machine-readable FEC data without scraping the FEC website or building your own API client.

**Fintech and Financial Intelligence Platforms**
Enhanced due diligence for politically exposed persons (PEPs) often requires knowing whether a subject has made political contributions. Search contributions by name and employer to identify PEP-adjacent donation activity for KYC workflows.

**Nonprofits and Good-Government Organizations**
Track PAC spending on specific races. Monitor dark money groups. Analyze whether reported spending matches independent expenditure disclosures. Publish transparency reports with structured data from the FEC's official filings.

---

### Key Features

| Feature | Detail |
|---|---|
| Data source | FEC Open Data API v1 — official federal election finance data |
| Candidates | Search by name, state, office, party, election cycle |
| Committees | Search PACs, super PACs, party committees, principal committees |
| Fundraising totals | Total receipts, disbursements, cash on hand per candidate per cycle |
| Contributions | Schedule A — individual donor name, employer, amount, date, recipient |
| Election cycles | 1980–2026 (all available FEC data) |
| Rate limits | DEMO_KEY: 1,000/hr; own key: 120 req/min |
| 429 handling | Automatic retry with exponential backoff |
| MCP server mode | Live tool-use in Claude Desktop, Claude Code, any MCP client |
| Batch mode | One-shot runs with dataset output |
| No key required | DEMO_KEY works for research and moderate usage |

---

### Quick Start

#### Batch Mode — Search Candidates

**Input:**
```json
{
  "mode": "candidates",
  "query": "Warren",
  "office": "senate",
  "party": "DEM",
  "cycle": 2024,
  "limit": 5
}
````

**Output:**

```json
[
  {
    "candidate_id": "S2MA00170",
    "name": "WARREN, ELIZABETH",
    "party": "Democratic Party",
    "party_code": "DEM",
    "office": "Senate",
    "state": "MA",
    "district": null,
    "election_years": [2012, 2018, 2024],
    "principal_committees": ["ELIZABETH WARREN FOR SENATE"],
    "incumbent_challenge": "Incumbent",
    "source": "fec_open_data"
  }
]
```

#### Batch Mode — Candidate Fundraising Totals

**Input:**

```json
{
  "mode": "totals",
  "candidateId": "S2MA00170",
  "cycle": 2024
}
```

**Output:**

```json
[
  {
    "candidate_id": "S2MA00170",
    "cycle": 2024,
    "total_receipts": 24750000.00,
    "total_disbursements": 18200000.00,
    "cash_on_hand_end": 6550000.00,
    "individual_contributions": 21800000.00,
    "pac_contributions": 1200000.00,
    "party_contributions": 850000.00,
    "total_loans": 0,
    "source": "fec_open_data"
  }
]
```

#### Batch Mode — Individual Contributions

**Input:**

```json
{
  "mode": "contributions",
  "contributorEmployer": "Goldman Sachs",
  "minAmount": 2000,
  "cycle": 2024,
  "limit": 20
}
```

**Output:**

```json
[
  {
    "contributor_name": "BLANKFEIN, LLOYD",
    "contributor_employer": "GOLDMAN SACHS",
    "contributor_occupation": "CEO",
    "contributor_city": "NEW YORK",
    "contributor_state": "NY",
    "contribution_amount": 3300.00,
    "contribution_date": "2024-03-15",
    "recipient_committee_id": "C00575795",
    "recipient_committee_name": "COMMITTEE TO ELECT...",
    "cycle": 2024,
    "source": "fec_open_data"
  }
]
```

#### MCP Server Mode

**Claude Desktop** (`claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "fec-finance": {
      "command": "npx",
      "args": [
        "apify-actor-mcp",
        "--actor-id", "your-username/fec-intelligence-mcp",
        "--token", "apify_api_YOURTOKEN"
      ],
      "env": {
        "FEC_API_KEY": "your_fec_api_key_here"
      }
    }
  }
}
```

Then ask Claude: *"Who are the top 10 Senate candidates by fundraising in the 2024 cycle?"* or *"What companies' employees donated the most to Republican House candidates in Florida?"*

***

### MCP Tools Exposed

#### `search_candidates`

Search FEC candidate records by name, state, office, party, and election cycle.

**Arguments:**
| Field | Type | Required | Description |
|---|---|---|---|
| `query` | string | No | Candidate name keyword |
| `state` | string | No | Two-letter state code |
| `office` | string | No | `president`, `senate`, or `house` |
| `party` | string | No | `DEM`, `REP`, `IND`, `LIB`, `GRE` |
| `cycle` | integer | No | Election cycle year (default 2024) |
| `limit` | integer | No | Max results (default 20) |

**Returns:** candidate\_id, name, party, office, state, district, election\_years, principal\_committees

***

#### `search_committees`

Search PACs, super PACs, party committees, and principal committees.

**Arguments:**
| Field | Type | Required | Description |
|---|---|---|---|
| `query` | string | No | Committee name keyword |
| `committee_type` | string | No | Type code: `S`=Super PAC, `N`=PAC, `Y`=State party |
| `state` | string | No | State filter |
| `cycle` | integer | No | Election cycle year |
| `limit` | integer | No | Max results |

**Returns:** committee\_id, name, committee\_type, designation, party, state, treasurer\_name

***

#### `get_candidate_totals`

Get fundraising and spending totals for a specific candidate.

**Arguments:**
| Field | Type | Required | Description |
|---|---|---|---|
| `candidate_id` | string | Yes | FEC candidate ID (from search\_candidates) |
| `cycle` | integer | No | Election cycle year |

**Returns:** total\_receipts, total\_disbursements, cash\_on\_hand\_end, individual\_contributions, pac\_contributions, total\_loans

***

#### `search_contributions`

Search individual contribution records (Schedule A filings).

**Arguments:**
| Field | Type | Required | Description |
|---|---|---|---|
| `contributor_name` | string | No | Donor name (partial match) |
| `contributor_employer` | string | No | Donor employer (partial match) |
| `min_amount` | number | No | Minimum contribution amount USD |
| `max_amount` | number | No | Maximum contribution amount USD |
| `cycle` | integer | No | Transaction cycle year |
| `limit` | integer | No | Max results |

**Returns:** contributor\_name, employer, occupation, city, state, contribution\_amount, contribution\_date, recipient committee

***

### Input Schema

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `"candidates"` | Query type: `candidates`, `committees`, `totals`, `contributions` |
| `query` | string | `""` | Name or keyword search |
| `state` | string | `""` | State filter (two-letter code) |
| `office` | string | `""` | Office filter: `president`, `senate`, `house` |
| `party` | string | `""` | Party code: `DEM`, `REP`, `IND`, etc. |
| `cycle` | integer | `2024` | Election cycle year |
| `candidateId` | string | `""` | FEC candidate ID (for totals mode) |
| `contributorName` | string | `""` | Donor name (for contributions mode) |
| `contributorEmployer` | string | `""` | Donor employer (for contributions mode) |
| `minAmount` | integer | `0` | Minimum contribution amount USD |
| `maxAmount` | integer | `0` | Maximum contribution amount USD |
| `limit` | integer | `20` | Max results (max 200) |
| `serveMcp` | boolean | `false` | Start MCP server instead of batch run |

***

### Use Case Recipes

#### Recipe 1: Competitive Race Fundraising Comparison

Compare fundraising between candidates in a competitive Senate race:

**Step 1:** Search candidates by state and office:

```json
{"mode": "candidates", "state": "OH", "office": "senate", "cycle": 2024}
```

**Step 2:** Get totals for each candidate\_id returned:

```json
{"mode": "totals", "candidateId": "S0OH00234", "cycle": 2024}
```

**Outcome:** Side-by-side fundraising comparison, cash-on-hand advantage, spending burn rate.

***

#### Recipe 2: Industry Donor Analysis

Find contributions from finance industry employees to a specific party:

```json
{
  "mode": "contributions",
  "contributorEmployer": "BlackRock",
  "minAmount": 2000,
  "cycle": 2024,
  "limit": 100
}
```

Repeat for `JPMorgan`, `Citadel`, `KKR` — combine datasets to map finance industry political alignment.

***

#### Recipe 3: Super PAC Landscape for a Race

Find all super PACs active in a specific state:

```json
{
  "mode": "committees",
  "committee_type": "O",
  "state": "PA",
  "cycle": 2024,
  "limit": 50
}
```

`O` = Independent expenditure only committee (classic Super PAC structure).

***

#### Recipe 4: Donor PEP Screening

For a donor named in an investment pitch: screen their political activity for reputational risk:

```json
{
  "mode": "contributions",
  "contributorName": "Smith John",
  "cycle": 2024,
  "limit": 50
}
```

Cross-reference contribution amounts against legally allowed limits to flag potential violations.

***

#### Recipe 5: Historical Fundraising Trend

Compare the same candidate's fundraising across multiple cycles:

```json
{"mode": "totals", "candidateId": "S2MA00170", "cycle": 2024}
{"mode": "totals", "candidateId": "S2MA00170", "cycle": 2018}
{"mode": "totals", "candidateId": "S2MA00170", "cycle": 2012}
```

Shows growth trajectory, small-donor versus PAC ratio changes, and spending efficiency over time.

***

### Connecting to Claude Desktop / Claude Code

**macOS Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "fec-finance": {
      "command": "npx",
      "args": [
        "apify-actor-mcp",
        "--actor-id", "your-username/fec-intelligence-mcp",
        "--token", "apify_api_YOURTOKEN"
      ],
      "env": {
        "FEC_API_KEY": "your_key_from_api.data.gov"
      }
    }
  }
}
```

**Claude Code** (project `.claude/settings.json`):

```json
{
  "mcpServers": {
    "fec-finance": {
      "command": "npx",
      "args": ["apify-actor-mcp", "--actor-id", "your-username/fec-intelligence-mcp", "--token", "apify_api_YOURTOKEN"]
    }
  }
}
```

**Direct HTTP** (for custom MCP clients):

- `GET http://<run-url>:4321/mcp/tools` — list available tools
- `POST http://<run-url>:4321/mcp/call` — `{"name": "search_candidates", "arguments": {"query": "Biden", "cycle": 2024}}`

***

### API Key Setup

The actor works without any configuration using the `DEMO_KEY` rate limit (1,000 requests/hour per IP). For production use:

1. Sign up at [api.data.gov/signup/](https://api.data.gov/signup/) — free, instant
2. Set the `FEC_API_KEY` environment variable in the actor's configuration
3. Your key allows 120 requests/minute — enough for heavy research workloads

***

### Data Source and Notes

- **Source:** FEC Open Data API v1 — `https://api.open.fec.gov/v1/`
- **Coverage:** All federal candidate filings from 1980 to present
- **Update frequency:** FEC data updates in near-real-time as reports are filed
- **Contribution limits (2024):** Individual to candidate = $3,300/election; to national party = $41,300/year; Super PACs = unlimited
- **DEMO\_KEY limits:** 1,000 req/hr per IP, 10,000 req/day — suitable for research and testing
- **Rate limit handling:** The actor automatically retries on HTTP 429 with exponential backoff

***

### Pricing

| Volume | Price |
|---|---|
| First 1,000 results | $0.40 |
| 1,001 – 50,000 results | $0.30/1k |
| MCP server (per session-hour) | Metered by result count |

***

### Support

- **Issues:** File a GitHub issue on the actor repository
- **Apify Community:** [community.apify.com](https://community.apify.com)
- **FEC API docs:** [api.open.fec.gov/developers/](https://api.open.fec.gov/developers/)
- **FEC data browser:** [fec.gov/data/](https://www.fec.gov/data/)
- **API key signup:** [api.data.gov/signup/](https://api.data.gov/signup/)

# Actor input Schema

## `mode` (type: `string`):

Which type of FEC data to query. 'candidates' = search candidate records, 'committees' = search PACs and committees, 'totals' = get fundraising totals for a specific candidate (requires candidateId), 'contributions' = search individual contribution records.

## `query` (type: `string`):

Name or keyword to search. For candidates: 'Biden', 'Warren', 'Smith'. For committees: 'EMILY List', 'Club for Growth'. Leave empty to browse all records.

## `state` (type: `string`):

Two-letter state abbreviation to filter by. Examples: 'CA', 'TX', 'NY', 'FL', 'OH'. Leave empty for all states.

## `office` (type: `string`):

For candidates mode: filter by office. 'president', 'senate', or 'house'. Leave empty for all offices.

## `party` (type: `string`):

For candidates mode: filter by party code. 'DEM' = Democrat, 'REP' = Republican, 'IND' = Independent, 'LIB' = Libertarian, 'GRE' = Green. Leave empty for all parties.

## `cycle` (type: `integer`):

Two-year election cycle (even years only). 2024 = 2023–2024, 2022 = 2021–2022, etc. Defaults to 2024.

## `candidateId` (type: `string`):

FEC candidate ID for the 'totals' mode. Format: P/S/H + 8 digits. Examples: 'P80001571' (Biden), 'P80000722' (Trump). Get this from a candidates search first.

## `contributorName` (type: `string`):

Donor name to search in contribution records. Partial match supported. Examples: 'Soros', 'Koch', 'Bloomberg', 'Gates'.

## `contributorEmployer` (type: `string`):

Donor's employer to search in contribution records. Examples: 'Google', 'Goldman Sachs', 'Apple Inc', 'Harvard University'.

## `minAmount` (type: `integer`):

Only return contributions at or above this dollar amount. The 2024 individual contribution limit per candidate per election is $3,300.

## `maxAmount` (type: `integer`):

Only return contributions at or below this dollar amount. Set to 0 for no upper limit.

## `limit` (type: `integer`):

Maximum number of records to return (max 200). The FEC API paginates at 100 per page — larger limits will make multiple API calls.

## `serveMcp` (type: `boolean`):

When enabled, starts an MCP-compatible HTTP server on port 4321 instead of returning a batch dataset. Use this mode to connect Claude Desktop, Cursor, or any MCP client directly to live FEC campaign finance data. The actor will run continuously until stopped.

## Actor input object example

```json
{
  "mode": "candidates",
  "query": "",
  "state": "",
  "office": "",
  "party": "",
  "cycle": 2024,
  "candidateId": "",
  "contributorName": "",
  "contributorEmployer": "",
  "minAmount": 0,
  "maxAmount": 0,
  "limit": 20,
  "serveMcp": false
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("andrew_avina/fec-intelligence-mcp").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("andrew_avina/fec-intelligence-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call andrew_avina/fec-intelligence-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=andrew_avina/fec-intelligence-mcp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FEC Campaign Finance Intelligence MCP",
        "description": "Follow the money in US politics — FEC campaign finance data via MCP.",
        "version": "0.1",
        "x-build-id": "YsyDAzwgxIzDjdQDC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/andrew_avina~fec-intelligence-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-andrew_avina-fec-intelligence-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/andrew_avina~fec-intelligence-mcp/runs": {
            "post": {
                "operationId": "runs-sync-andrew_avina-fec-intelligence-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/andrew_avina~fec-intelligence-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-andrew_avina-fec-intelligence-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Query Mode",
                        "enum": [
                            "candidates",
                            "committees",
                            "totals",
                            "contributions"
                        ],
                        "type": "string",
                        "description": "Which type of FEC data to query. 'candidates' = search candidate records, 'committees' = search PACs and committees, 'totals' = get fundraising totals for a specific candidate (requires candidateId), 'contributions' = search individual contribution records.",
                        "default": "candidates"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Name or keyword to search. For candidates: 'Biden', 'Warren', 'Smith'. For committees: 'EMILY List', 'Club for Growth'. Leave empty to browse all records.",
                        "default": ""
                    },
                    "state": {
                        "title": "State Filter",
                        "type": "string",
                        "description": "Two-letter state abbreviation to filter by. Examples: 'CA', 'TX', 'NY', 'FL', 'OH'. Leave empty for all states.",
                        "default": ""
                    },
                    "office": {
                        "title": "Office Sought (Candidates)",
                        "enum": [
                            "",
                            "president",
                            "senate",
                            "house"
                        ],
                        "type": "string",
                        "description": "For candidates mode: filter by office. 'president', 'senate', or 'house'. Leave empty for all offices.",
                        "default": ""
                    },
                    "party": {
                        "title": "Party Code (Candidates)",
                        "type": "string",
                        "description": "For candidates mode: filter by party code. 'DEM' = Democrat, 'REP' = Republican, 'IND' = Independent, 'LIB' = Libertarian, 'GRE' = Green. Leave empty for all parties.",
                        "default": ""
                    },
                    "cycle": {
                        "title": "Election Cycle Year",
                        "minimum": 1980,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Two-year election cycle (even years only). 2024 = 2023–2024, 2022 = 2021–2022, etc. Defaults to 2024.",
                        "default": 2024
                    },
                    "candidateId": {
                        "title": "Candidate ID (Totals mode)",
                        "type": "string",
                        "description": "FEC candidate ID for the 'totals' mode. Format: P/S/H + 8 digits. Examples: 'P80001571' (Biden), 'P80000722' (Trump). Get this from a candidates search first.",
                        "default": ""
                    },
                    "contributorName": {
                        "title": "Contributor Name (Contributions mode)",
                        "type": "string",
                        "description": "Donor name to search in contribution records. Partial match supported. Examples: 'Soros', 'Koch', 'Bloomberg', 'Gates'.",
                        "default": ""
                    },
                    "contributorEmployer": {
                        "title": "Contributor Employer (Contributions mode)",
                        "type": "string",
                        "description": "Donor's employer to search in contribution records. Examples: 'Google', 'Goldman Sachs', 'Apple Inc', 'Harvard University'.",
                        "default": ""
                    },
                    "minAmount": {
                        "title": "Minimum Contribution Amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return contributions at or above this dollar amount. The 2024 individual contribution limit per candidate per election is $3,300.",
                        "default": 0
                    },
                    "maxAmount": {
                        "title": "Maximum Contribution Amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return contributions at or below this dollar amount. Set to 0 for no upper limit.",
                        "default": 0
                    },
                    "limit": {
                        "title": "Result Limit",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of records to return (max 200). The FEC API paginates at 100 per page — larger limits will make multiple API calls.",
                        "default": 20
                    },
                    "serveMcp": {
                        "title": "MCP Server Mode",
                        "type": "boolean",
                        "description": "When enabled, starts an MCP-compatible HTTP server on port 4321 instead of returning a batch dataset. Use this mode to connect Claude Desktop, Cursor, or any MCP client directly to live FEC campaign finance data. The actor will run continuously until stopped.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
