# SEC Form 4 Insider Trading Scraper (`parseforge/sec-form4-scraper`) Actor

Scrapes SEC Form 4 insider trading filings from EDGAR by company ticker, CIK, or latest market-wide filings. Returns each transaction as a flat row with insider name, title, trade code, shares, price, and post-trade holdings.

- **URL**: https://apify.com/parseforge/sec-form4-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $37.49 / 1,000 result items

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/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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### SEC Form 4 Insider Trading Scraper

**Scrape SEC Form 4 insider trading filings by ticker, CIK, or market-wide, up to a million per run.** Every transaction comes with the insider's name, title, trade code, shares, price, and post-trade holdings. No API key. Export to CSV, JSON, Excel, or XML.

SEC EDGAR's official full-text search is built for documents, not data. This Actor reads the Form 4 filing index directly, resolves tickers to CIKs, and returns each insider transaction as one flat row. Filter by date range, transaction code, or derivative type before the data ever reaches your dataset.

| Who uses it | What they scrape SEC EDGAR for |
|---|---|
| Quantitative analysts | Build insider sentiment signals from open market buys and sells |
| Compliance officers | Monitor executive trading at peer companies for policy benchmarking |
| Financial journalists | Find notable insider purchases or sales for story leads |
| Retail investors | Track what corporate insiders are doing with their own stock |
| Academic researchers | Assemble large Form 4 datasets for event studies |

### What it does

This Actor collects SEC Form 4 insider trading filings by company ticker, CIK number, or the latest market-wide filings, and returns each transaction as a flat row.

- 🏢 **Company mode:** pass tickers like AAPL or CIKs like 0000320193 and get every Form 4 filing for those issuers.
- ⚡ **Latest mode:** pull the most recent Form 4 filings across the entire market, no ticker list needed.
- 📅 **Date range filter:** restrict filings to a start and end date, inclusive, in YYYY-MM-DD format.
- 🏷️ **Transaction code filter:** keep only P/S open market trades, A grants, M option exercises, or any of the 20 SEC codes.
- 📈 **Derivative toggle:** include or exclude options, RSUs, warrants, and convertible notes from the output.
- 🔍 **Ticker to CIK resolution:** every ticker is resolved to its SEC Central Index Key automatically.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with SEC EDGAR data

**📊 Build an insider sentiment dashboard.**

A quant fund runs the Actor daily in latest mode, filters to P and S codes, and feeds the net insider buy/sell ratio into their alpha model.

**🔔 Monitor executive selling at a watchlist.**

A compliance analyst passes 50 tickers in company mode with a 90-day date range and reviews every open market sale for pre-clearance violations.

**📰 Find story leads from unusual insider activity.**

A financial journalist runs the Actor weekly in latest mode, filters to large A grants or P purchases, and cross-references the insiders with recent news.

**🎓 Assemble a research dataset.**

An academic researcher pulls five years of Form 4 data for the S\&P 500, excludes derivatives, and exports to CSV for an event study on insider trading windows.

### Why choose this scraper

| | What you get |
|---|---|
| **No SEC API key** | Reads the public EDGAR filing index directly, no registration or rate-limit headaches |
| **One row per transaction** | Each insider trade is a flat record with insider name, title, code, shares, price, and holdings |
| **Market-wide or company-specific** | Track a watchlist of tickers or scan every new Form 4 filed today |
| **Clean derivative handling** | Keep or drop options, RSUs, and warrants with one checkbox |

### How it compares

No other Store actor targets SEC EDGAR the same way, so the honest comparison is with the alternatives teams actually weigh.

