# SEC Insider Trading Feed (Form 4 buys & sells, parsed) (`moment-data/sec-insider-transactions-feed`) Actor

Daily feed of SEC Form 4 insider transactions: ticker, role (CEO, director, 10% owner), open-market buys and sells with shares, price and value, 10b5-1 flag. Filter by ticker, signal, role, min value. Official EDGAR data.

- **URL**: https://apify.com/moment-data/sec-insider-transactions-feed.md
- **Developed by:** [Luke Miller](https://apify.com/moment-data) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 insider 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 Feed: Form 4 Buys & Sells, Parsed

Corporate insiders (CEOs, CFOs, directors) and 10% owners must report trades in their company's stock to the SEC on **Form 4** within two business days. This Actor turns the official EDGAR filings into a clean daily feed: **which company, which insider role, open-market buy or sale, how many shares, at what price, total dollar value, holdings after the trade and whether it was a pre-planned 10b5-1 sale**.

### Who uses it

- **Traders and quant researchers:** catch open-market insider *purchases* (code P), the classic bullish signal, the morning after they are filed. Screen out routine grants, option exercises and tax withholding.
- **Activist and fund watchers:** follow 10% owners such as hedge funds and activist funds (named in the output) as they build or cut positions.
- **IR teams, newsletters and analysts:** monitor a ticker watchlist for any insider activity.
- **AI agents and dashboards:** "which CFOs bought more than $100k of their own stock yesterday?" through the Apify API or MCP server.

### What you get

- **One record per filing** with the issuer name, CIK and ticker, insider roles (`director`, `officer`, `tenPercentOwner`, `other`) and officer titles (for example *Chief Executive Officer*, *Senior EVP & CFO*).
- **Signal per filing:** `open-market-buy`, `open-market-sale`, `mixed-buy-sell`, `other` (grants, exercises, tax withholding, gifts) or `holdings-only`.
- **Totals:** open-market buy and sell shares and dollar value, net value, average buy and sell price, shares owned after the trade, and a Rule 10b5-1 plan flag.
- **Parsed transaction lines** (optional): security, date, SEC transaction code with plain-English description, shares, price, value, acquired or disposed, direct or indirect ownership, and for derivatives the exercise price and underlying shares.
- **Filters applied before you pay:** tickers, issuer name, signal, transaction codes, insider roles, entity owners only, minimum dollar value, exclude 10b5-1 plans, form types (3, 4, 5) and amendments.
- **New since last run** mode for daily schedules: pay only for filings you have not received before.

**Privacy by design:** names, CIKs and addresses of *individual* insiders are never output. Each person is described by role and title only. Reporting owners that are legal entities (funds, LPs, LLCs, corporations) are named, because they are businesses. To identify an individual insider, open the official filing via `filingIndexUrl`.

### Quick start

1. Run with the defaults (`{}`) to get 30 Form 4 filings from the latest EDGAR business day in a few seconds.
2. Insider purchases of $50k or more, excluding 10b5-1 plans:

```json
{
  "signals": ["open-market-buy"],
  "minOpenMarketValue": 50000,
  "excludeRule10b51": true,
  "daysBack": 3,
  "maxItems": 200
}
```

3. A ticker watchlist: `{"tickers": ["AAPL", "NVDA", "TSLA"], "daysBack": 5}`. Funds and activists only: `{"entityOwnersOnly": true}`.
4. **Schedule tip:** create an Apify Schedule every weekday morning (for example 7:00 America/New_York, after EDGAR publishes the previous day's index at about 10 pm ET) with `"mode": "sinceLastRun"`, a unique `"stateKey"` and a higher `maxItems`. Each run then delivers only new filings. Connect a webhook, Slack, Google Sheets or Zapier/Make integration.

### Input

| Field | Meaning |
|---|---|
| `mode` | `window` (default, stateless) or `sinceLastRun` (**use for schedules**) |
| `daysBack` | Latest EDGAR business days to read, default 1 |
| `formTypes` | `4` (default), `3` (new insiders), `5` (annual) |
| `includeAmendments` | Include 3/A, 4/A, 5/A, default false |
| `tickers`, `issuerNameContains` | Watchlist filters |
| `signals` | `open-market-buy`, `open-market-sale`, `mixed-buy-sell`, `other`, `holdings-only` |
| `transactionCodes` | SEC codes, e.g. `P`, `S`, `A`, `M`, `G`, `F` |
| `ownerRoles` | `director`, `officer`, `tenPercentOwner`, `other` |
| `entityOwnersOnly` | Only filings by funds, LPs, LLCs, corporations |
| `minOpenMarketValue` | Minimum open-market buy or sell value (USD) |
| `excludeRule10b51` | Drop pre-planned 10b5-1 trades |
| `includeTransactions` | Include parsed transaction lines, default true |
| `maxItems` | Cap per run (also caps your spend), default 30 |
| `maxFilingsToCheck` | Safety cap on documents inspected with narrow filters, default 2000 |
| `contactEmail` | Optional; added to the User-Agent sent to the SEC |
| `stateKey` | One key per saved search (sinceLastRun) |

### Output (example, a real record from Oct 30, 2026)

```json
{
  "documentType": "4",
  "periodOfReport": "2026-10-28",
  "issuerName": "ADAMS NATURAL RESOURCES FUND, INC.",
  "issuerCik": 216851,
  "ticker": "PEO",
  "ownerTypes": ["individual"],
  "ownerRoles": ["director"],
  "officerTitles": [],
  "entityOwners": [],
  "signal": "open-market-buy",
  "transactionCodes": ["P"],
  "openMarketBuyShares": 1010,
  "openMarketBuyValue": 30229.3,
  "avgBuyPrice": 29.93,
  "sharesOwnedAfter": 4135,
  "rule10b51Plan": false,
  "formType": "4",
  "filingDate": "2026-10-30",
  "accessionNumber": "0001771309-26-000005",
  "transactions": [
    { "securityTitle": "Common Stock", "transactionDate": "2026-10-28", "code": "P", "codeDescription": "Open-market or private purchase",
      "acquiredDisposed": "acquired", "shares": 1010, "pricePerShare": 29.93, "value": 30229.3, "sharesOwnedAfter": 4135, "ownership": "indirect" }
  ],
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/216851/000177130926000005/0001771309-26-000005-index.htm"
}
```

(Some fields shortened; see `sample-output.json`.) An entity owner looks like `"entityOwners": [{ "ownerName": "Saba Capital Management, L.P.", "ownerCik": 1510281, "roles": ["tenPercentOwner"] }]`. Every run also writes a summary to the `OUTPUT` record.

### Timing you should know about

- EDGAR publishes the daily form index **nightly** (about 10 pm ET). A run picks up everything filed through the previous business day; weekends and federal holidays are skipped.
- Form 4 is due within two business days of the trade, so `periodOfReport` is usually 0-2 days before `filingDate`.

### Data source and fair access

- Sources: the SEC EDGAR daily form index (`sec.gov/Archives/edgar/daily-index`) and each filing's ownership XML. The SEC states that EDGAR public filing content is free to access and reuse ([SEC FAQ](https://www.sec.gov/about/webmaster-frequently-asked-questions)).
- The Actor follows the SEC's [fair access rules](https://www.sec.gov/search-filings/edgar-search-assistance/accessing-edgar-data): a declared User-Agent, about 6 requests per second (limit 10), and backoff on errors.
- Not affiliated with or endorsed by the SEC. Data is as filed by insiders. This is not investment advice.

### Pricing

Pay per event (Apify takes care of billing; you only pay for what is delivered):

| Event | Price | Charged |
|---|---|---|
| `apify-actor-start` | $0.005 | once per run |
| `insider-filing` | $0.003 | per Form 3/4/5 filing delivered (filings removed by your filters are free) |

A default test run (30 filings) costs about $0.095. A daily open-market-buy screen (~20-60 filings/day) costs about $0.07-0.19/day. The whole market (~300-1,500 Form 4s per business day) costs about $1-4.50/day. `maxItems` and Apify's *max cost per run* cap your spend. No separate platform-usage charges: compute is included in the event prices.

# Actor input Schema

## `mode` (type: `string`):

window (default): matching filings from the latest N EDGAR business days, no saved state. sinceLastRun: only filings not delivered before for this State key; use this for daily schedules.

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

How many of the latest EDGAR business days to read (weekends and holidays skipped). Also the first-run window in sinceLastRun mode.

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

Ownership forms to include: 4 (changes, default), 3 (initial statements of new insiders), 5 (annual).

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

Also deliver amended filings (3/A, 4/A, 5/A).

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

Watchlist of issuer tickers, e.g. AAPL, TSLA, NVDA. Empty = whole market.

## `issuerNameContains` (type: `array`):

Keep filings whose issuer name contains any of these words (case-insensitive).

## `signals` (type: `array`):

open-market-buy = filing has code P purchases and no S sales; open-market-sale = S only; mixed-buy-sell; other = grants, option exercises, tax withholding, gifts; holdings-only = no transactions. Empty = all.

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

Keep filings containing any of these SEC transaction codes, e.g. P (purchase), S (sale), A (grant), M (option exercise), G (gift), F (tax withholding). Empty = all.

## `ownerRoles` (type: `array`):

Keep filings where a reporting owner has any of these roles. Empty = all.

## `entityOwnersOnly` (type: `boolean`):

Keep only filings where at least one reporting owner is a legal entity (fund, LLC, LP, corporation), e.g. activist and 10% holder trades. Entity names are included in the output.

## `minOpenMarketValue` (type: `integer`):

Keep filings whose open-market buy or sell value (shares x price, codes P/S) is at least this amount.

## `excludeRule10b51` (type: `boolean`):

Drop filings marked as made under a Rule 10b5-1 trading plan (pre-scheduled sales), to focus on discretionary trades.

## `includeTransactions` (type: `boolean`):

Include the parsed transaction table (each line: code, shares, price, value, shares owned after, direct/indirect). Turn off for a compact one-row-per-filing feed.

## `maxItems` (type: `integer`):

Hard cap on delivered filings (also caps your spend). A typical business day has 300-1,500 Form 4 filings.

## `maxFilingsToCheck` (type: `integer`):

Safety cap on documents downloaded per run with narrow filters. You are only charged for delivered filings.

## `contactEmail` (type: `string`):

SEC asks automated clients to declare a contact in the User-Agent. Optional: if set, it is added to the User-Agent sent to sec.gov.

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

Name of the saved search for sinceLastRun mode. Use one key per schedule.

## Actor input object example

```json
{
  "mode": "window",
  "daysBack": 1,
  "formTypes": [
    "4"
  ],
  "includeAmendments": false,
  "entityOwnersOnly": false,
  "minOpenMarketValue": 0,
  "excludeRule10b51": false,
  "includeTransactions": true,
  "maxItems": 30,
  "maxFilingsToCheck": 2000,
  "stateKey": "default"
}
```

# Actor output Schema

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

One record per Form 4 (or 3/5) filing.

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

Business days read, counts, filters.

# 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 = {
    "formTypes": [
        "4"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("moment-data/sec-insider-transactions-feed").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 = { "formTypes": ["4"] }

# Run the Actor and wait for it to finish
run = client.actor("moment-data/sec-insider-transactions-feed").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 '{
  "formTypes": [
    "4"
  ]
}' |
apify call moment-data/sec-insider-transactions-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moment-data/sec-insider-transactions-feed"
        }
    }
}
```

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/xe7hiUufTgEVYuvdk/builds/dDWJhKwuCrsxX9jDC/openapi.json