# SEC Insider Trading Tracker: Form 4 + 8-K Alerts (`contented_catwalk/sec-insider-trades-8k-alerts`) Actor

Track SEC Form 4 insider buying and selling as clean rows (insider, role, transaction code, shares, price, value, holdings after), filtered by ticker, CIK, date, type and size, plus 8-K item alerts. Only-new mode. Official SEC data; $1 per 1,000 filings.

- **URL**: https://apify.com/contented_catwalk/sec-insider-trades-8k-alerts.md
- **Developed by:** [Orvix](https://apify.com/contented_catwalk) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 filings

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

## SEC Insider Trading Tracker: Form 4 + 8-K Alerts

Track **insider buying and selling** from SEC Form 4 filings as clean rows: who traded, their role (CEO, CFO, director, 10% owner), the transaction type, shares, price per share, **dollar value** and the shares they hold afterwards. Filter by ticker, company or insider CIK, date range, transaction code (open-market buy `P`, sale `S`, award, option exercise...) and minimum value. Add **8-K current-report alerts** filtered by item: earnings (2.02), executive changes (5.02), cybersecurity incidents (1.05), restatements (4.02), material agreements (1.01), completed acquisitions (2.01) and more. Turn on **only-new mode** and schedule it to get each filing exactly once.

Data comes straight from SEC EDGAR (official, public, free to access). We identify ourselves to the SEC and stay under its 10 requests per second fair-access rule.

### What you can use it for

- **Insider buying alerts:** `transactionCodes: ["P"]`, `minValue: 100000`, market-wide or a watchlist, daily schedule.
- **Watchlist monitoring:** your tickers, Form 4 + 8-K, only-new mode, sent to Slack, email or Google Sheets.
- **Track a specific person or fund:** put their CIK in `insiderCiks`.
- **Research and backtests:** export insider transactions for a date range to CSV, JSON or Excel.
- **Event-driven feeds:** 8-K items such as 5.02 (officer departures) or 1.05 (cyber incidents) for news, risk or compliance workflows.
- **AI agents:** give an agent structured insider and 8-K data instead of raw filings.

### Input example

```json
{
  "tickers": ["AAPL", "NVDA", "TSLA"],
  "transactionCodes": ["P", "S"],
  "minValue": 50000,
  "include8K": true,
  "items8K": ["2.02", "5.02"],
  "onlyNew": true,
  "stateKey": "watchlist",
  "maxFilings": 500
}
```

Leave `tickers`, `ciks` and `insiderCiks` empty for a market-wide scan of every Form 4 in the date range.

### Output example (Form 4 row)

A real row from a test run, trimmed:

```json
{
  "recordType": "insider-transaction",
  "form": "4",
  "fileDate": "2026-10-15",
  "ticker": "AAPL",
  "issuerName": "Apple Inc.",
  "issuerCik": "320193",
  "insiderName": "Newstead Jennifer",
  "insiderCik": "1780525",
  "insiderRole": "SVP, GC and Government Affairs",
  "isDirector": false,
  "isOfficer": true,
  "isTenPercentOwner": false,
  "transactionDate": "2026-10-13",
  "transactionCode": "S",
  "transactionDescription": "Open-market sale",
  "acquiredDisposed": "D",
  "shares": 2399,
  "pricePerShare": 345,
  "value": 827655,
  "sharesOwnedAfter": 37194,
  "directOrIndirect": "D",
  "rule10b51Plan": true,
  "footnotes": ["This transaction was made pursuant to a Rule 10b5-1 trading plan ..."],
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1780525/000114036126039785/form4.xml"
}
```

Also included: accession number, period of report, security title, derivative fields (exercise price, expiration, underlying shares), indirect ownership nature, all owners for joint filings, amendment form (4/A) and the filing index URL.

**8-K rows** (`recordType: "8-K"`): company, ticker, CIK, filing date, `items8K` with plain-English `items8KDescriptions`, `matchedItems`, period of report, `filingUrl` and `filingIndexUrl`.

### Input fields

- `tickers` and/or `ciks` (companies), `insiderCiks` (people or funds). Leave all empty for market-wide.
- `startDate`, `endDate` (filing dates; default the last 30 days, 7 in only-new mode).
- `includeForm4` (default on), `transactionCodes` (P buy, S sell, A award, M exercise, F tax withholding, G gift, ...), `acquiredDisposed`, `minValue`, `includeHoldings`.
- `include8K`, `items8K`; `includeAmendments`.
- `onlyNew` + `stateKey`; `maxFilings` (cost cap).

### Pricing

- **$1 per 1,000 filings** ($0.001 per filing). One Form 4 often has several transaction rows; you pay once per filing.
- You pay only for filings that match your filters. Filings we read but you filtered out are free. Empty and failed runs are free. The run stops at your maximum cost per run.

### Use with Make, n8n, Zapier and AI agents

Run it via the Apify API, schedule it in Apify Console, or connect it with the Apify integrations for Make, n8n, Zapier and Google Sheets. AI agents can call it through Apify's MCP server.

### FAQ

**What is a Form 4?** The SEC form company insiders (officers, directors, 10% owners) must file within two business days of trading the company's stock.

**What do the transaction codes mean?** `P` open-market purchase, `S` open-market sale, `A` grant or award, `M` option exercise, `F` shares withheld for tax, `G` gift. `transactionDescription` spells each one out.

**Is this real-time?** It reads EDGAR when it runs. Schedule it (for example every hour on weekdays) with `onlyNew: true` for alert-style use.

**Do I need an SEC API key?** No. EDGAR is public; no key or login is needed.

### Notes

- Values are shares x price as reported. Some lines have no price (awards, gifts); `value` is then empty.
- Market-wide scans read every Form 4 of the day (often 500-2,000), so they take about a minute per day of range.
- This is data, not investment advice.

# Actor input Schema

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

Company tickers, e.g. AAPL, TSLA. Leave empty (and CIKs empty) for every company (market-wide).

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

Optional issuer CIK numbers instead of, or in addition to, tickers.

## `insiderCiks` (type: `array`):

Optional: only trades by these people or funds (reporting owner CIKs). Combined with tickers/CIKs, only their trades in those companies.

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

Filing date range start. Default: 30 days before the end date (7 days in only-new mode).

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

Default: today.

## `includeForm4` (type: `boolean`):

Parse Form 4 filings into one row per transaction.

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

Only these codes. P = open-market buy, S = open-market sale, A = award, M = option exercise, F = tax withholding, G = gift. Empty = all.

## `acquiredDisposed` (type: `string`):

Only acquisitions (A) or only disposals (D) of shares. Default: both.

## `minValue` (type: `integer`):

Only transactions worth at least this much (shares x price). Rows without a price are excluded when set.

## `includeHoldings` (type: `boolean`):

Also return holdings lines that report no transaction (only when no code/value filter is set).

## `include8K` (type: `boolean`):

Also return 8-K filings (current reports) for the same companies and dates.

## `items8K` (type: `array`):

Only 8-Ks with these items, e.g. 2.02 (results), 5.02 (officer/director change), 1.01 (material agreement), 1.05 (cyber incident), 4.02 (restatement). Empty = all.

## `includeAmendments` (type: `boolean`):

Also include amended filings.

## `onlyNew` (type: `boolean`):

Remember delivered filings and return only new ones. For schedules (e.g. every hour).

## `stateKey` (type: `string`):

Separate memory per monitor in only-new mode.

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

Stop after this many filings (cost control). One Form 4 can contain several transaction rows; you pay per filing.

## Actor input object example

```json
{
  "tickers": [
    "AAPL",
    "TSLA",
    "NVDA"
  ],
  "includeForm4": true,
  "transactionCodes": [
    "P",
    "S"
  ],
  "acquiredDisposed": "",
  "includeHoldings": false,
  "include8K": false,
  "includeAmendments": true,
  "onlyNew": false,
  "stateKey": "default",
  "maxFilings": 500
}
```

# Actor output Schema

## `records` (type: `string`):

One row per Form 4 transaction and one row per 8-K.

## `summary` (type: `string`):

Counts, errors and charges.

# 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 = {
    "tickers": [
        "AAPL",
        "TSLA",
        "NVDA"
    ],
    "transactionCodes": [
        "P",
        "S"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("contented_catwalk/sec-insider-trades-8k-alerts").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 = {
    "tickers": [
        "AAPL",
        "TSLA",
        "NVDA",
    ],
    "transactionCodes": [
        "P",
        "S",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("contented_catwalk/sec-insider-trades-8k-alerts").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 '{
  "tickers": [
    "AAPL",
    "TSLA",
    "NVDA"
  ],
  "transactionCodes": [
    "P",
    "S"
  ]
}' |
apify call contented_catwalk/sec-insider-trades-8k-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,contented_catwalk/sec-insider-trades-8k-alerts"
        }
    }
}
```

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/dfHJtEwyCIodQZ5oO/builds/cgzYSYOJ2q3h3cRvg/openapi.json