# SEC Form 4 Insider Trading Scraper — Cluster Buys & Signals (`sutraflow/sec-insider-trading-signals`) Actor

Scrape SEC Form 4 insider trades: open-market buys only, 10b5-1 flags, cluster-buy detection and conviction scoring.

- **URL**: https://apify.com/sutraflow/sec-insider-trading-signals.md
- **Developed by:** [Samik Sarkar](https://apify.com/sutraflow) (community)
- **Categories:** Developer tools, Automation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 insider transaction returneds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

**SEC Insider Trading Signals** turns raw [SEC Form 4](https://www.sec.gov/about/forms/form4.pdf) filings into a clean, ranked feed of **insider buying and selling** — with the compensation noise stripped out. It reads every Form 4 disseminated by EDGAR, keeps only the transactions that reflect an actual decision, flags **pre-scheduled 10b5-1 trades**, and detects **cluster buys** where several insiders at the same company purchase within days of each other.

Most Form 4 scrapers hand you every row in the filing. Roughly **80% of that volume is option exercises, share grants and tax withholding** — mechanical compensation events that tell you nothing. This Actor classifies every transaction so you can filter to the ~20% that carries information.

### What SEC Insider Trading Signals does

- Scans **all Form 4 and Form 4/A filings** across the entire US market, or just the tickers you care about
- Classifies each transaction: open-market buy, open-market sale, grant, option exercise, tax withholding, gift, disposition
- Flags **Rule 10b5-1 pre-scheduled trades** so you can separate discretionary conviction from a plan set up months earlier
- Detects **cluster buys** — two or more distinct insiders buying the same issuer inside a rolling window, counting **named individuals only** so a fund complex co-filing under a dozen affiliated vehicles cannot manufacture a signal
- Collapses **joint filings to one row per transaction**, so a trade co-filed by 13 entities is one event with a co-filer count, not 13 duplicate rows
- Scores each purchase 0–100 on a transparent **conviction heuristic**: seniority, dollar size, how much the buyer grew their own stake, whether it was discretionary, and whether colleagues bought alongside
- Resolves ticker symbols, insider roles (CEO, CFO, director, 10% owner) and links straight back to the source filing on EDGAR

### Why use SEC Insider Trading Signals

- **Quant and systematic research** — a clean daily feed of open-market insider purchases, already de-noised, ready for a backtest
- **Financial media and newsletters** — surface the notable buys of the day without reading a thousand filings
- **Investor relations and compliance** — monitor Section 16 activity at your own company or your peer group
- **Fintech products** — power an insider-activity screen, alert or dashboard without building an EDGAR pipeline
- **Watchlist alerts** — schedule a daily run over your portfolio and get notified when an executive buys

### How to use SEC Insider Trading Signals

1. Click **Start** — the defaults sweep the last two days of the whole US market for open-market buys over $25,000.
2. Wait for the run to finish. Progress appears in the log as filings are scanned.
3. Open the **Storage / Dataset** tab and switch between the **Insider signals** and **Cluster buys only** views.
4. Export to JSON, CSV, Excel or XML, or pull it from the [Apify API](https://docs.apify.com/api/v2).
5. To watch specific companies, set **Scan mode** to *Specific companies* and list your tickers.
6. Use **Schedules** to run it every morning, and **Integrations** to push results to Slack, a webhook, Google Sheets or your database.

### Input

Every field has a working default, so you can run it without configuring anything.

```json
{
  "mode": "market_sweep",
  "lookbackDays": 2,
  "signalTypes": ["open_market_buy"],
  "minTransactionValueUsd": 25000,
  "excludePlannedTrades": false,
  "detectClusterBuys": true,
  "clusterWindowDays": 7,
  "clusterMinInsiders": 2,
  "maxResults": 1000
}
```

To follow a watchlist instead:

```json
{
  "mode": "companies",
  "tickers": ["AAPL", "NVDA", "JPM"],
  "lookbackDays": 30,
  "signalTypes": ["open_market_buy", "open_market_sale"],
  "minTransactionValueUsd": 0
}
```

### Output

```json
{
  "convictionScore": 84,
  "ticker": "ACME",
  "issuerName": "ACME ROBOTICS INC",
  "issuerCik": "0000320193",
  "insiderName": "DOE JANE A",
  "insiderRole": "CEO",
  "officerTitle": "Chief Executive Officer",
  "isDirector": true,
  "isOfficer": true,
  "isTenPercentOwner": false,
  "signalType": "open_market_buy",
  "transactionCode": "P",
  "transactionCodeLabel": "Open market or private purchase",
  "transactionDate": "2026-08-14",
  "shares": 10000,
  "pricePerShare": 42.5,
  "transactionValueUsd": 425000.0,
  "sharesOwnedAfter": 60000,
  "holdingsIncreasePct": 20.0,
  "isPlanned10b5_1": false,
  "insiderIsEntity": false,
  "coFilerCount": 0,
  "clusterIndividualCount": 3,
  "clusterTotalValueUsd": 1250000.0,
  "accessionNumber": "0000320193-26-000075",
  "filedAt": "2026-08-15",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/..."
}
```

You can download the dataset in various formats such as JSON, HTML, CSV or Excel.

### Data fields

| Field | Description |
|---|---|
| `convictionScore` | 0–100 heuristic for open-market buys. Higher = more informative on its face. |
| `signalType` | `open_market_buy`, `open_market_sale`, `award_grant`, `option_exercise`, `tax_withholding`, `gift`, `disposition_to_issuer`, `other` |
| `transactionCode` / `transactionCodeLabel` | The raw SEC Table I/II code and its plain-English meaning |
| `ticker`, `issuerName`, `issuerCik` | The company whose stock was traded |
| `insiderName`, `insiderCik` | The Section 16 reporting person |
| `insiderRole`, `officerTitle` | CEO, CFO, President/Chairman, Senior officer, Director, 10% owner |
| `isDirector`, `isOfficer`, `isTenPercentOwner` | Raw relationship flags as filed |
| `shares`, `pricePerShare`, `transactionValueUsd` | Size of the transaction |
| `sharesOwnedAfter`, `holdingsIncreasePct` | Position after the trade, and how much the buy grew it |
| `isPlanned10b5_1` | True when the filing indicates a Rule 10b5-1 trading plan |
| `isDerivative` | True for Table II (options, RSUs, warrants) |
| `securityType` | `common`, `preferred`, `derivative` or `other`, from the security title |
| `dataQualityFlags` | Markers for figures that cannot be right as filed — see the FAQ |
| `clusterId`, `clusterTotalValueUsd` | Cluster-buy membership, when detected |
| `clusterIndividualCount` | Named individuals in the cluster — the number that qualifies it |
| `clusterInsiderCount` | Everyone in the cluster, individuals and entities |
| `insiderIsEntity` | True when the filer is a fund or holding vehicle rather than a person |
| `coFilerCount`, `coFilerNames` | Other entities that co-filed the same transaction |
| `accessionNumber`, `filedAt`, `periodOfReport` | Filing identifiers and dates |
| `filingUrl`, `filingIndexUrl` | Direct links to the source document on SEC EDGAR |

### How much does it cost to track SEC insider trading?

This Actor uses **pay per event**, so you pay for results rather than for compute time:

| Event | Price |
|---|---|
| Actor start | $0.01 |
| Each insider transaction returned | $0.01 |

A default run (two days of the whole market, open-market buys over $25k) typically returns a few hundred transactions, so **most daily runs land between $1 and $4**. Watching a handful of tickers costs cents. Results are sorted by conviction score before the `maxResults` cut, so a smaller budget still keeps the most significant activity.

### Tips

- **Set `excludeEntityFilers` to true** to drop fund and holding-vehicle filers entirely and keep only named individuals.
- **Set `excludePlannedTrades` to true** to remove Rule 10b5-1 activity. This is the single most effective noise filter after the transaction-code classification.
- **Cluster buys are the highest-signal output.** Set `clusterMinInsiders` to 3 for a much shorter, much stronger list.
- **Widen `lookbackDays` on Mondays** — weekends and market holidays produce no filings.
- Lower `minTransactionValueUsd` to 0 when watching small-cap companies, where meaningful insider buys are smaller in dollar terms.
- Raise `maxFilingsToScan` when scanning more than a few days of the full market.
- Schedule a daily run just after **market close**; Form 4s are due within two business days of the transaction, so most arrive in the evening.

### FAQ

**Where does the data come from?**
Directly from SEC EDGAR — the daily index and the ownership XML inside each filing. Nothing is bought, cached or resold, and the Actor respects the SEC's fair-access rate limits and identifies itself with a contact address as the SEC requests.

**Is this legal?**
Yes. SEC filings are US federal government records published for public use and are not subject to copyright. Insider transactions are *required* to be disclosed publicly under Section 16(a) of the Securities Exchange Act, usually within two business days.

**Is the conviction score investment advice?**
**No.** It is a transparent screening heuristic computed only from fields the insider themselves disclosed — seniority, size, stake change, plan status, cluster membership. It is not a prediction, a recommendation, or a signal to trade, and it has not been validated against forward returns. Do your own research and speak to a licensed professional before making investment decisions.

**Why do I see fewer results than filings scanned?**
By design. Most Form 4 rows are grants, option exercises and tax withholding. The defaults return only open-market purchases above $25,000. Joint filings also collapse to a single row per transaction rather than one per co-filer.

**A fund filed under a dozen entity names — do I get charged for each?**
No. One transaction is one billable row regardless of how many affiliated vehicles co-filed it. The extras appear in `coFilerCount` and `coFilerNames`.

**I see an insider "buy" with an absurd dollar value.**
Form 4 is self-reported and filers do mis-key it. One real example: 1,000 shares of a penny-stock preferred reported at $100,000 per share, producing a $100,000,000 "purchase". Rows like this are **kept**, because that is genuinely what the filing says and `filingIndexUrl` takes you straight to it — but they carry a `dataQualityFlags` entry and are pushed down the conviction ranking so they never lead your results. Preferred and derivative securities are demoted for the same reason: they are usually negotiated placements, not open-market conviction.

**Some transactions have no price.**
A minority of filings report the price only in a footnote, or report a range. Those rows come through with `pricePerShare` and `transactionValueUsd` set to `null` rather than a guess.

**Can I get historical data?**
Yes — set `startDate` and `endDate` to any past range and raise `maxFilingsToScan`. EDGAR daily indexes go back many years.

### Support

Found a bug, a filing that parses badly, or need a field that isn't here? Open an issue on the **Issues** tab and it will get looked at. Custom variants of this Actor for a specific workflow can be arranged.

# Actor input Schema

## `mode` (type: `string`):

Market sweep reads every Form 4 filed in the date window (best for finding new signals). Specific companies watches only the tickers or CIKs you list.

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

How many calendar days back from today to scan. Ignored if you set explicit start/end dates. Weekends and US market holidays have no filings.

## `startDate` (type: `string`):

YYYY-MM-DD. Overrides lookback days.

## `endDate` (type: `string`):

YYYY-MM-DD. Defaults to today (UTC).

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

Stock symbols to watch, e.g. AAPL, NVDA. Only used when mode is 'Specific companies'.

## `ciks` (type: `array`):

SEC Central Index Keys, if you prefer them to tickers. Only used when mode is 'Specific companies'.

## `signalTypes` (type: `array`):

Open-market buys are the classic insider signal — an insider spending their own money. Grants, tax withholding and option exercises are compensation mechanics and make up most raw Form 4 volume, which is why they are off by default.

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

Drop buys and sales below this dollar value. Filters out token purchases. Set to 0 to keep everything.

## `excludePlannedTrades` (type: `boolean`):

Rule 10b5-1 trades are set up months in advance, so they carry far less information than a discretionary trade. Turn this on to keep only discretionary activity.

## `includeDerivatives` (type: `boolean`):

Table II holdings — options, RSUs, warrants. Off by default because most are compensation events.

## `detectClusterBuys` (type: `boolean`):

Flag cases where several different insiders at the same company bought within a short window — much harder to explain away as one person's liquidity needs.

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

How close together insider purchases must be to count as one cluster.

## `clusterMinInsiders` (type: `integer`):

How many distinct insiders must buy inside the window.

## `maxFilingsToScan` (type: `integer`):

Safety cap on how many Form 4 documents are downloaded in one run. Raise it for wide date ranges.

## `maxResults` (type: `integer`):

Cap on returned transactions. Results are sorted by conviction score, so the most significant ones survive the cut.

## `excludeEntityFilers` (type: `boolean`):

Drop Section 16 filers that are corporate vehicles (L.P., LLC, funds, holding companies) rather than named individuals. A fund complex can co-file one subscription under a dozen entities, which is plumbing rather than conviction.

## `countEntitiesInClusters` (type: `boolean`):

By default only named individuals count toward the cluster threshold, so affiliated fund vehicles cannot manufacture a cluster. Turn this on to count every filer.

## `userAgent` (type: `string`):

The SEC asks automated clients to identify themselves with a contact address. Override only if you want your own organisation named in the request.

## Actor input object example

```json
{
  "mode": "market_sweep",
  "lookbackDays": 2,
  "tickers": [],
  "ciks": [],
  "signalTypes": [
    "open_market_buy"
  ],
  "minTransactionValueUsd": 25000,
  "excludePlannedTrades": false,
  "includeDerivatives": false,
  "detectClusterBuys": true,
  "clusterWindowDays": 7,
  "clusterMinInsiders": 2,
  "maxFilingsToScan": 2500,
  "maxResults": 1000,
  "excludeEntityFilers": false,
  "countEntitiesInClusters": false
}
```

# Actor output Schema

## `signals` (type: `string`):

No description

## `clusterBuys` (type: `string`):

No description

## `csv` (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("sutraflow/sec-insider-trading-signals").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("sutraflow/sec-insider-trading-signals").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 sutraflow/sec-insider-trading-signals --silent --output-dataset

```

## MCP server setup

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

```

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/fMNx8AJjpocT7tYlh/builds/27edDIBrn6gf3w16O/openapi.json