# SEC EDGAR Monitor 🔔 (Form 4 insider trades, 8-K, 13D alerts) (`tagadanar/sec-edgar-monitor`) Actor

One watchlist for the three filings that move a thesis: Form 4 insider trades (fully parsed), 8-K material events and 13D/13G activist stakes, with a Slack digest of only-new filings. Official SEC data, no API key, misses cost nothing. $5 per 1,000 filings.

- **URL**: https://apify.com/tagadanar/sec-edgar-monitor.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** News, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 filing founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 EDGAR Filings Monitor: Insider Trading (Form 4), 8-K & 13D/13G Alerts

**Turn any ticker or CIK into structured insider trading and material event alerts, straight from SEC EDGAR's own JSON API.** Give it a list of tickers, get back every Form 4 (who bought or sold, how many shares, at what price), 8-K (material events) and 13D/13G (ownership stake) filing as clean rows, with a monitor mode that only reports and charges for filings that are actually new.

Built for **retail investors tracking insider buys, quant and research feeds, financial journalists, and AI agents** (works out of the box via API and MCP).

### Why this actor

- One watchlist, three filing types, one digest: Form 4, 8-K and 13D/13G behind a single schedule and a single Slack alert. On Apify today that otherwise means wiring two or three separate single-form actors together.
- Official SEC data only: every field comes straight from `sec.gov` and `data.sec.gov`, the same source that services charging a monthly fee for insider alerts pull from. No scraping, no stale mirrors.
- Form 4 detail parsed for you: insider name, whether they're a director, officer or 10% owner, their title, and each transaction (security, shares, price, bought or sold, shares owned after). Most alternatives only hand you the filing link.
- Covers the three filing types that actually move a thesis: Form 4 (insider trading), 8-K (material events) and 13D/13G (activist and passive ownership stakes), including both the `SC 13G` and older `SCHEDULE 13G` spellings SEC itself uses.
- Monitor mode with a Slack-compatible webhook digest: schedule it daily and get pinged only when a new filing shows up, never a repeat.
- Fair pricing: you pay per filing actually returned, platform usage included. A run that finds nothing only pays the tiny start fee.

### Use cases

- **Retail investors**: get an alert the moment a company's CEO, CFO or a board member buys or sells stock.
- **Quant and research feeds**: pull structured Form 4 transaction data by ticker for a signal or backtest, no PDF or HTML parsing required.
- **Financial journalists**: track 8-K material events and 13D activist stakes across a watchlist of tickers.
- **Compliance and IR teams**: keep a clean, queryable log of a company's own insider filings.
- **AI agents**: plug it into Claude, Cursor or any MCP client and ask, *"has any Apple insider sold stock in the last month?"*

### Input

```json
{
    "tickers": ["AAPL"],
    "formTypes": ["4"],
    "sinceDays": 90,
    "maxFilingsPerCompany": 20
}
```

`tickers` accepts stock tickers (`AAPL`, `TSLA`, `NVDA`); use `ciks` instead (or alongside) for companies without a public ticker. `formTypes` accepts `4`, `8-K`, `13D` and `13G` (both `SC` and `SCHEDULE` spellings, plus amendments, are matched automatically).

Monitor mode example (for a scheduled run):

```json
{
    "tickers": ["AAPL", "TSLA", "NVDA"],
    "formTypes": ["4"],
    "sinceDays": 30,
    "monitorMode": true,
    "webhookUrl": "https://hooks.slack.com/services/xxx/yyy/zzz"
}
```

### Output (one record per filing)

```json
{
    "ticker": "AAPL",
    "cik": "320193",
    "companyName": "Apple Inc.",
    "form": "4",
    "filingDate": "2026-06-17",
    "reportDate": "2026-06-15",
    "accessionNumber": "0001140361-26-025622",
    "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126025622/form4.xml",
    "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126025622/0001140361-26-025622-index.htm",
    "isNew": null,
    "retrievedAt": "2026-06-17T12:00:00.000Z",
    "insider": {
        "name": "Newstead Jennifer",
        "isDirector": false,
        "isOfficer": true,
        "officerTitle": "SVP, GC and Secretary",
        "isTenPercentOwner": false
    },
    "transactions": [
        { "securityTitle": "Common Stock", "transactionDate": "2026-06-15", "transactionCode": "F", "shares": 16238, "pricePerShare": 296.42, "sharesOwnedAfter": 41546, "acquiredDisposed": "D", "derivative": false }
    ]
}
```

| Field | Meaning |
|---|---|
| `ticker` / `cik` / `companyName` | The filer, resolved from your input |
| `form` | Filing type as SEC reports it (`4`, `8-K`, `SC 13G`...) |
| `filingDate` / `reportDate` | When it was filed vs. the event date it reports |
| `accessionNumber` | SEC's unique filing ID |
| `primaryDocumentUrl` / `filingIndexUrl` | Direct links to the source document and filing index |
| `isNew` | `true`/`false` in monitor mode, `null` otherwise |
| `insider` | Name, director/officer/10%-owner flags and title (Form 4 only, else `null`) |
| `transactions` | Security, code, shares, price, bought (`A`)/sold (`D`), shares owned after (Form 4 only, else `null`) |

