# Congress Stock Trades API: US House STOCK Act since 2014 (`bosco_labs/us-house-trades`) Actor

Congress stock trades: stock, option, fund and bond trades that US House members disclose in STOCK Act Periodic Transaction Reports, from the Clerk's official filings since 2014 (no Senate). Each row: ticker, amount range, owner, disclosure delay. Filter by member, ticker, type, amount, date.

- **URL**: https://apify.com/bosco_labs/us-house-trades.md
- **Developed by:** [Bosco Labs](https://apify.com/bosco_labs) (community)
- **Categories:** Business, News, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 house member trades

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 API: US House STOCK Act since 2014

Get **congress stock trades: every stock, option, fund and bond trade that members of the US
House of Representatives disclose** in their Periodic Transaction Reports (PTRs) under the STOCK Act, one clean row per
transaction: member, state/district, filing date, trade date, days to disclose, owner (self,
spouse, joint, child), ticker, asset type, purchase/sale/exchange and the amount range as
numbers. Straight from the official filings of the Clerk of the House, with a link to the PTR
PDF on every row. **Pricing: $1.80 per 1,000 trades ($0.0018 per trade), no start fee.** You
only pay for trades delivered, and the Actor stops at your max charge limit.

History goes back to the first online PTRs in **January 2014**. The Clerk publishes one index
per year; the Actor reads the index, downloads each online PTR PDF and parses its transaction
table. No logins, no third-party copies.

### What you get

One row per transaction. Real output from Nancy Pelosi's PTR of 24 October 2025:

```json
{
  "schema_version": "1",
  "transaction_id": "20033337-1",
  "member_name": "Nancy Pelosi",
  "first_name": "Nancy",
  "last_name": "Pelosi",
  "state_district": "CA11",
  "state": "CA",
  "filing_date": "2025-10-24",
  "transaction_date": "2025-10-22",
  "notification_date": "2025-10-22",
  "days_to_disclose": 2,
  "owner": "SP",
  "ticker": "AAPL",
  "asset_description": "Apple Inc. - Common Stock (AAPL) [ST]",
  "asset_type": "stock",
  "asset_type_code": "ST",
  "option_type": null,
  "transaction_type": "sale",
  "is_partial": true,
  "amount_min": 100001,
  "amount_max": 250000,
  "amount_text": "$100,001 - $250,000",
  "is_amendment": false,
  "doc_id": "20033337",
  "pdf_url": "https://disclosures-clerk.house.gov/public_disc/ptr-pdfs/2025/20033337.pdf",
  "source_url": "https://disclosures-clerk.house.gov/public_disc/ptr-pdfs/2025/20033337.pdf",
  "retrieved_at": "2026-11-05T16:38:21+00:00"
}
```

| Field | Meaning |
|---|---|
| `member_name`, `first_name`, `last_name` | As listed in the Clerk's index |
| `state_district`, `state` | e.g. `CA11`, `CA` |
| `filing_date` | When the PTR was filed, i.e. when the trade became public |
| `transaction_date`, `notification_date` | Trade date and the date the member was notified |
| `days_to_disclose` | `filing_date - transaction_date` in days (the STOCK Act asks for 30 days after notification, 45 at most after the trade) |
| `owner` | `SP` spouse, `JT` joint, `DC` dependent child, `null` the member |
| `ticker` | Only when the filing gives it in parentheses, upper-cased; otherwise `null` |
| `asset_description`, `asset_type_code` | Asset as filed, and the Clerk's code (`ST`, `OP`, `EF`, `GS`, ...) |
| `asset_type` | `stock`, `option`, `fund`, `bond` or `other` (from the code) |
| `option_type` | `call` or `put` for options |
| `transaction_type`, `is_partial` | `purchase`, `sale` (full or partial) or `exchange` |
| `amount_min`, `amount_max`, `amount_text` | The reported range, e.g. 15001 / 50000 / `$15,001 - $50,000`; both equal the value when a filer reports an exact amount; `amount_max` is `null` for "Over" ranges |
| `is_amendment` | The transaction was filed as an amendment |
| `doc_id`, `transaction_id`, `pdf_url`, `source_url` | The filing, a stable row id, and the PDF |
| `schema_version`, `retrieved_at` | Output version and fetch time (UTC) |

### Input

```json
{ "members": ["Pelosi"], "years": ["2024", "2025"], "transactionTypes": ["purchase"], "maxResults": 500 }
```

| Field | Meaning |
|---|---|
| `members` | Name contains, e.g. `"Pelosi"`, `"Josh Gottheimer"`. Empty = all members |
| `tickers` | Only these tickers, e.g. `["NVDA", "MSFT"]` |
| `transactionTypes` | `purchase`, `sale`, `exchange`. Default all |
| `filedFrom` / `filedTo` | Filing date range. Default: the last 30 days, or the last 365 days when you set `members` (unless you set `years`) |
| `years` | Whole filing years for history, e.g. `["2020"]` |
| `minAmountUsd` | Lower bound of the range at least this, e.g. `15001`, `1000001` |
| `maxResults` | Max trades, newest filings first. Default 100 |
| `onlyNewSinceLastRun` | For schedules: skip trades you already received with the same filters |

Running without input returns up to 100 trades filed in the last 30 days. A run also stores a
`SUMMARY` record in its key-value store: trades delivered, and the URLs of paper PTRs it skipped.

### Use cases

- **Journalism and research:** who traded what, and how late it was disclosed
  (`days_to_disclose`), across all members since 2014.
- **Transparency and watchdog tools:** a member's full trading history in one call.
- **Alerts:** schedule the Actor daily with `onlyNewSinceLastRun` and send new filings to Slack,
  email or a spreadsheet; you only pay for new trades.
- **Data pipelines:** export to CSV, Excel, Google Sheets or your warehouse via the Apify API.

### Use with AI agents (MCP)

Agents can call this Actor as a tool through the
[Apify MCP server](https://github.com/apify/apify-mcp-server). Add this server URL to your MCP
client (Claude, Cursor, VS Code, ...):

```text
https://mcp.apify.com?tools=bosco_labs/us-house-trades
```

It loads this Actor as a tool, plus the tools that read its results (`get-actor-run`,
`get-dataset-items`). The hosted server signs you in with OAuth, or accepts your Apify token as
`Authorization: Bearer <APIFY_TOKEN>`. On the default server (`https://mcp.apify.com`), agents
can also find this Actor with `search-actors` and run it with `call-actor`.

Example prompts this Actor answers:

- *"Which options did Nancy Pelosi's household trade in 2025, and how many days after the trade were they disclosed?"*
- *"Which House members disclosed NVDA trades in the last 30 days?"*
- *"List House trades over $1 million filed in 2024."*

For the first one, the agent passes:

```json
{"members": ["Pelosi"], "years": ["2025"]}
```

**Output for agents:** stable, typed JSON, one row per transaction. Every row has `schema_version` and a `source_url` pointing to the PTR PDF on the Clerk's site, so the agent can cite its source. House only: Senate trades are not included.

**Cost:** $0.0018 per trade, billed to the Apify account the MCP server is signed in with.

### FAQ

**Which filings are covered?** Periodic Transaction Reports of House members filed online, from
January 2014 to the latest update of the Clerk's index. Annual financial disclosure
reports and the Senate are not included.

**What about paper filings?** Some PTRs are scanned paper forms (about 12% in 2026, more than
half in 2014). They have no text, so they are skipped rather than guessed; the run log and the
`SUMMARY` record list their PDF links so you can read them yourself.

**Why is the ticker empty?** The ticker is taken only from the filing, when the member wrote it
in parentheses. Bonds, Treasury bills, private funds and many older filings have none. Nothing
is looked up or guessed.

**Why is `asset_type` empty on old rows?** Filings before about 2018 carry no asset type code.
Options are still recognised from their description; other rows stay `null`.

**Amendments?** `is_amendment` is true when the transaction was filed as an amendment. Its
`filing_date` is the amendment's date, not when the trade first became public, so
`days_to_disclose` overstates the delay for those rows.

**Why upper/lower case oddities?** Some older PDFs garble the case of the asset text (e.g.
`(bAbA)`). `asset_description` is kept as filed; `ticker` is upper-cased.

**How fresh?** As fresh as the Clerk's yearly index, which is regenerated regularly: the copy
fetched on 2026-11-05 was dated 2026-11-04 and listed filings up to 2026-11-03.

**Is this trading advice?** No. This is a copy of public disclosures, with ranges instead of
exact amounts and trades that become public weeks after they happen.

**Legal?** These are public disclosures published by the Clerk under the STOCK Act. Users are
responsible for complying with applicable law on the use of these disclosures, including
5 U.S.C. 13107.

# Actor input Schema

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

Case-insensitive part of the member's name as listed by the Clerk, e.g. \["Pelosi"] or \["Josh Gottheimer"]. Empty = all House members.

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

Only trades whose filing names one of these tickers, e.g. \["NVDA", "MSFT", "BRK.B"]. Trades without a ticker in the filing are left out when this is set. Empty = all.

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

Any of purchase, sale (full or partial), exchange, e.g. \["purchase"]. Default all three.

## `filedFrom` (type: `string`):

Earliest filing date (when the trade became public), YYYY-MM-DD, e.g. "2025-01-01". Empty = 365 days ago when `members` is set, else 30 days ago; ignored when `years` is set without dates.

## `filedTo` (type: `string`):

Latest filing date, YYYY-MM-DD, e.g. "2025-12-31". Empty = today.

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

Whole filing years to load, as strings, e.g. \["2024", "2025"] (one Clerk index per year; online PTRs start in 2014). Without dates, returns those whole years. Use this or `filedFrom` for history.

## `minAmountUsd` (type: `integer`):

Only trades whose reported range starts at or above this USD amount, e.g. 15001 leaves out the smallest $1,001 - $15,000 range, 1000001 keeps trades over $1 million. Empty = no minimum.

## `maxResults` (type: `integer`):

Maximum trades, newest filings first, e.g. 500. Default 100. You pay per trade returned.

## `onlyNewSinceLastRun` (type: `boolean`):

true = skip (and don't charge for) trades an earlier run with the same filters already delivered. For scheduled runs. Default false. Remembered in a named key-value store in your account.

## Actor input object example

```json
{
  "members": [
    "Pelosi"
  ],
  "transactionTypes": [
    "purchase",
    "sale",
    "exchange"
  ],
  "years": [
    "2026"
  ],
  "maxResults": 50,
  "onlyNewSinceLastRun": false
}
```

# Actor output Schema

## `results` (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": [
        "Pelosi"
    ],
    "years": [
        "2026"
    ],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("bosco_labs/us-house-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 = {
    "members": ["Pelosi"],
    "years": ["2026"],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("bosco_labs/us-house-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 '{
  "members": [
    "Pelosi"
  ],
  "years": [
    "2026"
  ],
  "maxResults": 50
}' |
apify call bosco_labs/us-house-trades --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bosco_labs/us-house-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/MZTd7RcekZmYasBVg/builds/FecwyRkIQF2r5gIzU/openapi.json