# SEC Insider Trade Alerts: Form 4 Buys and Sells (`texxupport/sec-insider-trade-alerts`) Actor

Track insider buying and selling from SEC Form 4 filings. Filter by ticker, insider name, buy or sell and minimum dollar value, and get clean rows with shares, price and value. Schedule runs to get only new filings. Data only, not investment advice.

- **URL**: https://apify.com/texxupport/sec-insider-trade-alerts.md
- **Developed by:** [Kye Williams](https://apify.com/texxupport) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 insider trade delivereds

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 Trade Alerts (Form 4)

Get insider buys and sells from SEC Form 4 filings as clean data: who traded, in which company, how many shares, at what price, and what it is worth. Watch specific companies or scan the whole market, and run it on a schedule to get only filings you have not seen.

The Actor reads the SEC's public EDGAR service at run time. It needs no API key, no proxies and no login.

**Data only. Nothing here is investment advice.** The Actor reports what companies' insiders filed; it does not say what to buy or sell.

### Who it is for

- **Retail investors and newsletter writers** who follow insider activity in companies they care about.
- **Analysts and quant researchers** building datasets of insider transactions.
- **Journalists** tracking trades by executives and directors.
- **AI agents and automations** that need a dependable "what did insiders just file?" tool.

### What you get

One row per transaction, newest filing first. Each row includes:

- the company (`ticker`, `issuerName`, `issuerCik`) and the insider (`insiderName`, `insiderRole` such as "Chief Financial Officer; Director", `officerTitle`, director / officer / 10% owner flags, other reporting owners on a joint filing)
- `transactionDate`, `transactionCode` and a plain-English `transactionType` (Open-market purchase, Open-market sale, Grant or award, Shares withheld for taxes, Gift, and so on)
- `shares`, `pricePerShare`, `valueUsd` (shares times price when both are reported), `acquiredOrDisposed`, `sharesOwnedAfter`, `ownership` (direct or indirect) and `tenb51Plan` (whether the filing says the trade was under a 10b5-1 plan)
- `accessionNumber`, `filingDate` and `filingUrl`: the filing's page on sec.gov

Example row (illustrative values):

```json
{
  "ticker": "ACME",
  "issuerName": "Acme Corp",
  "insiderName": "DOE JANE",
  "insiderRole": "Chief Financial Officer",
  "transactionDate": "2026-09-29",
  "transactionCode": "S",
  "transactionType": "Open-market sale",
  "shares": 1000,
  "pricePerShare": 150.25,
  "valueUsd": 150250,
  "sharesOwnedAfter": 9000,
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1234567/000123456726000001/0001234567-26-000001-index.htm"
}
```

### Input

| Field | What it does |
| --- | --- |
| `companies` | Stock tickers (AAPL) or CIK numbers. With companies listed, the Actor reads those companies' Form 4 filings. Leave empty to scan every Form 4 in the date window. |
| `transactionTypes` | Which kinds of transactions to deliver: buy, sell, award, exercise, tax-withholding, gift, other. Default: buy and sell (open-market purchases and sales). |
| `minValueUsd` | Only trades worth at least this much. Trades with no reported price cannot meet a minimum. |
| `insiderNames` | Only trades by insiders whose name contains one of these words. |
| `daysBack`, `dateFrom`, `dateTo` | The filing-date window. Default: the last 7 days. |
| `maxFilingsToScan` | When scanning the whole market, stop after reading this many filings. Default 400. |
| `onlyNew` | Deliver only trades this Actor has not already delivered for this exact search, and skip filings it has already read. |
| `maxResults` | Stop after this many trades. Default 100, up to 10,000. |

### Alerts on a schedule

1. Set `onlyNew` to true, list your `companies` and choose your `transactionTypes`.
2. Schedule the Actor (for example daily) from the Apify Console.
3. Each run delivers only trades you have not seen. If a run stops early (cost cap, scan limit or time limit), the next run continues where it stopped.

The "already delivered" list is kept in a storage called `sec-insider-alerts-state` in your own Apify account, with one list per distinct search.

### Pricing

You pay per insider trade delivered (pay per event), plus Apify's normal platform usage for the run. See the Pricing tab for the current price. Set a maximum cost per run in the run options to cap spending: the Actor stops as soon as the cap is reached.

### Limits and good to know

- **Whole-market scans read one filing at a time** at a polite pace set by the SEC's fair-access rules, so a scan of a busy week takes minutes and stops at `maxFilingsToScan`. Listing companies is much faster. With `onlyNew` on, repeated runs work through the window.
- The SEC's daily index for a day appears after that day ends, so today's filings arrive in tomorrow's run. Weekends and holidays have no index.
- For listed companies the Actor reads the company's most recent filings list (about the latest thousand filings), which covers normal date windows.
- Only Form 4 (not 4/A amendments) and only the stock transaction table are read. Option and other derivative rows are not included.
- Filings can contain errors or be amended later. Check the filing linked in each row.
- Insider trades are a record of the past. They are not a recommendation.

### Data source and disclaimer

Data comes from the SEC's public EDGAR system (sec.gov). This Actor is not affiliated with or endorsed by the U.S. Securities and Exchange Commission or any government agency.

### Support

Found a problem or want another field? Open an issue on this Actor's Issues tab.

# Actor input Schema

## `companies` (type: `array`):

Stock tickers such as AAPL or SEC CIK numbers such as 320193. Leave empty to scan every Form 4 in the date window (slower, and capped by 'Maximum filings to scan').

## `transactionTypes` (type: `array`):

Which kinds of transactions to deliver. Buy and sell are open-market purchases and sales.

## `minValueUsd` (type: `integer`):

Only trades worth at least this much (shares times price). Trades with no reported price cannot meet a minimum. Leave at 0 for no minimum.

## `insiderNames` (type: `array`):

Only trades by insiders whose name contains one of these words. SEC lists names last name first, for example SMITH JOHN.

## `daysBack` (type: `integer`):

How many days before the end date to look, by filing date. Ignored when you fill in a start date.

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

First filing date to include, written YYYY-MM-DD.

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

Last filing date to include, written YYYY-MM-DD. Defaults to today (UTC).

## `maxFilingsToScan` (type: `integer`):

Safety limit for whole-market scans (no companies listed): stop after reading this many filings. Turn on 'Only new' and run again to continue where it stopped.

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

Turn this on and run the Actor on a schedule to get an alert-style feed. The Actor remembers which trades it already delivered, and which filings it already read, for this exact search.

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

Stop after this many trades. You pay per trade delivered, so this also caps your cost.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT"
  ],
  "transactionTypes": [
    "buy",
    "sell"
  ],
  "minValueUsd": 0,
  "daysBack": 7,
  "maxFilingsToScan": 400,
  "onlyNew": false,
  "maxResults": 100
}
```

# Actor output Schema

## `results` (type: `string`):

Every insider trade delivered by this run, as a table you can download as CSV, Excel or JSON.

# 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 = {
    "companies": [
        "AAPL",
        "MSFT"
    ],
    "transactionTypes": [
        "buy",
        "sell"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("texxupport/sec-insider-trade-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 = {
    "companies": [
        "AAPL",
        "MSFT",
    ],
    "transactionTypes": [
        "buy",
        "sell",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("texxupport/sec-insider-trade-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 '{
  "companies": [
    "AAPL",
    "MSFT"
  ],
  "transactionTypes": [
    "buy",
    "sell"
  ]
}' |
apify call texxupport/sec-insider-trade-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,texxupport/sec-insider-trade-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/q0oesD82gyERLQK1U/builds/RoRwZtIwXDQ5hcFaY/openapi.json