Congressional Trading API

Retrieve stock trading activity from US House Representatives and Senators disclosed under the STOCK Act. House and Senate trades are served by separate endpoints with an identical schema.

Endpoints

GET /v2/congress/house/{symbol}
GET /v2/congress/senate/{symbol}

Authentication

The API supports multiple authentication methods:

Method	Example
Bearer token (recommended)	`Authorization: Bearer YOUR_API_KEY`
X-API-Key header	`X-API-Key: YOUR_API_KEY`
Query parameter	`?apiKey=YOUR_API_KEY`
Legacy query parameter	`?token=YOUR_API_KEY`

Parameters

Path Parameters

Parameter	Type	Required	Description
`symbol`	string	Yes	Stock ticker symbol (e.g., `AAPL`, `NVDA`)

Query Parameters

Parameter	Type	Required	Description
`startDate`	string	No	Start date (YYYY-MM-DD)
`endDate`	string	No	End date (YYYY-MM-DD)
`limit`	integer	No	Maximum number of results to return

startDate and endDate filter on the transaction date, not on disclosureDate. A trade executed inside the window is returned even if it was disclosed after endDate.

Request

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

house_df = fb.house_trades.ticker("NVDA",
                                  date_from="2025-01-01",
                                  date_to="2025-06-30",
                                  as_dataframe=True)
senate_df = fb.senate_trades.ticker("NVDA",
                                    date_from="2025-01-01",
                                    date_to="2025-06-30",
                                    as_dataframe=True)
print(house_df)
print(senate_df)

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/congress/house/AAPL"

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/congress/senate/AAPL"

import requests

headers = {"Authorization": "Bearer YOUR_API_KEY"}

for chamber in ["house", "senate"]:
    response = requests.get(
        f"https://api.finbrain.tech/v2/congress/{chamber}/AAPL",
        headers=headers,
        params={"limit": 10}
    )
    data = response.json()

    for t in data["data"]["trades"]:
        disclosed = t["disclosureDate"] or "not disclosed"
        owner = t["owner"] or "?"
        print(f"{t['date']} - {t['politician']} ({chamber}, {owner}): "
              f"{t['transactionType']} ({t['amount']}) disclosed {disclosed}")

#include <iostream>
#include <string>
#include <curl/curl.h>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* userp) {
    userp->append((char*)contents, size * nmemb);
    return size * nmemb;
}

json get_congress_trades(const std::string& chamber, const std::string& symbol,
                         const std::string& api_key) {
    CURL* curl = curl_easy_init();
    std::string response;

    if (curl) {
        std::string url = "https://api.finbrain.tech/v2/congress/" + chamber + "/" + symbol;

        struct curl_slist* headers = nullptr;
        std::string auth_header = "Authorization: Bearer " + api_key;
        headers = curl_slist_append(headers, auth_header.c_str());

        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
        curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }

    return json::parse(response);
}

int main() {
    for (const std::string& chamber : {"house", "senate"}) {
        auto result = get_congress_trades(chamber, "AAPL", "YOUR_API_KEY");

        for (auto& t : result["data"]["trades"]) {
            std::string disclosed = t["disclosureDate"].is_null()
                ? "not disclosed"
                : t["disclosureDate"].get<std::string>();

            std::cout << t["date"].get<std::string>() << " - "
                      << t["politician"].get<std::string>() << " (" << chamber << "): "
                      << t["transactionType"].get<std::string>()
                      << " (" << t["amount"].get<std::string>() << ")"
                      << " disclosed " << disclosed
                      << std::endl;
        }
    }

    return 0;
}

use reqwest::blocking::Client;
use serde::Deserialize;
use std::error::Error;

#[derive(Debug, Deserialize)]
struct CongressTrade {
    date: String,
    politician: String,
    #[serde(rename = "transactionType")]
    transaction_type: String,
    amount: String,
    owner: Option<String>,
    #[serde(rename = "amountRaw")]
    amount_raw: Option<String>,
    #[serde(rename = "amountFlag")]
    amount_flag: Option<String>,
    #[serde(rename = "disclosureDate")]
    disclosure_date: Option<String>,
}

#[derive(Debug, Deserialize)]
struct CongressData {
    symbol: String,
    name: String,
    chamber: String,
    trades: Vec<CongressTrade>,
}

#[derive(Debug, Deserialize)]
struct CongressTradesResponse {
    success: bool,
    data: CongressData,
}

fn get_congress_trades(chamber: &str, symbol: &str, api_key: &str)
    -> Result<CongressTradesResponse, Box<dyn Error>> {
    let url = format!(
        "https://api.finbrain.tech/v2/congress/{}/{}",
        chamber, symbol
    );

    let client = Client::new();
    let response: CongressTradesResponse = client
        .get(&url)
        .bearer_auth(api_key)
        .send()?
        .json()?;

    Ok(response)
}

