# Congress Stock Trades Tracker: House STOCK Act Filings (`scrapemint/congress-stock-trades`) Actor

Every stock trade reported by members of the US House, parsed from the Clerk's official STOCK Act filings: member, party, committees, ticker, buy or sell, amount range, trade date and days to disclose. Flags large, option and late trades. No key, no proxy. Pay per trade.

- **URL**: https://apify.com/scrapemint/congress-stock-trades.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, News
- **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

## Congress Stock Trades Tracker: House STOCK Act Filings

Every stock trade reported by a member of the US House of Representatives, parsed from the Clerk of the House's official STOCK Act filings into clean rows: **who traded, their party and committees, what they bought or sold, how much, when, and how long they took to disclose it.**

Put it on a daily schedule and each run returns only filings you have not seen. No key, no login, no browser, no proxy: it reads the Clerk's public files directly.

### What you get

One row per trade:

| Field | Example |
|---|---|
| `member`, `party`, `state`, `district` | `Nancy Pelosi`, `D`, `CA`, `CA11` |
| `committees` | the member's current House committee seats |
| `owner` | `Self`, `Spouse`, `Joint` or `Dependent child` |
| `asset`, `ticker` | `Bloom Energy Corporation Class A`, `BE` |
| `assetType`, `assetTypeCode` | `Stock option`, `OP` |
| `transactionType` | `Purchase`, `Sale`, `Partial sale`, `Exchange` |
| `transactionDate`, `filingDate` | when the trade happened, when it was reported |
| `amountRange`, `amountMin`, `amountMax` | `$1,000,001 - $5,000,000` |
| `description` | the member's own note, e.g. `Purchased 100 call options with a strike price of $100...` |
| `daysToDisclose`, `lateDisclosure` | days from trade to filing; late if over the STOCK Act's 45 days |
| `notable`, `notableReasons` | `large` ($50,001+), `option`, `late` |
| `filingUrl` | the official PDF, so any row can be checked |

### Examples

- **Daily feed of every new trade:** defaults, on a daily schedule
- **Follow specific members:** `members: ["Pelosi", "Wasserman Schultz"]`
- **Who is trading a stock:** `tickers: ["NVDA"]`, `lookbackDays: 365`, `onlyNew: false`
- **Only big moves:** `minAmount: 50000`
- **Options only:** `assetTypes: ["OP"]`
- **One party, one state:** `parties: ["R"]`, `states: ["TX"]`

### How it works

The Clerk publishes a yearly index of every financial disclosure and each Periodic Transaction Report as a PDF. The actor reads the index, keeps trade reports filed in your window, filters by member, party and state before downloading anything, then reads each report's transaction table. Party and committee seats come from the Clerk's official member list.

With `onlyNew` on, reports already returned are remembered in your own account (separately for each set of filters), so a scheduled run returns only new filings. If `maxTrades` stops a run partway through a report, the next run continues from exactly that trade: nothing is skipped and nothing is billed twice.

### Pricing

| Event | Price | When |
|---|---|---|
| `trade_row` | $0.01 | a trade |
| `notable_trade_row` | $0.03 | a trade of $50,001 or more, a stock option, or one disclosed after the 45-day deadline |

A run with no new filings returns nothing and costs nothing.

### Limits, stated plainly

- **House only.** The Senate's disclosure site blocks automated access, so Senate trades are not included.
- **Handwritten filings.** A few members still file on paper. Those reports are scanned images with no text, so their trades cannot be read; each is returned as a free `scanned-filing` row with a link to the PDF.
- **Amounts are ranges.** The law requires ranges (e.g. $1,001 - $15,000), not exact values; a few filers add an exact figure, which is kept as reported.
- **Up to 45 days late by law.** A trade can appear weeks after it happened; `daysToDisclose` shows exactly how late.

# Actor input Schema

## `lookbackDays` (type: `integer`):

Read trade reports filed within this many days. Members have up to 45 days to report a trade, so a trade can be older than its filing.

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

Names or last names, e.g. Pelosi, Taylor, Wasserman Schultz. Leave empty for every member.

## `parties` (type: `array`):

D, R or I.

## `states` (type: `array`):

Two-letter state codes, e.g. CA, TX, NY.

## `tickers` (type: `array`):

Only trades in these tickers, e.g. NVDA, AAPL, MSFT.

## `transactionTypes` (type: `array`):

purchase, sale (includes partial sales) or exchange. Empty for all.

## `assetTypes` (type: `array`):

The filing's own codes: ST stocks, OP options, EF ETFs, MF mutual funds, GS government securities, CS corporate bonds, CT crypto. Empty for all.

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

Skip trades whose reported range tops out below this. 50000 keeps $50,001 and larger.

## `includeSpouseAndJoint` (type: `boolean`):

Off keeps only trades in the member's own name.

## `onlyNew` (type: `boolean`):

On: each run returns only filings earlier runs (with the same filters) have not. For daily alerts. Off: every trade in the window.

## `includeScanned` (type: `boolean`):

Some members still file on paper; those are scanned images with no text. On: each is returned as a free row linking the PDF.

## `maxTrades` (type: `integer`):

Stop after this many trades. With onlyNew on, the next run picks up exactly where this one stopped, so nothing is skipped or billed twice.

## Actor input object example

```json
{
  "lookbackDays": 14,
  "members": [],
  "parties": [],
  "states": [],
  "tickers": [],
  "transactionTypes": [],
  "assetTypes": [],
  "minAmount": 0,
  "includeSpouseAndJoint": true,
  "onlyNew": true,
  "includeScanned": true,
  "maxTrades": 50
}
```

# Actor output Schema

## `trades` (type: `string`):

Member, party, district, committees, owner, asset, ticker, asset type, purchase or sale, trade and filing dates, amount range, days to disclose and notable flags.

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

Reports in the window, reports parsed, scanned paper filings and trades returned.

# 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 = {
    "lookbackDays": 14,
    "maxTrades": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/congress-stock-trades").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 = {
    "lookbackDays": 14,
    "maxTrades": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/congress-stock-trades").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 '{
  "lookbackDays": 14,
  "maxTrades": 50
}' |
apify call scrapemint/congress-stock-trades --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapemint/congress-stock-trades"
        }
    }
}
```

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/NqgeHOKyXiqhoMHq7/builds/71TiVUXhN8aWAEde0/openapi.json