# SEC EDGAR Filings Scraper - Form 4 Insider Trades (`flash_scraper/sec-edgar-filings-scraper`) Actor

Scrape SEC EDGAR filings by stock ticker, company, or CIK. Filter to Form 4 insider trades — parsed to insider name, role, shares, price & a -100 to +100 buy/sell signal — or pull 8-K, 10-K, 13F & more with direct doc links. Official SEC data, no API key. Export CSV/JSON/Excel.

- **URL**: https://apify.com/flash\_scraper/sec-edgar-filings-scraper.md
- **Developed by:** [Flash Scrape](https://apify.com/flash_scraper) (community)
- **Categories:** News, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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/platform/actors/running/actors-in-store#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

## Insider Trading Tracker — SEC Form 4 Buy/Sell Scraper with Signal Score

Turn the SEC's raw EDGAR filings feed into a clean **insider trading** dataset — give it a stock ticker and get every **Form 4 insider buy/sell transaction**, parsed into shares, price, value, and a **-100 to +100 signal score** so you can rank real conviction trades in seconds, at **$5 per 1,000 results**.

### What does it do?

This actor is an **insider trading scraper** built on the official SEC EDGAR API (data.sec.gov). Give it a **ticker** (or company name) and it resolves the CIK, pulls the company's filings, and for every **Form 3/4/5 insider filing** fetches the ownership XML and parses the **full transaction table** — insider name, role (director / officer / 10% owner), transaction code, shares, price per share, total value, and shares owned after. Every insider filing is then classified with an **insider\_signal** ("Bullish — open-market buy", "Bearish — open-market sale", "Net insider buying", etc.) and a **buy/sell signal\_score** from -100 (strong sell) to +100 (strong buy), plus `total_bought_value`, `total_sold_value`, and `net_transaction_value` so you can rank conviction trades instead of reading raw filings one by one. It also returns 8-K, 10-K, 13F, and S-1 filings with plain-English form labels and direct document links when you don't filter to Form 4 only.

### Why use it / who's it for

- **Retail investors** building a personal insider-buying watchlist — see when a CEO or CFO is putting real money into their own stock, not just a link to a filing.
- **Fintech builders** who need a clean, structured insider-trading feed to power a trading signal, screener, or alert app — no HTML scraping, no XML parsing on your end.
- **Equity & credit analysts** who want Form 4 insider transactions joined with company profile data (SIC industry, exchange, fiscal year end) for fundamental research.
- **Newsletter writers & fintwit / stock-alert accounts** who publish "insider buying alerts" and need a repeatable, automatable data source.
- **Compliance teams & journalists** who need a clean, dated, linkable trail of officer/director trading activity.
- **Use cases**: insider-trading watchlists across a portfolio of tickers, scheduled Form 4 alerts via Make/n8n/Zapier, ranking the market's most bullish/bearish insider signals this week, feeding a stock-screener or trading-signal model.

### How to use it

1. Enter one or more stock **tickers** (e.g. `["AAPL", "NVDA"]`) or a **company name** search.
2. Set **formType** to `4` to scope the run to insider trading filings only (leave blank for all filing types).
3. Optionally set **dateFrom** to only pull recent insider trades, and cap **maxItems** / **maxPerCompany**.
4. Leave **parseInsiderTransactions** on (default) to get the full parsed buy/sell transaction table and signal score on each row.
5. Run the actor and export results as CSV, JSON, or Excel — or pull them straight into Sheets/Airtable via integrations.

### Output fields

| Field | Description |
|---|---|
| `ticker`, `company`, `cik` | Resolved stock ticker, company name, and SEC CIK |
| `company_sic`, `company_industry` | SIC code and plain-English industry |
| `company_exchange` | Listing exchange(s), e.g. Nasdaq |
| `fiscal_year_end`, `state_of_incorporation`, `entity_category` | Company profile fields |
| `form`, `form_label` | Filing form (e.g. `4`) and plain-English label ("Insider trade") |
| `filing_date`, `report_date` | When it was filed / the transaction date |
| `accession_number` | SEC accession number |
| `primary_doc_url`, `filing_index_url`, `insider_xml_url` | Direct links to the filing document, index, and raw ownership XML |
| `is_xbrl`, `size` | XBRL flag and file size |
| `insider_name`, `insider_role` | Reporting insider's name and role |
| `insider_is_director`, `insider_is_officer`, `insider_is_ten_percent_owner` | Insider relationship flags |
| `transactions` | Full parsed **insider trading** table: security, date, code, code\_label, shares, price\_per\_share, value, shares\_owned\_after |
| `transaction_count` | Number of transactions on the filing |
| `total_bought_value`, `total_sold_value`, `net_transaction_value` | Dollar totals bought vs. sold |
| `insider_signal`, `signal_score` | Plain-English **insider trading signal** and a -100…+100 buy/sell score |

#### Example output

A real sample from a live run:

| ticker | company | form | form\_label | filing\_date | primary\_doc\_url |
|---|---|---|---|---|---|
| AAPL | Apple Inc. | 4 | Insider trade | 2026-06-17 | [form4.xml](https://www.sec.gov/Archives/edgar/data/320193/000114036126025622/xslF345X06/form4.xml) |
| AAPL | Apple Inc. | 4 | Insider trade | 2026-06-17 | [form4.xml](https://www.sec.gov/Archives/edgar/data/320193/000114036126025620/xslF345X06/form4.xml) |
| AAPL | Apple Inc. | 4 | Insider trade | 2026-05-29 | [form4.xml](https://www.sec.gov/Archives/edgar/data/320193/000114036126023363/xslF345X06/form4.xml) |
| AAPL | Apple Inc. | SD | SD | 2026-05-28 | [ef20073373\_sd.htm](https://www.sec.gov/Archives/edgar/data/320193/000114036126023149/ef20073373_sd.htm) |

### Input example

```json
{
  "tickers": ["AAPL", "NVDA"],
  "formType": "4",
  "dateFrom": "2026-01-01",
  "parseInsiderTransactions": true,
  "maxItems": 500
}
```

### How much does it cost?

This actor is **pay-per-event at $0.005 per result — $5 per 1,000 insider trading records** (effective 2026-07-16). There's no subscription: you only pay for filings actually returned. New Apify accounts get **roughly 1,000 results free** on the platform's free tier, enough to build and test a full insider-trading watchlist across a dozen tickers before spending anything.

### FAQ

#### Is it legal to scrape SEC insider trading filings?

Yes. Form 4, 8-K, 10-K, and all other filings come straight from the SEC's public EDGAR API (data.sec.gov) — the same government database anyone can browse for free. This actor just parses it into structured rows.

#### How fresh is the insider trading data?

The SEC "recent" feed (used by this actor) holds each company's latest filings, typically updated the same day insiders file their Form 4 — often within two business days of the actual trade, as required by SEC rules.

#### Do I need an SEC API key or account?

No. The SEC EDGAR data API is free and open; this actor needs no API key, login, or proxy to run.

#### What's the difference between signal\_score and insider\_signal?

`insider_signal` is a plain-English label ("Bullish — open-market buy", "Bearish — open-market sale", "Net insider buying/selling", "Routine"). `signal_score` is the same classification as a number from -100 (strong sell) to +100 (strong buy), so you can sort or threshold programmatically.

#### Can I track multiple tickers at once?

Yes — pass an array of tickers and the actor resolves each to its CIK and pulls filings for all of them in parallel, sorted newest first.

### Other Flash Scrape lead tools

- [Email Verifier](https://apify.com/flash_scraper/email-verifier) — validate and clean lead lists before outreach
- [Company Domain Enricher](https://apify.com/flash_scraper/company-domain-enricher) — find the right website/domain for any company name
- [Local Business Leads Scraper](https://apify.com/flash_scraper/local-business-leads) — B2B leads by city and category
- [Google Maps Leads Opener](https://apify.com/flash_scraper/google-maps-leads-opener) — bulk-open Google Maps business leads for fast outreach

# Actor input Schema

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

Stock ticker symbols, e.g. 'AAPL', 'NVDA', 'TSLA'. The actor resolves them to SEC CIKs.

## `companyName` (type: `string`):

Company name search (matches the SEC company title, partial). Use instead of / with tickers.

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

SEC Central Index Keys, if you already have them.

## `formType` (type: `string`):

Keep only filings whose form starts with this, e.g. '4' (insider trades), '8-K', '10-K', '13F', 'SC 13'. Leave empty for all forms.

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

Only filings on/after this date (YYYY-MM-DD). Optional.

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

Maximum filings to return across all companies.

## `maxPerCompany` (type: `integer`):

Cap per company (the SEC 'recent' feed holds up to ~1000 latest filings).

## `parseInsiderTransactions` (type: `boolean`):

For insider filings, fetch and parse the ownership XML into a structured transaction table (insider name, role, code, shares, price, value, shares owned after) plus a buy/sell signal score.

## `maxInsiderDocs` (type: `integer`):

Cap on how many Form 3/4/5 documents to fetch + parse per run (each is one extra request to SEC).

## Actor input object example

```json
{
  "tickers": [
    "NVDA",
    "TSLA"
  ],
  "ciks": [],
  "maxItems": 200,
  "maxPerCompany": 1000,
  "parseInsiderTransactions": true,
  "maxInsiderDocs": 300
}
```

# Actor output Schema

## `results` (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": [
        "AAPL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flash_scraper/sec-edgar-filings-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 = { "tickers": ["AAPL"] }

# Run the Actor and wait for it to finish
run = client.actor("flash_scraper/sec-edgar-filings-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "AAPL"
  ]
}' |
apify call flash_scraper/sec-edgar-filings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=flash_scraper/sec-edgar-filings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/svKRBNqhDCkV0N7D0/builds/95O00eTm9Biamo13p/openapi.json