# FEC Campaign Finance Pro (Donors, Committees, Money) (`red.cars/fec-campaign-finance-pro`) Actor

Candidate search, committee search, itemized individual contributions (Schedule A) and independent expenditures (Schedule E) from the FEC official OpenFEC API, as flat rows. Hard result caps, zero-result hint rows, own-API-key support. $0.005/run + $2.00 per 1,000 rows.

- **URL**: https://apify.com/red.cars/fec-campaign-finance-pro.md
- **Developed by:** [AutomateLab](https://apify.com/red.cars) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## FEC Campaign Finance Pro

Campaign money from the FEC's own OpenFEC API, in clean rows: candidate search, committee search, itemized individual contributions (Schedule A) and independent expenditures (Schedule E).

**Pricing: $0.005 per run + $2.00 per 1,000 result rows.** No proxies, no scrapers: every row comes from the FEC's official JSON API, so the rows are exactly what the FEC published.

### Comparison

| | [fec-campaign-finance-pro](https://apify.com/red.cars/fec-campaign-finance-pro) (this actor) | [ryanclinton/fec-campaign-finance](https://apify.com/ryanclinton/fec-campaign-finance) (category leader) |
|---|---|---|
| Price | $0.005/run + $2.00 per 1,000 rows | $0.002 per record + $0.00005/GB start |
| Search types | 4 in one actor: candidates, committees, contributions (Schedule A), expenditures (Schedule E) | contributions focus |
| API key | Your own free FEC key supported; shared DEMO_KEY fallback | fixed |
| Result cap | Hard maxItems cap, run stops at the cap | config-dependent |
| Rows | Flattened, typed rows with links to the FEC record and filing PDF | nested/mixed |

The leader sits at 3 active users in the last 30 days with no public reviews; this actor ships the same per-row price with all four FEC search surfaces in one call.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `searchType` | select | `candidates` | `candidates`, `committees`, `contributions`, `expenditures` |
| `query` | string | empty | Name to search: candidate/committee name (q), contributor name (Schedule A), payee name (Schedule E) |
| `committeeId` | string | empty | FEC committee ID, e.g. `C00401224`. Use it for money queries to stay fast |
| `candidateId` | string | empty | FEC candidate ID for expenditure pulls, e.g. `H6TX34072` |
| `office` | select | any | `H` House, `S` Senate, `P` President (candidate search) |
| `state` | string | empty | Two-letter state, e.g. `TX` |
| `party` | string | empty | `DEM`, `REP`, ... |
| `twoYearPeriod` | number | `2026` | FEC two-year transaction period for money queries |
| `dateFrom` / `dateTo` | string | empty | Date window `YYYY-MM-DD` for contributions/expenditures |
| `minAmount` | number | `0` | Minimum contribution amount |
| `maxItems` | number | `10` | Hard cap on rows; the run stops at the cap so you never pay for rows you didn't ask for |
| `apiKey` | string | empty | OpenFEC API key. Empty uses the shared `DEMO_KEY`, which is rate limited |

### Output

Each dataset item is one flat row with a `searchType` marker.

- **candidates**: `candidateId`, `name`, `party`, `office`, `state`, `district`, `lastCycle`, `hasRaisedFunds`, `incumbentStatus`, `firstFiled`, `lastFiled`, `committeeIds`, `fecLink`
- **committees**: `committeeId`, `name`, `designation`, `type`, `state`, `party`, `treasurer`, `lastCycle`, `firstFiled`, `linkedCandidates`, `fecLink`
- **contributions**: `contributor`, `employer`, `occupation`, `city`, `state`, `amount`, `receiptDate`, `aggregateYtd`, `committeeId`, `committeeName`, `candidateName`, `pdfUrl`
- **expenditures**: `payee`, `amount`, `expenditureDate`, `description`, `committeeId`, `committeeName`, `candidateName`, `candidateId`, `supportOrOppose`, `filingNumber`, `pdfUrl`

A run that matches nothing pushes a single `ZERO_RESULTS` hint row (the only billed item) so you can see why.

### Use cases

- Journalists and researchers tracking who funds which campaigns this cycle
- Compliance and PAC teams screening donors before outreach
- Opposition research: full contribution trails by committee, employer or window
- Ad intelligence: who is spending money on independent expenditures for or against a candidate

### FAQ

**Do I need an API key?** No. Empty uses the FEC's shared `DEMO_KEY`, which is heavily rate limited. For reliable volume get a free key in one minute at [api.data.gov/signup](https://api.data.gov/signup/) and paste it into `apiKey`.

**Why do money queries need a filter?** Unfiltered Schedule A pulls span millions of rows and time out on the FEC's side. Give it a `committeeId`, a contributor `query`, or a `candidateId` (and ideally a date window).

**Which cycle do I get?** Money queries default to `twoYearPeriod: 2026`. Set `2024`, `2022`, ... for historical cycles.

**Can I pull more than 10 rows?** Yes: raise `maxItems` (cap 5,000 per run). The run stops exactly at the cap.

**Is the data official?** Yes, every field comes from the FEC's public OpenFEC API (api.open.fec.gov). Rows link back to fec.gov records and filing PDFs.

### Pair it with

**[Congress Stock Trades Pro](https://apify.com/red.cars/congress-stock-trades-pro)** covers the trading side of the same money: House member PTR filings parsed into rows with amount midpoints and links to the source PDF, $0.005 per run + $1.50 per 1,000 rows.

# Actor input Schema

## `searchType` (type: `string`):

What to pull from the FEC: candidates, committees, itemized individual contributions, or independent expenditures.

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

Name to search. For candidates and committees this is the q filter; for contributions it matches contributor_name; for expenditures it matches payee_name. Empty returns all (combined with other filters).

## `committeeId` (type: `string`):

Optional FEC committee ID (e.g. C00401224). Required for contribution and expenditure pulls to stay fast; contributions/expenditures without it can time out on the FEC side.

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

Optional FEC candidate ID (e.g. H6TX34072) for expenditure pulls.

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

Optional office filter for candidate search.

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

Optional two-letter state filter (e.g. TX).

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

Optional party filter for candidates/committees (e.g. DEM, REP).

## `twoYearPeriod` (type: `integer`):

FEC cycle year for money queries. Defaults to 2026 (the current cycle).

## `dateFrom` (type: `string`):

Optional date filter (YYYY-MM-DD) for contributions/expenditures.

## `dateTo` (type: `string`):

Optional date filter (YYYY-MM-DD) for contributions/expenditures.

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

Optional minimum contribution amount.

## `maxItems` (type: `integer`):

Hard cap on rows pushed. The run stops as soon as the cap is hit so you never pay for results you didn't ask for.

## `apiKey` (type: `string`):

OpenFEC API key. DEMO_KEY works for light tests but is shared and rate limited; get a free key in one minute at https://api.data.gov/signup/ and paste it here for reliable volume.

## Actor input object example

```json
{
  "searchType": "candidates",
  "query": "",
  "committeeId": "",
  "candidateId": "",
  "office": "",
  "state": "",
  "party": "",
  "twoYearPeriod": 2026,
  "dateFrom": "",
  "dateTo": "",
  "minAmount": 0,
  "maxItems": 10,
  "apiKey": ""
}
```

# Actor output Schema

## `results` (type: `string`):

Clean FEC rows. Candidates: id, name, party, office, state, district, cycle, filing dates. Committees: id, name, designation, type, state, party, treasurer. Contributions: contributor, employer, occupation, amount, date, committee and candidate. Expenditures: payee, amount, date, description, committee, supported/opposed candidate.

# 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("red.cars/fec-campaign-finance-pro").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("red.cars/fec-campaign-finance-pro").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 red.cars/fec-campaign-finance-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,red.cars/fec-campaign-finance-pro"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/zAFfyopyUrsXwhlfk/builds/GuCoDvTtY25KUpZOs/openapi.json