# SEC Insider Trades Scraper - Form 4 Buys & Sells (`fetchsmith/sec-insider-trades-scraper`) Actor

Scrape SEC EDGAR Form 3/4/5 insider trades from the official filings: one flat row per transaction with insider name, role, decoded code, shares, price, signed USD value and shares held after. No API key, no start fee.

- **URL**: https://apify.com/fetchsmith/sec-insider-trades-scraper.md
- **Developed by:** [Fetch Smith](https://apify.com/fetchsmith) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 insider transactions

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 Trades Scraper — Form 4 buys & sells as flat rows

Reads **SEC EDGAR ownership filings (Forms 3, 4 and 5)** straight from the SEC's own keyless
endpoints and returns **one flat row per reported transaction** — not one row per filing, and not
a PDF link you still have to parse.

Give it tickers (`AAPL`, `NVDA`) or raw CIK numbers. Tickers are resolved against SEC's official
`company_tickers.json` map, so an unlisted ticker is skipped with a warning instead of silently
returning nothing.

### Why this one

- **Parsed transactions, not filing lists.** Most EDGAR Actors hand you an index of 10-K/10-Q/8-K
  filings. This one opens the raw ownership XML behind each Form 4 and pulls out the trade:
  who, what role, which code, how many shares, at what price, how many held afterwards.
- **`transactionCode` is decoded.** `S` → `Open-market sale`, `F` → `Shares withheld for taxes`,
  `M` → `Option exercise/conversion`, and so on for all 17 codes. The distinction matters: a
  large `F` or `M` row is routine compensation mechanics, not a bearish signal, and treating
  every disposition as "insider selling" is the single most common mistake in this dataset.
- **`transactionValueUsd` is signed and pre-computed** — negative on a disposition, positive on
  an acquisition — so you can sum a column without re-deriving the sign from
  `acquiredOrDisposed`.
- **Rule 10b5-1 flag and footnotes are carried through**, which is how you tell a pre-scheduled
  plan sale from a discretionary one.
- **No personal addresses.** The ownership XML contains the reporting person's street address.
  This Actor deliberately never emits it. Names, CIKs, roles and officer titles are the public
  corporate disclosure; the address block is personal data and is not part of this product.
- **No API key, no start fee, HTTP only** (no headless browser), pay only per transaction row.

### Output fields

`id`, `accessionNumber`, `formType`, `filingDate`, `periodOfReport`, `issuerName`, `issuerCik`,
`ticker`, `insiderName`, `insiderCik`, `isDirector`, `isOfficer`, `isTenPercentOwner`, `isOther`,
`officerTitle`, `coFilers`, `derivative`, `securityTitle`, `transactionDate`, `transactionCode`,
`transactionCodeMeaning`, `acquiredOrDisposed`, `shares`, `pricePerShare`, `transactionValueUsd`,
`sharesOwnedAfter`, `directOrIndirect`, `indirectOwnershipNature`, `exercisePrice`,
`expirationDate`, `underlyingSecurityTitle`, `underlyingShares`, `rule10b5_1Plan`, `footnotes`,
`filingUrl`, `url`.

Derivative rows (options, RSUs, convertibles) carry `exercisePrice`, `expirationDate`,
`underlyingSecurityTitle` and `underlyingShares`; non-derivative common-stock rows leave them
`null`. Set `includeDerivative: false` to get common stock only.

#### Sample row

```json
{
  "id": "0001140361-26-037020-n0",
  "accessionNumber": "0001140361-26-037020",
  "formType": "4",
  "filingDate": "2026-09-17",
  "periodOfReport": "2026-09-15",
  "issuerName": "Apple Inc.",
  "ticker": "AAPL",
  "insiderName": "Newstead Jennifer",
  "isOfficer": true,
  "officerTitle": "SVP, GC and Government Affairs",
  "derivative": false,
  "securityTitle": "Common Stock",
  "transactionDate": "2026-09-15",
  "transactionCode": "S",
  "transactionCodeMeaning": "Open-market sale",
  "acquiredOrDisposed": "D",
  "shares": 1438,
  "pricePerShare": 330.19,
  "transactionValueUsd": -474813.22,
  "sharesOwnedAfter": 32914,
  "rule10b5_1Plan": true,
  "footnotes": "This transaction was made pursuant to a Rule 10b5-1 trading plan adopted by the reporting person on May 5, 2026."
}
```

### Notes on the source

- Form 3 is an **initial** statement of holdings and Form 5 an annual catch-up; both are largely
  holdings rather than open-market trades, so a Form 3 often yields **zero transaction rows**.
  That is the filing, not a bug.
- A filing can be made jointly by several reporting persons. The first is used for the
  `insiderName`/role fields and the rest are listed in `coFilers` rather than dropped.
- SEC's filing index is newest-first, so `sinceDate` stops paging as soon as it passes the date.
- Measured across 160 real Form 4 transactions from 11 large-cap issuers (MSFT, ADBE, ORCL, CRM,
  NOW, IBM, META, TSLA, AMZN, GOOGL, NVDA): `exercisePrice` was populated on 15/33 (45%) of
  derivative rows — the rest were RSU vests, which have no strike price — while `expirationDate`
  and `coFilers` were both 0% in this sample. RSU-heavy mega-cap grants rarely carry an
  expiration date, and none of the 11 issuers sampled had a jointly-filed Form 4 in the window
  checked; both fields do populate on option grants and family/trust co-ownership filings, just
  not reliably at large tech issuers. Set `includeDerivative: false` if you only need the
  common-stock rows.

### Related guides

- All FetchSmith tools: https://fetchsmith.com/tools

Source code: https://github.com/Fetchsmith/fetchsmith/tree/main/actors/sec-insider-trades-scraper

# Actor input Schema

## `issuers` (type: `array`):

Ticker symbols (AAPL, NVDA) or raw SEC CIK numbers (320193). Tickers are resolved against SEC's own official ticker->CIK map, so a ticker that SEC does not list is skipped with a warning rather than silently returning nothing.

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

Form 4 is the one that matters for trade signals (a transaction reported within 2 business days). Form 3 is an initial statement of holdings and Form 5 is an annual catch-up; both are mostly holdings rather than open-market trades, so a Form 3 filing often yields zero transaction rows.

## `sinceDate` (type: `string`):

YYYY-MM-DD. Leave empty for no lower bound. SEC's filing index is newest-first, so this stops paging as soon as it passes the date.

## `maxFilingsPerIssuer` (type: `integer`):

How many matching ownership filings to open per company. One filing usually yields 1-4 transaction rows.

## `includeDerivative` (type: `boolean`):

Derivative rows are options, RSUs and convertible securities (with exercise price, expiration and underlying share count). Turn off to get only the non-derivative common-stock rows.

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

Hard cap on transaction rows returned (and therefore on what you are charged).

## Actor input object example

```json
{
  "issuers": [
    "AAPL",
    "NVDA",
    "JPM"
  ],
  "formTypes": [
    "4"
  ],
  "sinceDate": "",
  "maxFilingsPerIssuer": 20,
  "includeDerivative": true,
  "maxResults": 100
}
```

# Actor output Schema

## `dataset` (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 = {
    "issuers": [
        "AAPL",
        "NVDA",
        "JPM"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetchsmith/sec-insider-trades-scraper").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 = { "issuers": [
        "AAPL",
        "NVDA",
        "JPM",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fetchsmith/sec-insider-trades-scraper").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 '{
  "issuers": [
    "AAPL",
    "NVDA",
    "JPM"
  ]
}' |
apify call fetchsmith/sec-insider-trades-scraper --silent --output-dataset

```

## MCP server setup

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

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/M0IK3D0ejd8FwDRX3/builds/tPjL50hu4kySInkwX/openapi.json