8-K and 13D/13G rows come back with `insider` and `transactions` set to `null`: the filing itself is the signal.

### Pricing

Pay per event, with no subscription:

| Event | Price | When |
|---|---|---|
| Actor start | **$0.001** | Flat, once per run |
| Filing found | **$0.005** | Per filing returned with its data |
| Digest sent | **$0.03** | Monitor mode only, per Slack/webhook digest actually posted |

A thousand filings across a watchlist costs $5 all-in, platform usage included, and in monitor mode a quiet day costs almost nothing: dedup means you are never billed twice for the same filing, so a scheduled watchlist that finds nothing new only pays the tiny run fee. Dedicated insider-alert subscriptions start around $25 to $50 per month whether anything happened or not.

### FAQ

**Where does the data come from?** SEC EDGAR's own public JSON endpoints (`sec.gov/files/company_tickers.json`, `data.sec.gov/submissions`, and the filing archive). No scraping, no third-party aggregator.

**How do I get alerted when a CEO or director sells stock?** Turn on `monitorMode`, add a Slack (or any) webhook URL, and schedule the actor daily. You'll get a digest only when a new Form 4 shows up, and you're only charged for genuinely new filings.

**Is there a free SEC Form 4 API?** Yes, this is it: SEC EDGAR itself is free and requires no API key. This actor adds ticker resolution, XML parsing into a flat schema, filtering and monitor mode on top.

**Can I track insider trading by ticker across a whole watchlist?** Yes, pass as many tickers as you like in one run.

**What about 8-K and 13D/13G?** Include them in `formTypes` alongside or instead of `4`. Useful for tracking material events and activist/passive ownership stakes on the same schedule.

**Does it cover companies without a ticker?** Yes, pass their SEC CIK number in `ciks`.

**Does it work with AI agents?** Yes. Like every Apify actor it is exposed via REST API and **MCP**, so Claude, Cursor and similar tools can call it directly as a tool, for instance to answer "which Tesla insiders bought stock this quarter?"

***

### Something missing?

If you need an extra field, another source, or a different output, open an issue on this Actor and describe it. I read every request and small additions usually ship within days. More monitors and data Actors are on [my profile](https://apify.com/tagadanar).

*Keywords: SEC EDGAR API, Form 4 insider trading, insider trading tracker, 8-K monitor, 13D 13G filings, 13D activist stake tracker, schedule 13G alert, SEC filings alert, EDGAR full text search, insider buying alert, SEC Form 4 API free, stock insider transactions API, SEC filings for AI agents, MCP, CIK lookup, ticker to CIK.*

# Actor input Schema

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

Stock tickers to monitor, e.g. <code>AAPL</code>, <code>TSLA</code>, <code>NVDA</code>. Resolved to SEC CIKs automatically.

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

SEC CIK numbers to monitor instead of (or in addition to) tickers, e.g. <code>320193</code>. Use this for companies without a public ticker.

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

Which filing types to pull. Accepted values: <code>4</code> (insider trading), <code>8-K</code> (material events), <code>13D</code>, <code>13G</code> (ownership stakes, both plain and <code>SC</code>/<code>SCHEDULE</code> spellings and amendments included automatically).

## `sinceDays` (type: `integer`):

Only filings filed within this many days are returned.

## `maxFilingsPerCompany` (type: `integer`):

Stop after this many matching filings for each ticker/CIK.

## `monitorMode` (type: `boolean`):

Remember filings already seen across runs and return only newly filed ones. Built for a scheduled/recurring run: the first run establishes the baseline, later runs report and charge for new filings only.

## `webhookUrl` (type: `string`):

When monitor mode finds new filings, post a text digest here (Slack incoming webhook or any endpoint accepting <code>{"text": "..."}</code> JSON).

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "ciks": [],
  "formTypes": [
    "4"
  ],
  "sinceDays": 90,
  "maxFilingsPerCompany": 20,
  "monitorMode": false
}
```

# Actor output Schema

## `filings` (type: `string`):

One item per matched filing in the default dataset.

# 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"
    ],
    "formTypes": [
        "4"
    ],
    "sinceDays": 90,
    "maxFilingsPerCompany": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/sec-edgar-monitor").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"],
    "formTypes": ["4"],
    "sinceDays": 90,
    "maxFilingsPerCompany": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/sec-edgar-monitor").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 '{
  "tickers": [
    "AAPL"
  ],
  "formTypes": [
    "4"
  ],
  "sinceDays": 90,
  "maxFilingsPerCompany": 20
}' |
apify call tagadanar/sec-edgar-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=tagadanar/sec-edgar-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2orGdWjPNK98d3Mvi/builds/LmCS5aB145wC9fbcl/openapi.json