# SEC Form 4 Monitor: Insider Trading Alerts (`incontrovertible_gate/sec-form4`) Actor

Real-time insider trading alerts from SEC EDGAR Form 4 filings. Watch any tickers, filter by transaction value, and push notifications to Slack, Discord, Telegram or any webhook. A modern programmable alternative to OpenInsider, QuiverQuant, and SECForm4.com — pay only $0.10 per alert delivered.

- **URL**: https://apify.com/incontrovertible\_gate/sec-form4.md
- **Developed by:** [Netsrac](https://apify.com/incontrovertible_gate) (community)
- **Categories:** Other, Agents, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 alert dispatcheds

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 Form 4 Monitor — Real-Time Insider Trading Alerts to Slack, Discord & Telegram

**Get push notifications the moment a corporate insider files a Form 4 with the SEC.** Watch any list of US-listed tickers and receive alerts on **Slack, Discord, Telegram, or any webhook** within minutes of the filing hitting EDGAR. A modern, programmable **alternative to OpenInsider, QuiverQuant, InsiderFinance, and SECForm4.com** — but built for engineers, traders, and quant teams who want push alerts and clean JSON, not yet another dashboard to refresh.

> **TL;DR:** SEC Form 4 filings are public, free, and goldmine signal — but no free site pushes them to your channel of choice in real time. This actor does, and you only pay per alert delivered.

### What does SEC Form 4 Monitor do?

This actor watches the public [SEC EDGAR Form 4 feed](https://www.sec.gov/cgi-bin/browse-edgar?action=getcurrent\&type=4) — the filings every officer, director, and 10%-owner must submit within 2 business days of trading their company's stock — and pushes a structured alert to your Slack, Discord, or Telegram every time an insider on your watchlist transacts. It parses each filing's XML to extract the **insider's name, title, transaction code (P/S/A/M/F), share count, and price**, calculates the dollar value, applies your filters, and delivers a clean alert with a direct link to the SEC filing.

Insider buying clusters and large CEO sells are some of the highest-signal events in equity markets. Hedge funds pay tens of thousands per month for the same data through Bloomberg terminals (`BIQ <GO>`), FactSet, S\&P Capital IQ, or specialized providers like **WhaleWisdom, VerityData/InsiderScore, or 2iQ Research**. This actor delivers the underlying SEC data for **cents per alert**, with the same latency.

#### What this actor solves

- **Push notifications** the moment an insider trades — not next-day email digests
- **Custom watchlists** — track only the tickers you care about
- **Programmatic access** to Form 4 data — clean JSON, dataset export, webhook out
- **Direct EDGAR XML parsing** — actual share counts, prices, transaction codes, not a screenshot
- **Pipe to your own backend** — feed an LLM, a trading bot, a database, or a Discord
- **Minutes-fresh data** — within ~1 polling interval of the SEC accepting the filing

### Why use SEC Form 4 Monitor instead of free dashboards or paid Bloomberg?

| | Free sites (OpenInsider, Finviz, SECForm4.com) | Paid platforms (Bloomberg, WhaleWisdom, VerityData) | **SEC Form 4 Monitor** |
|---|---|---|---|
| **Cost** | Free, ad-supported | $24K–$300K/year | ~$0.10 per alert delivered |
| **Push alerts to your channel** | ❌ (manual refresh) | ✅ (custom integrations $$$) | ✅ Slack, Discord, Telegram, webhook |
| **Watchlist filtering** | Limited | ✅ | ✅ |
| **Min transaction-value filter** | ❌ | ✅ | ✅ |
| **Buy/sell/grant code filtering** | Partial | ✅ | ✅ |
| **JSON dataset for backtesting** | ❌ | ✅ | ✅ |
| **No dashboard required** | ❌ | ❌ | ✅ |
| **Pay only when something happens** | n/a | ❌ (flat fee) | ✅ |
| **Self-hosted / programmable** | ❌ | Limited | ✅ |

If you're tired of refreshing OpenInsider every morning, paying for a Bloomberg you don't fully use, or copy-pasting Form 4s into your trading journal — this is the missing piece.

### Use cases & workflows

#### 1. Day trader / swing trader: catch insider-buying clusters before the news cycle

Watch 20–50 small-/mid-cap tickers. Set `minTransactionValue: 50000`. Insider clusters (3+ officers buying in one day) are one of the highest-conviction signals in equity markets — and you'll see them before the 8-K hits. **Recent example:** on the first day this actor was tested live, six Patrick Industries (PATK) officers bought the open market in a single session, totaling over $2.4M. That's the textbook setup.

#### 2. Quant: build your own factor model

Set `notificationChannel: "none"`. Schedule the actor every 30 minutes. Every match writes to the Apify dataset. Wire the dataset to your data warehouse via the [Apify Webhook Integration](https://docs.apify.com/platform/integrations) → Snowflake/BigQuery/S3. Backtest insider-cluster strategies against price data without scraping anything yourself.

#### 3. Long-only PM: monitor your portfolio

Watch your 30 holdings. Filter to sells over $500K. Get a Slack ping when management is dumping shares — often the first signal something has changed in the business.

#### 4. Newsletter / fintwit creator: never miss a story

Watch the S\&P 100. Pipe alerts into a private Discord. Be first on Twitter when a CEO sells $50M.

#### 5. Compliance / IR team: monitor your own company

Watch your own ticker. Confirm that insiders are filing on time and within blackout-period rules.

#### 6. AI agent / LLM workflow: feed insider trades into Claude/GPT

Use `customWebhookUrl` to POST every match to your own LLM-driven analysis pipeline. Auto-summarize cluster events, correlate with earnings, generate trade theses.

### How to use SEC Form 4 Monitor

> ⚠️ **Important: this actor must be scheduled to receive ongoing alerts.** A single run only checks for filings once. Use Apify's **built-in Schedules** feature — no Zapier, n8n, cron server, or other third party needed. It's already part of your Apify account and free to use.

1. **Click "Try for free"** to add the actor to your Apify account.
2. **Configure the input:** tickers (e.g. `NVDA, TSLA, META`), `minTransactionValue`, and pick a `notificationChannel`.
3. **Paste your webhook URL or Telegram credentials.** All secret fields are stored encrypted by Apify.
4. **First run: enable `testMode`** to fire one alert for the most recent matching filing and confirm your webhook works.
5. **Set up the Schedule** (the only thing that turns this from a one-shot into a real-time monitor):
   - Open the actor → **Schedules** tab → **Create new schedule**
   - Cron: `0 */2 * * *` (every 2 hours) is the recommended default
   - Choose this actor + the same input you tested with
   - Save. That's it — alerts will now arrive on your schedule.

#### Schedule cadence cheat sheet

| Cron | Frequency | Best for |
|------|-----------|----------|
| `*/30 * * * *` | every 30 min | Active day traders, news desks |
| `0 */2 * * *` | every 2 hours | Most retail traders, default |
| `0 */6 * * *` | every 6 hours | Long-term investors |
| `0 13 * * 1-5` | weekdays 9am ET | Daily morning digest |

**Why no n8n / Zapier / external scheduler is needed:** Apify Schedules runs the actor on Apify's infrastructure, fully managed. Your watchlist + webhook stay in this one config. Less moving parts, less to break, less surface area for credential leaks.

### Input

| Field | Description |
|-------|-------------|
| `tickers` | Stock tickers to watch (`["NVDA","TSLA",…]`) |
| `minTransactionValue` | Minimum USD value of a transaction to alert on. Default `100000`. |
| `alertOnBuys` | Alert on purchases (P), grants (A), option exercises (M). Default `true`. |
| `alertOnSells` | Alert on sales (S) and tax withholding sales (F). Default `true`. |
| `notificationChannel` | `none` | `slack` | `discord` | `telegram` | `webhook` |
| `slackWebhookUrl` | Slack incoming webhook (when channel = slack) |
| `discordWebhookUrl` | Discord webhook (when channel = discord) |
| `telegramBotToken` + `telegramChatId` | Telegram bot credentials |
| `customWebhookUrl` | Any HTTPS endpoint receiving JSON alerts |
| `userAgent` | Required by SEC: `Your Name your@email.com` |
| `testMode` | First-run sanity check — fires one alert without dedup |

### Output

Every alert is also pushed to the run's dataset. Example item:

```json
{
  "accessionNumber": "000120992926000006",
  "filedAt": "2026-05-06T08:42:11-04:00",
  "ticker": "PATK",
  "company": "PATRICK INDUSTRIES INC",
  "insiderName": "NEMETH ANDY L",
  "insiderTitle": "Director, Chief Executive Officer",
  "transactionType": "Open-market purchase",
  "transactionCode": "P",
  "shares": 10000,
  "pricePerShare": 88,
  "totalValue": 880000,
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/76605/.../...-index.htm"
}
```

You can download the dataset in **JSON, CSV, Excel, or HTML** from the Apify Console, query it via the [Apify API](https://docs.apify.com/api/v2), or auto-pipe it to Google Sheets, Airtable, Notion, or Slack via [Apify integrations](https://docs.apify.com/platform/integrations).

### Data table

| Field | Type | Description |
|-------|------|-------------|
| `filedAt` | date | When EDGAR received the filing |
| `ticker` | string | Stock ticker symbol |
| `company` | string | Issuer company name |
| `insiderName` | string | Reporting person |
| `insiderTitle` | string | Director / Officer / 10% Owner / officer title |
| `transactionType` | string | Open-market purchase, sale, grant, option exercise, etc. |
| `transactionCode` | string | SEC code: P (buy), S (sell), A (grant), M (exercise), F (tax withholding) |
| `shares` | number | Number of shares transacted |
| `pricePerShare` | number | USD price per share |
| `totalValue` | number | shares × price |
| `filingUrl` | link | Direct link to the SEC filing index |

### Pricing — pay-per-event

This actor uses **Apify pay-per-event pricing: ~$0.10 per alert delivered**. On days with no insider activity matching your filters, you pay nothing. Compare to:

| Service | Approx cost | Notes |
|---|---|---|
| Bloomberg Terminal | $24,000/year | Includes everything, but you're paying for terminals you may not need |
| FactSet | $12,000+/year | Institutional only |
| WhaleWisdom Pro | $1,000+/year | Mostly 13F-focused; Form 4 is secondary |
| VerityData / InsiderScore | $$$ enterprise | Best-in-class but priced for hedge funds |
| OpenInsider | Free | No alerts, no API, dashboard only |
| **SEC Form 4 Monitor** | **~$5–$25/month for typical retail use** | Push alerts + JSON API |

A typical retail user watching 5–10 tickers averages 5–20 alerts per month. A quant team watching the Russell 2000 might see 500+ alerts per month — still under $50.

### Tips & advanced options

- **Tune `minTransactionValue` carefully.** $0 floods you with routine vesting and tax withholding. $100K is a reasonable retail default. $1M filters to executive-cluster signals only.
- **Schedule frequency.** Every 2 hours catches most filings within ~1 hour of EDGAR posting. Every 30 minutes is best for active traders. Every 6 hours is fine for long-term investors.
- **Cluster detection.** Run multiple actor instances per sector and watch for *clusters* — 3+ insiders in the same company buying in one week is a strong leading indicator.
- **Pipe to a database.** Set `notificationChannel: "none"` and use Apify's Webhook Integration to POST every new dataset item to your own backend.
- **Combine with 13F & 13D scrapers.** This actor handles Form 4. Pair it with separate actors for 13F (institutional) and 13D/G (activist) filings for a complete insider/institution picture.

### FAQ

**Is this legal?** Yes. Form 4 filings are public information published by the SEC under the Securities Exchange Act of 1934. There is no restriction on using them.

**How fresh is the data?** EDGAR's RSS feed updates every few minutes. Latency from filing-acceptance to your alert is roughly the gap between scheduled runs (so 2 hours on the default cadence), plus ~30 seconds for parsing.

**Why am I missing some filings?** EDGAR's "current" feed shows the 100 most-recent Form 4s. On extremely high-volume days (proxy seasons, post-earnings windows) older filings may scroll off before your next run. Increase schedule frequency to every 30 minutes or every hour during peak periods.

**Why isn't my ticker matching?** SEC tracks companies by CIK, not ticker. Recently-IPO'd companies, ADRs, and some non-US-listed entities may not yet appear in SEC's [`company_tickers.json`](https://www.sec.gov/files/company_tickers.json) mapping. Open an issue with the ticker and we'll investigate.

**Does this work for 13F/13D/13G filings?** No — this actor monitors **Form 4** only (officer/director/10%-owner trades). Institutional 13Fs and activist 13D/Gs are separate filing types and would need their own actors.

**Does this work for Schedule A grants or 10b5-1 plan trades?** Yes. Form 4 captures these — they appear with transaction codes A (grant) and the 10b5-1 footnote when applicable. The actor surfaces all transaction codes; use `alertOnBuys`/`alertOnSells` and `minTransactionValue` to filter.

**What if I want non-US insider data?** This actor is US-only (SEC EDGAR). Canadian SEDI filings, UK FCA filings, and EU MAR filings would each need a separate actor.

### Support & feedback

Open an issue on the actor's **Issues tab** on Apify Store. Feature requests welcome — especially around clustering analytics, alternative filing types, and integration patterns.

***

*Disclaimer: This actor is an information-retrieval tool for publicly available SEC filings. Nothing in its output constitutes investment advice. Trade responsibly.*

**Keywords:** insider trading alerts, SEC Form 4 alerts, Form 4 tracker, OpenInsider alternative, insider buying alerts, real-time insider trading, insider trading API, EDGAR Form 4, Form 4 monitor, insider transaction Slack alerts, insider trading Discord bot, insider trading Telegram bot, CEO stock sales tracker, track insider buying, stock insider alerts.

# Actor input Schema

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

Stock tickers (e.g. NVDA, TSLA, META). Form 4 filings for these companies trigger alerts.

## `minTransactionValue` (type: `integer`):

Only alert when total share value (price × shares) is at least this amount. Filters out small grants and routine vesting. Set 0 to alert on everything.

## `alertOnBuys` (type: `boolean`):

Send alerts for open-market purchases and grants.

## `alertOnSells` (type: `boolean`):

Send alerts for open-market sales and tax withholding sales.

## `notificationChannel` (type: `string`):

Where to send alerts. Choose 'none' to only write to the dataset (use Apify integrations like Zapier or Make to wire that up).

## `slackWebhookUrl` (type: `string`):

Incoming-webhook URL from your Slack app. Required when channel is 'slack'.

## `discordWebhookUrl` (type: `string`):

Channel webhook URL from Discord. Required when channel is 'discord'.

## `telegramBotToken` (type: `string`):

Bot token from @BotFather. Required when channel is 'telegram'.

## `telegramChatId` (type: `string`):

Chat ID where alerts go (DM, group, or channel). Required when channel is 'telegram'.

## `customWebhookUrl` (type: `string`):

Any HTTPS endpoint. Receives a JSON POST per match. Required when channel is 'webhook'.

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

SEC requires a User-Agent with your name and email (per their fair-access policy). Format: 'Your Name your@email.com'.

## `testMode` (type: `boolean`):

On first run only: ignore the dedup state and fire one alert for the most recent matching filing. Use this to confirm your webhook works before scheduling.

## Actor input object example

```json
{
  "tickers": [
    "NVDA",
    "TSLA",
    "META"
  ],
  "minTransactionValue": 100000,
  "alertOnBuys": true,
  "alertOnSells": true,
  "notificationChannel": "none",
  "userAgent": "SEC Form 4 Monitor your-email@example.com",
  "testMode": false
}
```

# Actor output Schema

## `alerts` (type: `string`):

All matched insider filings from this run. Download as JSON, CSV, Excel, or HTML.

## `runConsole` (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 = {
    "tickers": [
        "NVDA",
        "TSLA",
        "META"
    ],
    "userAgent": "SEC Form 4 Monitor your-email@example.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("incontrovertible_gate/sec-form4").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": [
        "NVDA",
        "TSLA",
        "META",
    ],
    "userAgent": "SEC Form 4 Monitor your-email@example.com",
}

# Run the Actor and wait for it to finish
run = client.actor("incontrovertible_gate/sec-form4").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": [
    "NVDA",
    "TSLA",
    "META"
  ],
  "userAgent": "SEC Form 4 Monitor your-email@example.com"
}' |
apify call incontrovertible_gate/sec-form4 --silent --output-dataset

```

## MCP server setup

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

```

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/5uPhjV0pMcoxYuVaO/builds/rEg7b3Ymr5gIDWqnG/openapi.json