| | SEC Form 4 Insider Trading Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When SEC EDGAR changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor from tickers, CIKs, or the latest market-wide feed, and filters run as each filing is read so only matching transactions reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10,
 "tickers": [
 "AAPL",
 "TSLA",
 "NVDA"
 ]
}
```

A larger pull:

```json
{
 "maxItems": 200,
 "tickers": [
 "AAPL",
 "TSLA",
 "NVDA"
 ]
}
```

### Pricing

Pay-per-result: **$0.04999 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $5.00 |
| 1,000 results | $49.99 |
| 10,000 results | $499.90 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [SEC Form 4 Insider Trading Scraper](https://apify.com/parseforge/sec-form4-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to SEC EDGAR through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/sec-form4-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your date range. If startDate and endDate are set, they must include the filing dates you expect. Also verify your tickers or CIKs are valid and that transactionCodes, if set, matches the trade types in those filings.

**Why are some tickers not resolving?**

Ticker resolution uses the SEC's company ticker mapping. If a ticker fails, try passing the CIK directly. CIKs are more stable and avoid ambiguity.

**Why do I see fewer rows than maxItems?**

maxItems is the upper limit, not a target. The Actor returns every matching transaction up to that limit. If filters are restrictive, the actual count will be lower.

**Why am I getting a 403 or rate-limit error?**

SEC EDGAR enforces fair use. The Actor throttles requests automatically, but for heavy production runs, set a custom User-Agent with your organization name and contact email as recommended by the SEC.

**Why are derivative transactions missing?**

Check the includeDerivatives checkbox. It defaults to true, but if you disabled it, options, RSUs, warrants, and convertible notes are excluded from the output.

### FAQ

| Question | Answer |
|---|---|
| What is SEC Form 4? | Form 4 is the statement of changes in beneficial ownership that corporate insiders, officers, directors, and 10% owners, must file with the SEC within two business days of a transaction in their company's securities. |
| Do I need an API key or SEC EDGAR account? | No. The Actor reads the public EDGAR filing index directly. The only requirement is a User-Agent header, which is pre-filled with a default you can override. |
| Can I scrape by ticker symbol? | Yes. Pass tickers like AAPL or TSLA in company mode. Each ticker is resolved to its SEC CIK and all matching Form 4 filings are fetched. |
| Can I scrape by CIK number? | Yes. Pass CIKs with or without leading zeros, for example 0000320193 or 320193, in company mode. |
| What is the difference between company mode and latest mode? | Company mode pulls Form 4 history for the tickers or CIKs you specify. Latest mode pulls the most recent Form 4 filings across the entire market, regardless of issuer. |
| What transaction codes can I filter by? | All 20 SEC transaction codes are supported: P, S, V, A, D, F, I, M, C, E, H, O, X, G, L, W, Z, J, K, and U. Leave the filter empty to include every coded transaction. |
| Does the output include derivative transactions? | By default, yes. Options, RSUs, warrants, and convertible notes are included. Disable the includeDerivatives checkbox to keep only share-level transactions. |
| Can I filter by date range? | Yes. Set startDate and endDate in YYYY-MM-DD format. Both are inclusive and apply to company mode and latest mode. |
| How many filings can I collect per run? | Up to 1,000,000 Form 4 filings per run. Set maxItems to control the volume. |
| What format is the data exported in? | The Actor returns a flat dataset that can be exported to CSV, JSON, Excel, or XML from the Apify platform. |
| Is this legal to scrape? | Yes. SEC EDGAR is a public government database. The SEC requires a descriptive User-Agent header, which the Actor provides by default. |
| How often is the data updated? | The Actor reads EDGAR live on every run. In latest mode, each run returns the most recent filings available at that moment. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by U.S. Securities and Exchange Commission. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

How to discover filings. `company` pulls Form 4 history for the tickers/CIKs you specify. `latest` pulls the most recent Form 4 filings across the entire market.

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

How many Form 4 filings to collect per run.

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

Stock ticker symbols. Each ticker is resolved to its SEC CIK and all Form 4 filings are fetched. Used when mode = `company`.

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

SEC Central Index Keys, with or without leading zeros (e.g. 0000320193 or 320193). Used when mode = `company`.

## `startDate` (type: `string`):

Earliest filing date to include, in YYYY-MM-DD format. Inclusive.

## `endDate` (type: `string`):

Latest filing date to include, in YYYY-MM-DD format. Inclusive.

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

Only output transactions matching these SEC transaction codes. Leave empty to include every coded transaction.

## `includeDerivatives` (type: `boolean`):

Include rows for derivative securities (options, RSUs, warrants, convertible notes). Disable for cleaner share-level data only.

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

SEC requires a contact User-Agent header on every request. The default is fine for casual use; supply your own "Sample Company Name AdminContact@samplecompany.com" for production runs.

## Actor input object example

```json
{
  "mode": "company",
  "maxItems": 10,
  "tickers": [
    "AAPL",
    "TSLA",
    "NVDA"
  ],
  "includeDerivatives": true,
  "userAgent": "ParseForge SEC Form 4 Scraper contact@parseforge.dev"
}
```

# Actor output Schema

## `overview` (type: `string`):

Compact table view of the most-used fields per transaction.

## `fullData` (type: `string`):

Complete dataset with every extracted field, including footnotes and derivative-specific columns.

# 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 = {
    "maxItems": 10,
    "tickers": [
        "AAPL",
        "TSLA",
        "NVDA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/sec-form4-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 = {
    "maxItems": 10,
    "tickers": [
        "AAPL",
        "TSLA",
        "NVDA",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/sec-form4-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 '{
  "maxItems": 10,
  "tickers": [
    "AAPL",
    "TSLA",
    "NVDA"
  ]
}' |
apify call parseforge/sec-form4-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/sec-form4-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/QsRFfP7Hikr5HQz8H/builds/pT0cj0sMPO1sx2TEI/openapi.json