Senate Trades API

Retrieve trading activity from US Senators disclosed under the STOCK Act. Track congressional purchases and sales for any ticker.

Endpoint

GET /v1/senatetrades/{market}/{ticker}

Authentication

Requires API key via token query parameter.

Parameters

Path Parameters

Parameter	Type	Required	Description
market	string	Yes	Market identifier (e.g., S&P 500, NASDAQ)
ticker	string	Yes	Stock ticker symbol (e.g., AAPL, META)

Query Parameters

Parameter	Type	Required	Description
token	string	Yes	Your API key
dateFrom	string	No	Start date (YYYY-MM-DD)
dateTo	string	No	End date (YYYY-MM-DD)

Request

cURL

curl "https://api.finbrain.tech/v1/senatetrades/S%26P%20500/META?token=YOUR_API_KEY"

Python SDK

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

# Get as DataFrame (recommended)
df = fb.senate_trades.ticker("S&P 500", "META", as_dataframe=True)
print(df.head())
#                        senator       type              amount
# date
# 2025-11-13  Shelley Moore Capito  Purchase  $1,001 - $15,000

# Get raw JSON response
trades = fb.senate_trades.ticker("S&P 500", "META")
print(trades)

C++

#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_senate_trades(const std::string& market, const std::string& ticker,
                       const std::string& api_key) {
    CURL* curl = curl_easy_init();
    std::string response;

    if (curl) {
        char* encoded_market = curl_easy_escape(curl, market.c_str(), 0);
        std::string url = "https://api.finbrain.tech/v1/senatetrades/" +
                          std::string(encoded_market) + "/" + ticker +
                          "?token=" + api_key;
        curl_free(encoded_market);

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

    return json::parse(response);
}

int main() {
    auto data = get_senate_trades("S&P 500", "META", "YOUR_API_KEY");

    for (auto& t : data["senateTrades"]) {
        std::cout << t["date"].get<std::string>() << " - "
                  << t["senator"].get<std::string>() << ": "
                  << t["type"].get<std::string>()
                  << " (" << t["amount"].get<std::string>() << ")"
                  << std::endl;
    }

    return 0;
}

Rust

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

#[derive(Debug, Deserialize)]
struct SenateTrade {
    date: String,
    amount: String,
    senator: String,
    #[serde(rename = "type")]
    trade_type: String,
}

#[derive(Debug, Deserialize)]
struct SenateTradesResponse {
    ticker: String,
    name: String,
    #[serde(rename = "senateTrades")]
    senate_trades: Vec<SenateTrade>,
}

fn get_senate_trades(market: &str, ticker: &str, api_key: &str)
    -> Result<SenateTradesResponse, Box<dyn Error>> {
    let url = format!(
        "https://api.finbrain.tech/v1/senatetrades/{}/{}?token={}",
        urlencoding::encode(market), ticker, api_key
    );

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

    Ok(response)
}

fn main() -> Result<(), Box<dyn Error>> {
    let data = get_senate_trades("S&P 500", "META", "YOUR_API_KEY")?;

    for t in &data.senate_trades {
        println!("{} - {}: {} ({})", t.date, t.senator, t.trade_type, t.amount);
    }

    Ok(())
}

JavaScript

const market = encodeURIComponent("S&P 500");
const response = await fetch(
  `https://api.finbrain.tech/v1/senatetrades/${market}/META?token=YOUR_API_KEY`
);
const data = await response.json();

Response

Success Response (200 OK)

{
  "ticker": "META",
  "name": "Meta Platforms Inc.",
  "senateTrades": [
    {
      "date": "2025-11-13",
      "amount": "$1,001 - $15,000",
      "senator": "Shelley Moore Capito",
      "type": "Purchase"
    },
    {
      "date": "2025-10-31",
      "amount": "$1,001 - $15,000",
      "senator": "John Boozman",
      "type": "Purchase"
    }
  ]
}

Response Fields

Field	Type	Description
ticker	string	Stock ticker symbol
name	string	Company name
senateTrades	array	Array of trade objects

Trade Object Fields

Field	Type	Description
date	string	Transaction date (YYYY-MM-DD)
amount	string	Transaction amount (exact value or range)
senator	string	Name of senator
type	string	Transaction type (Purchase or Sale)

Amount Ranges

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 market or ticker
401	Unauthorized	Invalid or missing API key
404	Not Found	Ticker not found
500	Internal Server Error	Server-side error

Related

• House Trades API - US House Representatives trading data
• Congressional Trading Dataset - Use cases and analysis examples
• Insider Transactions - SEC Form 4 data