fn main() -> Result<(), Box<dyn Error>> {
    for chamber in ["house", "senate"] {
        let result = get_congress_trades(chamber, "AAPL", "YOUR_API_KEY")?;

        for t in &result.data.trades {
            let disclosed = t.disclosure_date.as_deref().unwrap_or("not disclosed");
            println!("{} - {} ({}): {} ({}) disclosed {}",
                t.date, t.politician, chamber, t.transaction_type, t.amount, disclosed);
        }
    }

    Ok(())
}

for (const chamber of ["house", "senate"]) {
  const response = await fetch(
    `https://api.finbrain.tech/v2/congress/${chamber}/AAPL`,
    { headers: { "Authorization": "Bearer YOUR_API_KEY" } }
  );
  const result = await response.json();

  for (const t of result.data.trades) {
    const disclosed = t.disclosureDate ?? "not disclosed";
    console.log(`${t.date} - ${t.politician} (${chamber}): ${t.transactionType} (${t.amount}) disclosed ${disclosed}`);
  }
}

Response

Success Response (200 OK)

{
  "success": true,
  "data": {
    "symbol": "AAPL",
    "name": "Apple Inc.",
    "chamber": "house",
    "trades": [
      {
        "date": "2025-11-24",
        "politician": "Debbie Dingell",
        "transactionType": "Sale",
        "amount": "$50,001 - $100,000",
        "owner": "SELF",
        "amountRaw": null,
        "amountFlag": null,
        "disclosureDate": "2025-12-16"
      },
      {
        "date": "2024-03-11",
        "politician": "Debbie Dingell",
        "transactionType": "Purchase",
        "amount": "$1,001 - $15,000",
        "owner": "SP",
        "amountRaw": "$1,001-15,000",
        "amountFlag": null,
        "disclosureDate": "2024-04-05"
      }
    ]
  },
  "meta": {
    "timestamp": "2026-01-19T15:06:31.764Z"
  }
}

The Senate endpoint returns the same structure with "chamber": "senate".

Response Fields

Field	Type	Description
`success`	boolean	Whether the request was successful
`data.symbol`	string	Stock ticker symbol
`data.name`	string	Company name
`data.chamber`	string	Congressional chamber (`house` or `senate`)
`data.trades`	array	Array of trade objects
`meta.timestamp`	string	Response timestamp (ISO 8601)

Trade Object Fields

Field	Type	Description
`date`	string	Transaction date (YYYY-MM-DD)
`politician`	string	Name of the House or Senate member
`transactionType`	string	Transaction type (Purchase or Sale)
`amount`	string	Transaction amount (exact value or range), normalized to the statutory STOCK Act brackets where possible — see Amount Ranges
`owner`	string or null	Beneficial owner of the account: `SELF` (the member’s own account), `SP` (spouse), `DC` (dependent child), `JT` (joint), or a member-specific account code. Senate filings that leave the owner column blank report `UNKNOWN`; House filings that leave it blank report `SELF`, per the House PTR-form instructions
`amountRaw`	string or null	The amount string as originally filed — set only when `amount` was rewritten to a canonical bracket, `null` when the filed value was already canonical
`amountFlag`	string or null	`null` on clean rows; `review` when the filed amount was unusable, `ambiguous` when it had two defensible readings (in both cases `amount` keeps the raw string as filed)
`disclosureDate`	string or null	Date the trade was publicly disclosed in the periodic transaction report (YYYY-MM-DD). The STOCK Act allows up to 45 days, so this is the correct point-in-time anchor for backtesting. Nullable, but nulls are rare — historical rows were backfilled

Amount Ranges

amount is normalized to the statutory STOCK Act brackets below whenever the filed string is an unambiguous formatting variant of one; the original filed string is preserved in amountRaw. Open-ended filing categories ("Over $1,000,000", "Under $1,000", "Over $50,000,000") and exact values are kept as filed. A filing whose amount could not be read reports amount as "Unknown" with amountFlag set to review.

Range	Min	Max
$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

Errors

Code	Error	Description
400	Bad Request	Invalid symbol
401	Unauthorized	Invalid or missing API key
403	Forbidden	Authenticated, but not authorized to access this resource
404	Not Found	Ticker not found
429	Too Many Requests	Rate limit exceeded — wait and retry
500	Internal Server Error	Server-side error

Congressional Trading Dataset - Use cases and analysis examples
Screener API - Screen congressional trades across tickers
Insider Transactions - SEC Form 4 data
Price Forecasts - Price forecasts