# SEC Insider Trades Tracker (Form 4, EDGAR) (`kuroshio-data/sec-form4-insider-trades-tracker`) Actor

Who is buying and selling shares of US-listed companies? Tracks SEC Form 4 insider filings straight from EDGAR: insider name & role, ticker, buy/sell, shares, price, dollar value, 10b5-1 plan flag — as English structured JSON. No API key needed.

- **URL**: https://apify.com/kuroshio-data/sec-form4-insider-trades-tracker.md
- **Developed by:** [Hayato Yagi](https://apify.com/kuroshio-data) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 results

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/platform/actors/running/actors-in-store#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 Trades Tracker (Form 4, EDGAR)

**Which executives and major shareholders are buying — or dumping — their own company's stock?**

This actor tracks **SEC Form 4 insider-trading filings** straight from **EDGAR**, the U.S. Securities and Exchange Commission's official disclosure system, and returns them as clean **English structured JSON**. Every time a director, officer, or 10%+ owner of a U.S.-listed company trades that company's stock, they must file a Form 4 within two business days. Those filings are public but scattered across thousands of XML documents. This actor turns them into a machine-readable feed of **who traded what, how many shares, at what price, and for how many dollars** — including a **10b5-1 plan flag** that separates pre-scheduled trades from discretionary ones.

No API key, no login, no scraping of web pages — only the SEC's official, key-free data endpoints.

### What you get (one record per filing)

```json
{
  "source": "SEC EDGAR",
  "formType": "4",
  "accessionNumber": "0001225208-26-006816",
  "filedDate": "2026-07-29",
  "periodOfReport": "2026-07-28",
  "issuerName": "ABERCROMBIE & FITCH CO /DE/",
  "issuerTicker": "ANF",
  "insiderName": "Lipesky Scott D.",
  "insiderRoles": ["Officer"],
  "officerTitle": "EVP and COO",
  "hasOpenMarketPurchase": false,
  "hasOpenMarketSale": true,
  "isPlanned10b5_1": true,
  "totals": {
    "acquiredShares": 0,
    "disposedShares": 10000,
    "openMarketBuyValueUsd": 0,
    "openMarketSellValueUsd": 1050000,
    "netTradeValueUsd": -1050000
  },
  "transactions": [
    {
      "table": "non-derivative",
      "securityTitle": "Class A Common Stock",
      "date": "2026-07-28",
      "code": "S",
      "codeDescription": "Open-market or private sale",
      "acquiredDisposed": "D",
      "shares": 10000,
      "pricePerShare": 105,
      "valueUsd": 1050000,
      "sharesOwnedAfter": 172534,
      "ownership": "direct"
    }
  ],
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1018840/000122520826006816/0001225208-26-006816-index.htm"
}
```

- `totals.netTradeValueUsd` — open-market buys minus sells in dollars: positive = net buying, negative = net selling.
- `isPlanned10b5_1` — `true` when the trade ran under a pre-scheduled Rule 10b5-1 plan (routine), `false` for discretionary trades (the interesting ones).
- `insiderRoles` / `officerTitle` — Director, Officer (with exact title), 10% owner.
- `transactions[]` — every reported transaction, non-derivative and derivative, with SEC transaction codes decoded to plain English.

### Who it's for

- **Investors & analysts** who want insider buys/sells as a daily signal without paying for a market-data terminal.
- **Newsletter & research writers** who need a "which CEOs bought their own stock this week" feed.
- **Quant / AI agent builders** who want insider events as a normalized JSON stream (pairs well with any LLM pipeline).

Watching the Japanese market too? See our [Japan Activist & 5% Filings Tracker](https://apify.com/kuroshio-data/japan-activist-5pct-filings-tracker) (who is accumulating shares of Japanese listed companies) and [Japan Corporate Events Monitor](https://apify.com/kuroshio-data/japan-corporate-events-monitor) (what Japanese companies just disclosed — the 8-K equivalent).

### Input

| Field | Default | Notes |
|---|---|---|
| `dateFrom` | 6 days ago | First EDGAR filing date to scan, `YYYY-MM-DD`. |
| `dateTo` | today | Last filing date. Days are scanned **newest first**, so a capped run returns the freshest filings. |
| `formTypes` | `["4"]` | Ownership forms: `4` (transactions), `4/A` (amendments), `3` (initial ownership), `5` (annual). |
| `tickers` | — | Optional issuer symbol filter, e.g. `["AAPL","TSLA"]`. |
| `transactionCodes` | — | Optional filter, e.g. `["P"]` for open-market purchases only, `["P","S"]` for all open-market trades. |
| `maxFilings` | `25` | Cap for a quick, cheap sample (`0` = no limit; a busy day has 500–2,000 Form 4s). |
| `delayMs` | `150` | Politeness delay between SEC requests (SEC allows up to 10 req/s; don't go below 120). |
| `secUserAgent` | actor default | SEC asks automated clients to identify themselves; you can put `"Your Name your@email.com"` here. |

All fields are optional — **a run with no input returns the latest ~25 insider filings**.

### Typical uses

- Daily digest: run once a day with `transactionCodes: ["P"]` to catch every open-market insider **buy** (the classic bullish signal).
- Watchlist: set `tickers` to your portfolio and get every insider move in those names.
- Research: pull a full month with `maxFilings: 0` and aggregate net insider flows by sector.

### Notes & limitations

- Data source: SEC EDGAR daily form indexes and ownership XML documents — official, public-domain U.S. government data. The actor respects the SEC fair-access policy (identifying User-Agent, well under 10 requests/second).
- Filings appear in the daily index within minutes of acceptance; EDGAR accepts filings 6:00–22:00 US Eastern on business days. Weekends and market holidays have no index (the actor skips them automatically).
- `totals` counts share amounts from non-derivative (common stock) transactions; dollar totals cover open-market trades (codes P and S) where a price is reported. Grants, option exercises, gifts, etc. are all present in `transactions[]` with their SEC codes decoded.
- Form 3 filings report initial ownership and contain no transactions; they come through with an empty `transactions` array.

### Run locally

```bash
npm install
node src/main.js
```

Local input can be placed in `storage/key_value_stores/default/INPUT.json`.

# Actor input Schema

## `dateFrom` (type: `string`):

First EDGAR filing date to scan (US Eastern). Defaults to 6 days ago so a default run always finds recent business days.

## `dateTo` (type: `string`):

Last EDGAR filing date to scan. Defaults to today (UTC). Days are scanned newest-first, so the freshest filings come out first.

## `formTypes` (type: `array`):

EDGAR ownership forms to include. 4 = insider transaction report (the main one), 4/A = amendment, 3 = initial ownership, 5 = annual report.

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

If set, only filings whose issuer trading symbol matches one of these (e.g. AAPL, TSLA). Leave empty for all companies.

## `transactionCodes` (type: `array`):

If set, only filings containing at least one transaction with these codes. P = open-market purchase, S = open-market sale, A = award, M = option exercise, G = gift... Leave empty for all.

## `maxFilings` (type: `integer`):

Cap the number of filings pushed to the dataset. Default 25 keeps a quick, cheap sample of the latest insider activity.

## `delayMs` (type: `integer`):

Politeness delay to stay well under the SEC fair-access limit (10 requests/second). Do not set below 120.

## `secUserAgent` (type: `string`):

SEC asks automated clients to identify themselves in the User-Agent header (e.g. "Your Name your@email.com"). Leave empty to use the actor's default identification.

## Actor input object example

```json
{
  "formTypes": [
    "4"
  ],
  "maxFilings": 25,
  "delayMs": 150
}
```

# 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("kuroshio-data/sec-form4-insider-trades-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("kuroshio-data/sec-form4-insider-trades-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 kuroshio-data/sec-form4-insider-trades-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=kuroshio-data/sec-form4-insider-trades-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/dGqvuqwi7Zw22uHzq/builds/FjevEmeZBq42g854D/openapi.json