Insider Transactions API

Retrieve insider trading data from SEC Form 4 filings. Track executive purchases, sales, option exercises, and ownership changes for any ticker.

Endpoint

GET /v2/insider-trading/{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`, `MSFT`)

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

Request

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

df = fb.insider_transactions.ticker("AAPL",
                                    date_from="2025-01-01",
                                    date_to="2025-06-30",
                                    as_dataframe=True)
print(df)

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

import requests

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

response = requests.get(
    "https://api.finbrain.tech/v2/insider-trading/AAPL",
    headers=headers,
    params={"limit": 10}
)
data = response.json()

for t in data["data"]["transactions"]:
    print(f"{t['date']} - {t['insider']}: {t['transactionType']} "
          f"({t['shares']} shares @ ${t['pricePerShare']:.2f})")

#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_insider_transactions(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/insider-trading/" + 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() {
    auto result = get_insider_transactions("AAPL", "YOUR_API_KEY");

    for (auto& t : result["data"]["transactions"]) {
        std::cout << t["date"].get<std::string>() << " - "
                  << t["insider"].get<std::string>() << ": "
                  << t["transactionType"].get<std::string>()
                  << " (" << t["shares"].get<int>() << " shares @ $"
                  << t["pricePerShare"].get<double>() << ")"
                  << std::endl;
    }

    return 0;
}

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

#[derive(Debug, Deserialize)]
struct Transaction {
    date: String,
    insider: String,
    relationship: String,
    #[serde(rename = "transactionType")]
    transaction_type: String,
    shares: i64,
    #[serde(rename = "pricePerShare")]
    price_per_share: f64,
    #[serde(rename = "totalValue")]
    total_value: i64,
    #[serde(rename = "sharesOwned")]
    shares_owned: i64,
    #[serde(rename = "filingUrl")]
    filing_url: String,
}

#[derive(Debug, Deserialize)]
struct InsiderData {
    symbol: String,
    name: String,
    transactions: Vec<Transaction>,
}

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

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

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

    Ok(response)
}

fn main() -> Result<(), Box<dyn Error>> {
    let result = get_insider_transactions("AAPL", "YOUR_API_KEY")?;

    for t in &result.data.transactions {
        println!("{} - {}: {} ({} shares @ ${:.2})",
            t.date, t.insider, t.transaction_type, t.shares, t.price_per_share);
    }

    Ok(())
}

const response = await fetch(
  "https://api.finbrain.tech/v2/insider-trading/AAPL",
  { headers: { "Authorization": "Bearer YOUR_API_KEY" } }
);
const result = await response.json();

for (const t of result.data.transactions) {
  console.log(`${t.date} - ${t.insider}: ${t.transactionType} (${t.shares} shares @ $${t.pricePerShare})`);
}

Response

Success Response (200 OK)

{
  "success": true,
  "data": {
    "symbol": "AAPL",
    "name": "Apple Inc.",
    "transactions": [
      {
        "date": "2026-06-15",
        "insider": "Ben Borders",
        "relationship": "Principal Accounting Officer",
        "transactionType": "Sale",
        "shares": 116,
        "pricePerShare": 295.14,
        "totalValue": 34236,
        "sharesOwned": 38713,
        "filingDate": "2026-06-17",
        "filingUrl": "https://www.sec.gov/Archives/edgar/data/2100523/000114036126025620"
      }
    ]
  },
  "meta": {
    "timestamp": "2026-01-19T15:06:21.699Z"
  }
}

Response Fields

Field	Type	Description
`success`	boolean	Whether the request was successful
`data.symbol`	string	Stock ticker symbol
`data.name`	string	Company name
`data.transactions`	array	Array of transaction objects
`meta.timestamp`	string	Response timestamp (ISO 8601)

Transaction Object Fields

Field	Type	Description
`date`	string	Transaction date (YYYY-MM-DD)
`insider`	string	Insider name
`relationship`	string	Insider’s role/relationship
`transactionType`	string	Type of transaction (see Transaction Types below)
`shares`	integer	Number of shares
`pricePerShare`	number	Transaction price per share
`totalValue`	integer	Total transaction value in USD
`sharesOwned`	integer	Total shares owned after transaction
`filingDate`	string	Date the Form 4 was filed with the SEC and became public (YYYY-MM-DD). SEC rules require filing within 2 business days of the transaction, so this is the correct point-in-time anchor for backtesting
`filingUrl`	string	Link to SEC Form 4 filing

Transaction Types

Type	Description
Purchase	Open market buy
Sale	Open market sell
Derivative_Purchase	Derivative security buy
Derivative_Sale	Derivative security sell
Exercise	Option/warrant exercise
Award	Grant/award from company
Gift	Shares donated
Tax	Tax withholding on vesting
Conversion	Security conversion (NASDAQ only)
Other_Acquisition	Other share acquisition
Other_Disposition	Other share disposition

These can be grouped for analysis:

Acquisitions: Purchase, Derivative_Purchase, Exercise, Award, Other_Acquisition
Dispositions: Sale, Derivative_Sale, Tax, Gift, Other_Disposition
Neutral: Conversion

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

Insider Transactions Dataset - Use cases and analysis examples
Congressional Trading - US House and Senate trading data
Price Forecasts - Price forecasts