House Trades Dataset

Access trading activity from US House Representatives. Track stock purchases and sales disclosed under the STOCK Act for systematic trading strategies that follow political insiders.

For US Senate trading data, see the Senate Trades Dataset.

What’s Included

The House Trades dataset provides:

Politician Name: Name of the House member
Transaction Type: Purchase or Sale
Amount Range: Transaction size bracket as reported
Transaction Date: When the trade occurred
Chamber: Identifies the trade as originating from the House
Historical Data: Years of congressional trading history

Coverage

Filing Type	Description	Update Frequency
Periodic Transaction Report	Stock trades by members	As filed
Annual Financial Disclosure	Comprehensive holdings	Annual

Amount Ranges

Congressional disclosures report amounts in ranges:

Range	Minimum	Maximum
$1,001 - $15,000	$1,001	$15,000
$15,001 - $50,000	$15,001	$50,000
$50,001 - $100,000	$50,001	$100,000
$100,001 - $250,000	$100,001	$250,000
$250,001 - $500,000	$250,001	$500,000
$500,001 - $1,000,000	$500,001	$1,000,000
$1,000,001 - $5,000,000	$1,000,001	$5,000,000
Over $5,000,000	$5,000,001	N/A

Note: The amount field can be an exact value (e.g., "$360.00") or a range (e.g., "$15,001 - $50,000").

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

df = fb.house_trades.ticker("NVDA", as_dataframe=True)
print(df)

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.finbrain.tech/v2"

response = requests.get(
    f"{BASE_URL}/congress/house/NVDA",
    headers={"Authorization": f"Bearer {API_KEY}"}
)

data = response.json()
for trade in data["data"]["trades"]:
    print(f"{trade['date']}: {trade['politician']} - {trade['transactionType']} {trade['amount']}")

For complete code examples in Python, JavaScript, C++, Rust, and cURL, see the API Reference.

Visualization

Plot House trades on a price chart with the built-in SDK chart. You must supply your own price data:

from finbrain import FinBrainClient
import yfinance as yf

fb = FinBrainClient(api_key="YOUR_API_KEY")

# Provide your own price data
price_df = yf.download("NVDA", start="2024-01-01", end="2025-01-01")

# One-line interactive chart with buy/sell markers on price
fb.plot.house_trades("NVDA", price_df)

House Trades Chart — NVDA House Representative trades overlaid on price chart

Use Cases

Congressional Trade Alert System

Build alerts for significant congressional purchases:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

LARGE_TRADES = [
    "$500,001 - $1,000,000",
    "$1,000,001 - $5,000,000",
    "Over $5,000,000"
]

def scan_large_congressional_trades(symbols):
    """Find stocks with large congressional purchases"""
    results = []

    for symbol in symbols:
        try:
            df = fb.house_trades.ticker(symbol, as_dataframe=True)

            large_purchases = df[
                (df["transactionType"] == "Purchase") &
                (df["amount"].isin(LARGE_TRADES))
            ]

            if not large_purchases.empty:
                results.append({
                    "symbol": symbol,
                    "trades": large_purchases
                })
        except Exception:
            continue

    return results

# Scan popular stocks
symbols = ["NVDA", "AAPL", "MSFT", "GOOGL", "AMZN", "META", "TSLA"]
alerts = scan_large_congressional_trades(symbols)

for alert in alerts:
    print(f"\n{alert['symbol']}:")
    for _, trade in alert['trades'].iterrows():
        print(f"  {trade['politician']}: {trade['amount']}")

Follow Specific Representatives

Track trading activity of specific members:

from finbrain import FinBrainClient
import pandas as pd

fb = FinBrainClient(api_key="YOUR_API_KEY")

def get_representative_trades(politician_name, symbols):
    """Get all trades by a specific representative"""
    all_trades = []

    for symbol in symbols:
        try:
            df = fb.house_trades.ticker(symbol, as_dataframe=True)
            mask = df["politician"].str.lower().str.contains(politician_name.lower())
            matched = df[mask].copy()
            matched["symbol"] = symbol
            all_trades.append(matched)
        except Exception:
            continue

    return pd.concat(all_trades) if all_trades else pd.DataFrame()

# Track a specific representative's trades
rep_trades = get_representative_trades(
    "Pelosi",
    ["NVDA", "AAPL", "MSFT", "GOOGL", "AMZN", "CRM", "RBLX"]
)

for date, row in rep_trades.iterrows():
    print(f"{date}: {row['symbol']} - {row['transactionType']} {row['amount']}")

Trade Activity Analysis

Analyze buying vs selling activity for a symbol:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def analyze_trade_activity(symbol):
    """Analyze congressional trading activity for a symbol"""
    df = fb.house_trades.ticker(symbol, as_dataframe=True)

    purchases = df[df["transactionType"] == "Purchase"]
    sales = df[df["transactionType"] == "Sale"]

    return {
        "symbol": symbol,
        "total_trades": len(df),
        "purchases": len(purchases),
        "sales": len(sales),
        "buy_sell_ratio": len(purchases) / len(sales) if len(sales) > 0 else float('inf'),
        "politicians": df["politician"].unique().tolist()
    }

analysis = analyze_trade_activity("NVDA")
print(f"Total trades: {analysis['total_trades']}")
print(f"Purchases: {analysis['purchases']}, Sales: {analysis['sales']}")
print(f"Buy/Sell Ratio: {analysis['buy_sell_ratio']:.2f}")

Multi-Representative Buying Signal

Find stocks where multiple representatives are buying:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def find_cluster_buying(symbol, min_buyers=3):
    """Find if multiple representatives are buying a stock"""
    df = fb.house_trades.ticker(symbol, as_dataframe=True)

    purchases = df[df["transactionType"] == "Purchase"]

    # Count unique representatives making purchases
    buyers = purchases["politician"].unique()

    if len(buyers) >= min_buyers:
        return {
            "symbol": symbol,
            "unique_buyers": len(buyers),
            "total_purchases": len(purchases),
            "politicians": list(buyers)
        }

    return None

# Check multiple symbols
for symbol in ["NVDA", "AAPL", "MSFT", "GOOGL"]:
    result = find_cluster_buying(symbol)
    if result:
        print(f"{symbol}: {result['unique_buyers']} unique buyers")

House Trades API Reference - Endpoint details, parameters, and response schema
Senate Trades Dataset - US Senate trading data
Congressional Trade Signals Guide - Build trading strategies
Insider Transactions - Corporate insider trades