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:

Representative Name: Name of the House member
Transaction Type: Purchase or Sale
Amount Range: Transaction size bracket as reported
Transaction Date: When the trade occurred
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").

Quick Start

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

# Get congressional trades as DataFrame
df = fb.house_trades.ticker("S&P 500", "NVDA", as_dataframe=True)
print(df.head())

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

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(tickers):
    """Find stocks with large congressional purchases"""
    results = []

    for ticker in tickers:
        try:
            trades = fb.house_trades.ticker("S&P 500", ticker)

            large_purchases = [
                t for t in trades.get("houseTrades", [])
                if t["type"] == "Purchase"
                and t["amount"] in LARGE_TRADES
            ]

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

    return results

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

for alert in alerts:
    print(f"\n{alert['ticker']}:")
    for trade in alert['trades']:
        print(f"  {trade['representative']}: {trade['amount']}")

Follow Specific Representatives

Track trading activity of specific members:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def get_representative_trades(representative_name, tickers):
    """Get all trades by a specific representative"""
    trades_list = []

    for ticker in tickers:
        try:
            trades = fb.house_trades.ticker("S&P 500", ticker)

            rep_trades = [
                {**t, "ticker": ticker}
                for t in trades.get("houseTrades", [])
                if representative_name.lower() in t["representative"].lower()
            ]

            trades_list.extend(rep_trades)
        except Exception:
            continue

    return trades_list

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

for trade in rep_trades:
    print(f"{trade['date']}: {trade['ticker']} - {trade['type']} {trade['amount']}")

Trade Activity Analysis

Analyze buying vs selling activity for a ticker:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def analyze_trade_activity(market, ticker):
    """Analyze congressional trading activity for a ticker"""
    trades = fb.house_trades.ticker(market, ticker)

    trade_data = trades.get("houseTrades", [])

    purchases = [t for t in trade_data if t["type"] == "Purchase"]
    sales = [t for t in trade_data if t["type"] == "Sale"]

    return {
        "ticker": ticker,
        "total_trades": len(trade_data),
        "purchases": len(purchases),
        "sales": len(sales),
        "buy_sell_ratio": len(purchases) / len(sales) if sales else float('inf'),
        "representatives": list(set(t["representative"] for t in trade_data))
    }

analysis = analyze_trade_activity("S&P 500", "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(ticker, min_buyers=3):
    """Find if multiple representatives are buying a stock"""
    trades = fb.house_trades.ticker("S&P 500", ticker)

    purchases = [
        t for t in trades.get("houseTrades", [])
        if t["type"] == "Purchase"
    ]

    # Count unique representatives making purchases
    buyers = set(p["representative"] for p in purchases)

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

    return None

# Check multiple tickers
for ticker in ["NVDA", "AAPL", "MSFT", "GOOGL"]:
    result = find_cluster_buying(ticker)
    if result:
        print(f"{ticker}: {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
Python SDK Documentation