# Boardroom Buys: SEC Insider Trading Tracker & Cluster Buys (`cybermax/sec-insider-tracker`) Actor

See what CEOs, CFOs and directors buy with their own money. SEC Form 4 insider trades as clean JSON for your watchlist or the whole market, with automatic cluster-buy alerts when 2+ insiders buy. From $0.004 per trade, no subscription.

- **URL**: https://apify.com/cybermax/sec-insider-tracker.md
- **Developed by:** [CyberMax](https://apify.com/cybermax) (community)
- **Categories:** Lead generation, Business, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Boardroom Buys: SEC insider trading tracker & cluster buy alerts

**Know when the people who run a company buy its stock with their own money.** Boardroom Buys turns
SEC EDGAR Form 4 filings into one clean JSON row per insider trade (who, what, how many shares,
at what price) for your watchlist or the whole market. It flags a **cluster buy** when 2+ different
insiders at the same company buy on the open market within days, a signal some investors watch closely.

### Why Boardroom Buys

- **Pay per trade, not per month.** Sites like WhaleWisdom, Quiver Quantitative and sec-api.io charge
  $19–$239/month to package this public SEC data. Here it's $0.004 per trade, with no subscription.
- **Signal, not noise.** By default you get only open-market buys and sells (codes `P`/`S`). Option
  exercises, stock grants, gifts and trades below your minimum dollar value are dropped.
- **Ready for code and AI agents.** Form 4s arrive as one XML file per filing; you get a stable JSON
  schema instead, callable from any MCP client through Apify's MCP server.

**Example row (trimmed):**

```json
{ "issuer": { "name": "NextTrip, Inc.", "ticker": "NTRP" }, "owner": { "name": "Kaplan Andrew Jay", "isDirector": true },
  "transactionDate": "2026-09-17", "transactionCode": "P", "shares": 52910, "pricePerShare": 1.89,
  "totalValueUsd": 99999.9, "clusterBuy": false }
```

### What it does

1. **Watchlist mode** — give it a list of tickers (e.g. `AAPL`, `TSLA`) and it pulls every
   Form 4 filed by those companies' insiders in your lookback window.
2. **Whole-market mode** — leave tickers empty (or turn on "Track whole market") to get
   the newest Form 4 filings across every US-listed issuer, for a general insider-buying
   feed.
3. **Cluster-buy detection** — flags transactions where 2+ different insiders at the same
   company bought on the open market within a configurable window (default 7 days).
4. **Noise filtering** — by default keeps only open-market buys/sells (transaction codes
   `P`/`S`), not option exercises, stock grants or gifts, and drops trades below a minimum
   dollar value.

### Output (one row per transaction)

```json
{
  "issuer": { "cik": "0000788611", "name": "NextTrip, Inc.", "ticker": "NTRP" },
  "owner": { "cik": "0002078356", "name": "Kaplan Andrew Jay", "isDirector": true, "isOfficer": false, "isTenPercentOwner": false },
  "securityType": "non-derivative",
  "transactionDate": "2026-09-17",
  "transactionCode": "P",
  "acquiredDisposedCode": "A",
  "shares": 52910,
  "pricePerShare": 1.89,
  "totalValueUsd": 99999.9,
  "sharesOwnedAfter": 104492,
  "clusterBuy": false,
  "clusterInsiderCount": 1,
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/788611/..."
}
```

### Data source & legality

100% official, public SEC EDGAR data via SEC's own developer-sanctioned endpoints
(`data.sec.gov`, `www.sec.gov`), used per SEC's fair-access policy: a descriptive
User-Agent and a moderate request rate — no login, no CAPTCHA, no anti-bot bypass.
See <https://www.sec.gov/os/webmaster-faq#developers>.

### Limitations

- Form 4 must be filed within 2 business days of the trade, so this is near-real-time,
  not tick-by-tick.
- Joint filings signed by more than one reporting owner attribute every transaction to
  the first listed owner (SEC's schema doesn't split them out).
- Whole-market mode reflects the pace of new filings on EDGAR, not a fixed daily count.

### Pricing

Pay-per-event: one result row = one `insider-transaction` charge; a flagged cluster buy
adds one `cluster-signal` charge. No subscription, no minimum spend.

# Actor input Schema

## `tickers` (type: `array`):

US stock tickers to track (e.g. AAPL, TSLA). Leave empty and enable 'Track whole market' below to get the latest Form 4 filings for every company instead of a watchlist.

## `trackWholeMarket` (type: `boolean`):

If on, pulls the newest Form 4 filings across all US-listed issuers instead of only the tickers above. Good for a general insider-buying feed; use a watchlist instead if you only care about specific stocks.

## `maxItems` (type: `integer`):

Upper bound on how many Form 4 filings to download and parse in this run.

## `lookbackDays` (type: `integer`):

Only include filings whose transaction date is within this many days of today. Applies to watchlist mode; whole-market mode is naturally limited to the latest filings.

## `onlyOpenMarket` (type: `boolean`):

Skip option exercises, grants, gifts and other non-open-market transaction codes, keeping only code P (open-market purchase) and S (open-market sale) — the transactions most investors actually care about.

## `minTransactionValueUsd` (type: `integer`):

Drop transactions worth less than this (shares x price). Set to 0 to keep everything.

## `flagClusterBuys` (type: `boolean`):

Mark a transaction as a cluster buy when 2 or more different insiders at the same company bought on the open market within the cluster window below — a signal some investors watch for.

## `clusterWindowDays` (type: `integer`):

Window used to detect cluster buying at the same company.

## Actor input object example

```json
{
  "tickers": [],
  "trackWholeMarket": false,
  "maxItems": 200,
  "lookbackDays": 14,
  "onlyOpenMarket": true,
  "minTransactionValueUsd": 10000,
  "flagClusterBuys": true,
  "clusterWindowDays": 7
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("cybermax/sec-insider-tracker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("cybermax/sec-insider-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call cybermax/sec-insider-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cybermax/sec-insider-tracker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ODddbyZPaqgvfZZEz/builds/ebcbbgP3gLytQ9gmq/openapi.json