# SEC Form 4 Insider Tracker MCP (`red.cars/sec-form-4-insider-tracker`) Actor

Track SEC Form 4 and 8-K insider filings for watched tickers. Input tickers and event types, get structured insider trading signals with transaction details.

- **URL**: https://apify.com/red.cars/sec-form-4-insider-tracker.md
- **Developed by:** [AutomateLab](https://apify.com/red.cars) (community)
- **Categories:** MCP servers, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Form 4 Insider Tracker MCP

Monitor SEC EDGAR (sec.gov) for Form 4 insider trades and 8-K material events across your stock watchlist, returning structured transaction data with insider names, titles, share counts, and USD values.

### Overview

Track insider buying and selling activity across publicly traded companies using official SEC EDGAR filings. Form 4 disclosures are filed when company insiders—executives, directors, and large shareholders—make transactions in company stock. The SEC enforces same-day filing deadlines, making this data one of the fastest available signals for insider sentiment. 8-K reports capture material events like earnings surprises, executive changes, and strategic pivots that move markets.

### Features

- **Real-time SEC monitoring**: Tracks Form 4 (insider purchases/sales) and 8-K (material company events) filings with ~15-minute SEC EDGAR latency
- **Multi-ticker batch tracking**: Watch up to 50 stock tickers simultaneously in a single API call
- **Structured JSON output**: Parsed insider data—no more wrestling with raw SEC XML formats
- **Transaction type decoding**: Automatically interprets P=Purchase, S=Sale, D=Disposition, M=Merger transaction codes
- **Insider title extraction**: Captures officer/director titles (CEO, CFO, Director, etc.) from Form 4 filings
- **USD value calculation**: Computes total transaction value from share count × price when available
- **MCP server integration**: Native Model Context Protocol tool for AI agent workflows
- **Apify actor compatibility**: Full JSON input schema for batch processing and scheduling

### Use Cases

- **Quantitative trading signals**: Screen for insider buying clusters that historically precede price appreciation; filter by transaction size relative to insider holdings
- **Due diligence monitoring**: Alert when executives or directors in your portfolio companies file unusual transactions—large purchases signal confidence, sudden sales warrant investigation
- **Earnings season preparation**: Track 8-K filings for revenue warnings or guidance changes in the weeks before quarterly reports to position ahead of volatility
- **Risk management**: Identify insider selling at historical highs that may signal overvaluation or upcoming lock-up expirations
- **M\&A alpha detection**: Monitor 8-K disclosures for joint ventures, licensing agreements, and strategic partnerships that hint at future transactions
- **Short squeeze screening**: Flag rapid accumulation by insiders combined with high short interest as potential catalysts

### Quick Start

#### Prerequisites

- Apify account (free tier available)
- Node.js 18+ for local testing

#### 1-minute setup

```bash
## Install Apify CLI
npm install -g apify-cli

## Clone the actor
apify actors:create sec-form-4-insider-tracker

## Set environment variable
export APIFY_TOKEN=your_apify_token

## Run locally
node main.js --tickers AAPL,MSFT,GOOGL --maxResults 5
```

#### MCP Quick Start

```json
{
  "toolName": "track_insider_filings",
  "arguments": {
    "tickers": ["AAPL", "MSFT", "GOOGL"],
    "event_types": ["4", "8-K"],
    "maxResults": 10
  }
}
```

### Input Parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| tickers | array of string | \["AAPL", "MSFT"] | Stock tickers to monitor (max 50) |
| event\_types | array of string | \["4", "8-K"] | SEC form types: 4=Form4 insider trades, 8-K=material events |
| maxResults | integer | 10 | Max filings to return per ticker (max 50) |

### Output

```json
{
  "tickers_watched": ["AAPL", "MSFT"],
  "event_types_tracked": ["4", "8-K"],
  "total_filings": 2,
  "filings": [
    {
      "ticker": "AAPL",
      "form_type": "4",
      "filed_at": "2026-05-14",
      "insider_name": "Tim Cook",
      "title": "Chief Executive Officer",
      "transaction_type": "P - Purchase",
      "value_usd": 150000,
      "shares": 1000
    },
    {
      "ticker": "AAPL",
      "form_type": "8-K",
      "filed_at": "2026-05-13",
      "insider_name": "N/A - Company Filing",
      "title": "N/A",
      "transaction_type": "8-K Item 2.02",
      "value_usd": 0,
      "shares": 0
    }
  ],
  "metadata": {
    "sec_source": "https://www.sec.gov/cgi-bin/browse-edgar",
    "fetched_at": "2026-05-15T12:00:00Z"
  }
}
```

### Pricing

**PPE**: $0.08 per watched ticker per filing event.

Cost estimation: Watching 3 tickers with 5 filing events = 3 × 5 × $0.08 = $1.20

| Scenario | Tickers | Events | Cost |
|----------|---------|--------|------|
| Small watchlist | 5 | 10 | $0.40 |
| Medium portfolio | 15 | 20 | $2.40 |
| Large hedge fund | 50 | 50 | $20.00 |

### Troubleshooting

**"No filings found for ticker"**: SEC EDGAR has ~15-minute delay on new filings. If a filing just occurred, wait 15 minutes and retry. Also verify the ticker symbol is correct (e.g., "BRK.B" not "BRK B").

**"Rate limit exceeded"**: SEC imposes limits on EDGAR queries. The actor includes built-in retry logic with exponential backoff. For high-volume use cases, spread requests across multiple calls with 5-second intervals.

**"Form type not supported"**: Currently supports Form 4 (insider trades) and 8-K (material events). For support of additional form types (Form 13D, Form S-1, etc.), contact the development team with your requirements.

**"Invalid ticker symbol"**: Only valid SEC-registered tickers work. Test with well-known symbols like AAPL, MSFT, GOOGL before using niche symbols.

**"maxResults capped at 50"**: The SEC caps response size for performance. Use pagination by incrementing a date filter to retrieve historical filings in batches.

**Data latency concerns**: For real-time trading signals requiring zero latency, consider premium data feeds from Bloomberg or Refinitiv. SEC filings inherently have ~15-minute delay by regulation.

# Actor input Schema

## `tool` (type: `string`):

MCP tool to call

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

Stock tickers to watch (e.g. AAPL, MSFT, GOOGL)

## `event_types` (type: `array`):

SEC form types to track (4=Form4, 8-K=8-K)

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

Max filings to return per ticker

## Actor input object example

```json
{
  "tool": "track_insider_filings",
  "tickers": [
    "AAPL",
    "MSFT"
  ],
  "event_types": [
    "4",
    "8-K"
  ],
  "maxResults": 10
}
```

# 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 = {
    "tool": "track_insider_filings",
    "tickers": [
        "AAPL",
        "MSFT"
    ],
    "event_types": [
        "4",
        "8-K"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("red.cars/sec-form-4-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 = {
    "tool": "track_insider_filings",
    "tickers": [
        "AAPL",
        "MSFT",
    ],
    "event_types": [
        "4",
        "8-K",
    ],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("red.cars/sec-form-4-insider-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 '{
  "tool": "track_insider_filings",
  "tickers": [
    "AAPL",
    "MSFT"
  ],
  "event_types": [
    "4",
    "8-K"
  ],
  "maxResults": 10
}' |
apify call red.cars/sec-form-4-insider-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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