# Congressional Trading Tracker (`gochujang/congressional-trading-tracker`) Actor

Track US Congress stock trades (House + Senate PTR). Filter by politician, ticker, buy/sell, date. Real-time data from official disclosures. $0.001/start + $0.001/trade.

- **URL**: https://apify.com/gochujang/congressional-trading-tracker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 trade trackeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Congressional Trading Tracker

> Track **US Congress stock trades** (House + Senate) in real time. Filter by politician, ticker symbol, buy/sell type, and date range. Data from official House/Senate Periodic Transaction Reports (PTR) — **no API key required**.

### What does Congressional Trading Tracker do?

Members of US Congress are required to disclose stock trades within 45 days under the STOCK Act. This actor scrapes those disclosures and returns structured trade records: who bought or sold what, when, and for how much.

Run it with default settings to get the 200 most recent congressional trades across both chambers. Filter by politician name, ticker, or date range to build custom alerts or track specific positions.

***

### Why use this?

- **Trading edge** — Congress members outperform the market by 12% annually on average (academic research, 2004–2021). Following their trades is a legitimate quant signal.
- **No API key** — unlike financial data providers that charge $200–$2,000/month for insider trading data, this actor pulls from public government disclosures.
- **Schedulable** — run weekly on Apify Scheduler and push to Slack, Google Sheets, or a webhook for continuous monitoring.
- **Filterable** — watch a specific senator's trades, track who's buying NVDA, or alert on any sell above $100k.

***

### Use Cases

1. **Smart money following** — Schedule weekly and push new trades to your watchlist
2. **Ticker-specific alerts** — Filter by `ticker=NVDA` to see which Congress members are loading up on AI stocks
3. **Politician tracking** — Follow a specific politician's full trade history
4. **Quant research** — Export full dataset for backtesting a "follow Congress" strategy
5. **Compliance/journalism** — Track potential conflicts of interest by committee assignment

***

### How to use

1. Click **Try for free** — runs with default settings in 30 seconds
2. Set filters (all optional): politician name, ticker, chamber, buy/sell
3. Optionally add a date range (e.g., last 30 days)
4. Run — get structured JSON with all matching trades

To monitor continuously: **Schedules → New Schedule → every Monday 9am** → connect to a Webhook.

***

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `politician` | string | — | Politician name or slug (e.g. `nancy-pelosi`, `nancy pelosi`) |
| `ticker` | string | — | Stock ticker to filter (e.g. `NVDA`, `AAPL`) |
| `chamber` | string | all | `house`, `senate`, or empty for both |
| `tradeType` | string | all | `buy`, `sell`, or empty for all |
| `dateFrom` | string | — | Start date `YYYY-MM-DD` |
| `dateTo` | string | — | End date `YYYY-MM-DD` |
| `maxTrades` | integer | 200 | Maximum records to return (1–1000) |

#### Example inputs

**Recent Pelosi trades:**

```json
{
  "politician": "nancy-pelosi",
  "maxTrades": 50
}
```

**Who's buying NVDA?**

```json
{
  "ticker": "NVDA",
  "tradeType": "buy",
  "dateFrom": "2026-01-01"
}
```

**Senate sells this month:**

```json
{
  "chamber": "senate",
  "tradeType": "sell",
  "dateFrom": "2026-08-01",
  "maxTrades": 100
}
```

***

### Output

Each trade record contains:

| Field | Example | Description |
|---|---|---|
| `politician` | `Nancy Pelosi` | Full name of Congress member |
| `politician_id` | `nancy-pelosi` | URL slug |
| `party` | `D` | Political party (D/R/I) |
| `chamber` | `house` | house or senate |
| `state` | `CA` | State represented |
| `ticker` | `NVDA` | Asset ticker symbol |
| `company` | `Nvidia Corporation` | Full company name |
| `trade_type` | `buy` | buy or sell |
| `amount_min` | `1001` | Minimum amount ($) |
| `amount_max` | `15000` | Maximum amount ($) |
| `amount_midpoint` | `8000.5` | Midpoint estimate ($) |
| `amount_text` | `$1,001 - $15,000` | Original range string |
| `traded_date` | `2026-07-15` | Date of transaction |
| `filed_date` | `2026-08-10` | Date disclosure was filed |

**Sample output:**

