# Congress Voting Record Tracker: Votes, Bills & Cited Flags (`clearfeedlabs/legislator-record-tracker`) Actor

U.S. House members' roll-call votes from official House Clerk XML, sponsored and cosponsored bills from the Congress.gov API (your free key), party-break flags and neutral, cited position-change flags. Incremental and scorecard options.

- **URL**: https://apify.com/clearfeedlabs/legislator-record-tracker.md
- **Developed by:** [Clearfeed Labs](https://apify.com/clearfeedlabs) (community)
- **Categories:** News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 vote rows

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

### Congress Voting Record Tracker: Votes, Bills & Cited Flags

**Congress Voting Record Tracker** builds a **sourced voting record for the U.S. House members you choose**: every roll-call vote from the official **House Clerk roll-call XML**, how each vote compares with the member's party majority, **sponsored and cosponsored bills** from the official **Congress.gov API** (with your free key), and **neutral, cited position-change flags** that link to every source record behind them.

Built for **campaign research teams, political consultants, journalists, fact-checkers, advocacy groups and civic researchers** who need records they can cite, not claims they have to verify.

#### What you get

| Row type | Contents | Source |
|---|---|---|
| `vote` | Member, party, state, roll call, date, measure, question, result, the member's vote, party-majority vote, `votedAgainstPartyMajority`, passage-type flag | House Clerk XML: `sourceUrl` and `sourceXmlUrl` |
| `sponsorship` | Sponsored or cosponsored measure, title, introduced date, policy area, latest action | Congress.gov API: `sourceUrl` |
| `position-flag` | A factual, neutral statement plus context and `sources` (links to every record used) | Both |
| `scorecard` (add-on) | Participation rate, missed votes, party-agreement rate, period and method | House Clerk XML |

**Position-change flags** are generated only from fixed templates filled with record fields. They're never written freehand, and there's no sentiment or inference:

- `different-votes-same-measure`: the member voted Yea on one passage-type question and Nay on another for the same measure (e.g. on passage, then on the conference report). Procedural questions such as motions to recommit are excluded because they normally run opposite to passage.
- `voted-nay-on-sponsored-measure` / `voted-nay-on-cosponsored-measure` (needs a Congress.gov key): a Nay on a passage-type question for a measure the member is listed as sponsoring or cosponsoring.

Each flag carries a context note: different votes can reflect amended text, Senate or conference versions, or procedure. Always read the linked records.

#### Example inputs

- [Track a member's recent House votes and party breaks](https://apify.com/clearfeedlabs/legislator-record-tracker/examples/house-member-votes-party-breaks)
- [Passage votes and cited position flags for a member](https://apify.com/clearfeedlabs/legislator-record-tracker/examples/house-passage-votes-position-flags)

```json
{ "members": ["P000197", "Adams NC"], "years": [2026], "maxRollCalls": 200, "onlyFinalVotes": true, "congressApiKey": "<your free key>", "mode": "sinceLastRun" }
```

#### Your Congress.gov key (optional)

House votes need **no key**. Bill sponsorship rows and sponsorship flags use the Congress.gov API, which requires a **free key** from https://api.congress.gov/sign-up/. Paste it into `congressApiKey`. It's a secret input: it's used only for your run, never written to the output or logs, and never stored. We don't bundle our own key, because api.data.gov keys belong to individual developers.

#### Pricing

| Event | Price | When |
|---|---|---|
| Actor start | $0.00005 | Each run |
| Vote row | $0.002 | Each vote row returned |
| Sponsorship row | $0.002 | Each bill row returned |
| Position flag | $0.01 | Each cited flag returned |
| Add-on: scorecard | $0.02 | Per member, only with `addScorecard` |

With `mode: sinceLastRun` on a schedule you pay only for new votes, bills and flags. Tracking one member's ~60 votes a month costs about $0.12 a month. Turn off vote rows to pay only for flags and scorecards.

#### How the pricing compares

Store list prices, checked on 2026-11-01 (they may change):

| Actor | What it outputs | Price per 1,000 rows |
|---|---|---|
| **Congress Voting Record Tracker** | Per-member House votes with party comparison, bills, cited flags, scorecards | $2 votes and bills; flags $10, scorecards $20 per 1,000 |
| pink_comic/congress-gov-legislation-tracker | Bills | $2 |
| benthepythondev/congress-intelligence | Bills, members, votes | $3 |
| lathewright/congress-bills-tracker | Bills, sponsors, actions | $3 |
| ponderable_hydrometer/congress-gov-scraper | Bills, laws, members | $4 |
| nabeelbaghoor/legislation-tracking-bills-votes-api | Federal, state and EU bills | $5 to $10 |
| scrapersdelight/legiscan-bill-scraper | LegiScan bills | about $16 to $18 |
| parseforge/govtrack-congress-scraper | GovTrack data | about $40 |
| nexgendata/us-legislation-bill-tracker | Bills | $50 |

**Why flags cost more than rows:** a flag replaces research time. It joins several official records (multiple roll calls, Congress.gov sponsorship), applies documented rules and hands you the citations. Raw rows stay at the market rate of $2 per 1,000, and the scorecard is an optional add-on.

#### How it collects data

- **House Clerk roll-call XML** (`clerk.house.gov/evs/{year}/roll{n}.xml`): the official public record of every recorded House vote. We make one request at a time, about one per second, with an identifying User-Agent, and each roll call is cached in your account so it's fetched only once.
- **Congress.gov API v3:** the Library of Congress's documented API, called with your own key.

#### Coverage and limits

- **House only in this version.** Senate.gov's web firewall refuses automated requests, and we don't work around blocks, so Senate votes aren't included. State legislatures (OpenStates) and official statements (Congressional Record) are planned and will use the same bring-your-own-key approach.
- Roll calls from 1990 onward. Name matching uses the names printed in roll calls; use Bioguide IDs for certainty.
- Party majority is computed from each roll call's official party totals. Ties count as no majority.

#### Guardrails and responsible use

- Every row cites the public record. Flags are factual comparisons, not characterizations, and use the same wording for every member and party.
- **No voter data, no targeting, no contact lists.** This Actor covers official acts of elected officials only.
- Don't present flags as allegations or remove their context or sources. Check the source records before you publish.

#### Disclaimer

- **Nonpartisan.** Clearfeed Labs doesn't support or oppose any candidate, party or measure. This Actor is not affiliated with or endorsed by the U.S. House of Representatives, the Office of the Clerk, the Library of Congress or Congress.gov.
- **Data accuracy:** records come from official sources and can be corrected or updated after publication. Automated matching (names, measure numbers, sponsorship) can be wrong. The linked official record is authoritative.
- **Not legal advice**, and not a substitute for editorial or legal review before publication. You're responsible for how you use and present the data, including election-law, defamation and platform rules.
- Provided "as is" without warranty.

#### FAQ

**Is a key required?** No for House votes. Yes (free, your own) for sponsorship data.
**Why not the Senate?** Senate.gov blocks automated clients and we don't bypass blocks.
**Can it track many members?** Up to 50 per run. Roll calls are shared across members, so adding members barely adds requests.

Built by **Clearfeed Labs**: clean, compliant data feeds. Found an issue or want a feature? Open an issue on the Actor's Issues tab with a small example input.

# Actor input Schema

## `members` (type: `array`):

Bioguide IDs (e.g. P000197; find them at bioguide.congress.gov or congress.gov member URLs) or 'LastName ST' as printed in House roll calls (e.g. 'Adams NC'). Up to 50.

## `years` (type: `array`):

Calendar years of House roll calls to scan, newest first (1990 onward, up to 4).

## `maxRollCalls` (type: `integer`):

Most recent roll calls first. Each roll call is fetched once and cached, so re-runs are fast.

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

Since last run delivers each vote, bill and flag once per stateKey.

## `includeVoteRows` (type: `boolean`):

One row per member per roll call.

## `onlyFinalVotes` (type: `boolean`):

Passage, suspension, adoption, conference report, concurrence and veto override questions only (skips procedural votes).

## `onlyPartyBreaks` (type: `boolean`):

Only votes where the member voted Yea/Nay against the majority of their party on that roll call.

## `includePositionFlags` (type: `boolean`):

Neutral flags with links to every source record: different Yea/Nay votes on passage-type questions for the same measure, and (with a Congress.gov key) Nay votes on measures the member sponsored or cosponsored.

## `congressApiKey` (type: `string`):

Free key from https://api.congress.gov/sign-up/ (api.data.gov). Enables sponsored/cosponsored bill rows and sponsorship flags. Used only for your run and never logged or stored.

## `includeCosponsored` (type: `boolean`):

Also return bills the member cosponsored (needs congressApiKey).

## `maxBillsPerMember` (type: `integer`):

Most recent first.

## `addScorecard` (type: `boolean`):

Participation rate, missed votes and party-agreement rate over the scanned roll calls, with method and sources.

## `stateKey` (type: `string`):

Separate watchlists keep separate since-last-run memory.

## Actor input object example

```json
{
  "members": [
    "P000197"
  ],
  "years": [
    2026
  ],
  "maxRollCalls": 100,
  "mode": "all",
  "includeVoteRows": true,
  "onlyFinalVotes": false,
  "onlyPartyBreaks": false,
  "includePositionFlags": true,
  "includeCosponsored": false,
  "maxBillsPerMember": 50,
  "addScorecard": false,
  "stateKey": "default"
}
```

# Actor output Schema

## `rows` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {
    "members": [
        "P000197"
    ],
    "years": [
        2026
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("clearfeedlabs/legislator-record-tracker").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 = {
    "members": ["P000197"],
    "years": [2026],
}

# Run the Actor and wait for it to finish
run = client.actor("clearfeedlabs/legislator-record-tracker").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 '{
  "members": [
    "P000197"
  ],
  "years": [
    2026
  ]
}' |
apify call clearfeedlabs/legislator-record-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,clearfeedlabs/legislator-record-tracker"
        }
    }
}
```

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/K6qGmwjcrbmXpw1Fl/builds/VgWfnxFxIDX3nHlgi/openapi.json