```json
[
  {
    "rank": 1,
    "politician": "Nancy Pelosi",
    "politician_id": "nancy-pelosi",
    "party": "D",
    "chamber": "house",
    "state": "CA",
    "ticker": "NVDA",
    "company": "Nvidia Corporation",
    "trade_type": "buy",
    "amount_min": 250001,
    "amount_max": 500000,
    "amount_midpoint": 375000.5,
    "amount_text": "$250,001 - $500,000",
    "traded_date": "2026-07-15",
    "filed_date": "2026-08-05"
  }
]
```

You can download the dataset in JSON, CSV, Excel, or JSONL format.

***

### Pricing

**Pay-Per-Event**: `$0.001 per actor start` + `$0.001 per trade record returned`.

| Run | Trades | Cost |
|---|---|---|
| Default (200 trades) | 200 | ~$0.20 |
| Quick scan (50 trades) | 50 | ~$0.05 |
| Full export (1000 trades) | 1000 | ~$1.00 |

vs. Quiver Quantitative ($500/yr), Unusual Whales ($600/yr), Bloomberg ($24,000/yr).

***

### Automate with Apify Scheduler

Monitor congressional trades every week automatically:

**Apify Console → Schedules → + New Schedule:**

| Field | Value |
|---|---|
| Actor | Congressional Trading Tracker |
| Cron | `0 9 * * 1` (every Monday 9:00 UTC) |
| Input | `{"maxTrades": 500}` |

Connect to a Webhook (Slack, Discord, email) under **Integrations** to get alerts on new disclosures.

***

### Data Source

Data is sourced from **Capitol Trades** (capitoltrades.com), which aggregates official disclosures filed under the STOCK Act:

- **House PTR** — Periodic Transaction Reports from the House Office of the Clerk
- **Senate PTR** — Electronic Financial Disclosure System (EFTS)

All data is public government information. Congress members are legally required to file these reports within 45 days of any transaction over $1,000.

***

### FAQ

**Why is there a 45-day lag?** Congress members have 45 days after a transaction to file. Some file earlier. The lag is mandated by law.

**Is this legal to use?** Yes. The STOCK Act (2012) requires public disclosure of congressional trades for transparency. This actor retrieves publicly available government data.

**How accurate are the amounts?** Disclosures report ranges (e.g., $1,001–$15,000), not exact amounts. The `amount_midpoint` field gives a best estimate.

**Can I get historical data?** Yes — set `dateFrom` to any past date to retrieve historical disclosures.

***

### Related Actors (same author)

- [Economic Calendar Tracker](https://apify.com/gochujang/economic-calendar-tracker) — FOMC, CPI, NFP macro events
- [Crypto ETF Flow Tracker](https://apify.com/gochujang/crypto-etf-flow-tracker) — BTC/ETH institutional flows
- [Stock Earnings Tracker](https://apify.com/gochujang/stock-earnings-tracker) — Earnings calendar

***

### Feedback

Found a bug or have a feature request? [Leave a review](https://apify.com/gochujang/congressional-trading-tracker#reviews) — responses within 24 hours.

# Actor input Schema

## `politician` (type: `string`):

Filter by politician name or slug (e.g. 'nancy-pelosi', 'nancy pelosi'). Leave empty for all members.

## `ticker` (type: `string`):

Filter by asset ticker symbol (e.g. 'NVDA', 'AAPL', 'MSFT'). Leave empty for all assets.

## `chamber` (type: `string`):

Filter by chamber: 'house', 'senate', or empty for both.

## `tradeType` (type: `string`):

Filter by transaction type: 'buy', 'sell', or empty for all.

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

Start date for trade filter (YYYY-MM-DD, e.g. '2026-01-01'). Leave empty for no start filter.

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

End date for trade filter (YYYY-MM-DD, e.g. '2026-12-31'). Leave empty for no end filter.

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

Maximum number of trade records to return (1-1000). Default: 200.

## Actor input object example

```json
{
  "politician": "",
  "ticker": "",
  "chamber": "",
  "tradeType": "",
  "dateFrom": "",
  "dateTo": "",
  "maxTrades": 200
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/congressional-trading-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/congressional-trading-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 '{}' |
apify call gochujang/congressional-trading-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/congressional-trading-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/sQFyG2Cir1JfQVo9u/builds/T13Tf2Ya9kHJ1w5nq/openapi.json