# SEC EDGAR Scraper - Filings, Form 4 Insider Trades & XBRL (`offgrid-labs/sec-edgar-filings-insider`) Actor

SEC EDGAR scraper for any US-listed company: SEC filings (10-K, 10-Q, 8-K, S-1 and more), Form 4 insider trading transactions parsed into per-trade rows with insider role, shares, price and dollar value, and XBRL key financials - official SEC APIs, no key. From $0.50 per 1,000 filings.

- **URL**: https://apify.com/offgrid-labs/sec-edgar-filings-insider.md
- **Developed by:** [OFFGRID LABS](https://apify.com/offgrid-labs) (community)
- **Categories:** Business, Developer tools, News
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $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 EDGAR scraper: filings, Form 4 insider trades and XBRL financials

**TL;DR:** SEC EDGAR Scraper pulls data for any US-listed company from the **SEC's official EDGAR APIs** and returns three kinds of clean rows: **filings** (10-K, 10-Q, 8-K, S-1, 13D, DEF 14A, Form 4 and more), **insider transactions** (Form 3/4/5 parsed into one row per trade, with insider role, shares, price and dollar value) and **XBRL key financials**. It is built for investors, analysts, compliance and IR teams, fintech developers and AI agents. Pricing is per record type: **$0.50 per 1,000 filings, $3.00 per 1,000 insider transactions, $1.00 per 1,000 financials rows**.

Enter tickers or CIKs, pick what you want, click **Start**. No login, no proxy, no API key.

### What data you get

| Record type (`recordType`) | One row per | Key fields |
|---|---|---|
| `filing` | SEC filing | `ticker`, `companyName`, `cik`, `form`, `accessionNumber`, `filingDate`, `reportDate`, `acceptedAt`, `description`, `items` (8-K item numbers), `isXBRL`, `filingUrl`, `filingIndexUrl` |
| `insider_transaction` | Form 3/4/5 transaction per reporting owner | `insiderName`, `insiderRelationship` (officer title, director, 10% owner), `transactionDate`, `transactionCode`, `transactionType` (plain English), `acquiredDisposed`, `shares`, `pricePerShare`, `transactionValue` (USD), `sharesOwnedAfter`, direct/indirect ownership, derivative details, `is10b51Plan`, footnotes |
| `company_facts` | Company (XBRL) | latest annual and latest reported revenue, net income, operating income, diluted EPS, assets, liabilities, equity, cash, shares outstanding, public float; SIC, exchanges, fiscal year end |

**Form 4 transaction codes**

| Code | Meaning |
|---|---|
| `P` | Open-market or private purchase |
| `S` | Open-market or private sale |
| `A` | Grant or award |
| `M` | Option exercise / conversion |
| `F` | Tax withholding (shares withheld) |
| `G` | Gift |

The dataset has five views: **Overview - filings and insider trades**, **Filings - one row per SEC filing**, **Insider transactions - one row per Form 3/4/5 transaction**, **Key financials - one row per company (XBRL)** and **All fields - every record type**.

### Use cases

- **Insider-trading signals**: every insider buy and sell for your watchlist each day, with dollar values already calculated; filter to open-market purchases (`P`) above $100,000.
- **Event-driven research**: catch new 8-Ks (with item numbers such as 2.02 results or 5.02 executive changes) and 10-K/10-Q filings as they land.
- **Fundamentals at a glance**: a compact financial snapshot per company without parsing XBRL yourself.
- **Compliance and IR teams**: monitor peers' filings and insider activity.

### How to use the SEC EDGAR scraper

1. Enter **SEC User-Agent**: your name/company and email, e.g. `Acme Research jane.doe@acme.com`. The SEC requires this on every request (fair-access policy); it is only sent to sec.gov. If you leave it empty on Apify, the actor owner's contact is used.
2. Add **Companies**: tickers (`AAPL`, `MSFT`, `BRK-B`) or CIKs (`320193`).
3. Choose **What to collect**: filings, insider transactions, key financials.
4. Choose **Form types** and the date range, and optionally insider filters (**Insider transaction codes**, **Minimum transaction value (USD)**).
5. Click **Start**. Schedule it daily with **Filed within last N days** = 1 for a watchlist feed.

#### Form 4 insider trading

Select **Insider transactions**. Every Form 3/4/5 in the date range is parsed into one row per transaction, with the insider's role, transaction code, shares, price and dollar value. Filter to `P` (purchases) or `S` (sales) and a minimum value to keep only the trades that matter.

#### 10-K, 10-Q and 8-K filings

Select **Filings** and the form types you need. Each filing is one row with filing date, period, 8-K item numbers and links to the document and index.

#### XBRL financials

Select **Key financials** for one row per company with the latest annual and latest reported values from SEC XBRL company facts.

### Input example

```json
{
  "companies": ["AAPL", "NVDA", "TSLA"],
  "userAgent": "Acme Research jane.doe@acme.com",
  "recordTypes": ["filings", "insider_transactions", "company_facts"],
  "formTypes": ["10-K", "10-Q", "8-K", "4"],
  "filedWithinDays": 30,
  "transactionCodes": ["P", "S"],
  "minTransactionValue": 100000
}
```

### Output example

An insider transaction row:

```json
{
  "recordType": "insider_transaction",
  "cik": "0000320193",
  "companyName": "Apple Inc.",
  "ticker": "AAPL",
  "form": "4",
  "accessionNumber": "0001140361-26-041201",
  "filingDate": "2026-10-29",
  "reportDate": "2026-10-27",
  "insiderName": "Newstead Jennifer",
  "insiderRelationship": "Officer (SVP, GC and Government Affairs)",
  "isOfficer": true,
  "is10b51Plan": true,
  "securityTitle": "Common Stock",
  "transactionDate": "2026-10-27",
  "transactionCode": "S",
  "transactionType": "Open-market sale",
  "acquiredDisposed": "D",
  "shares": 2399,
  "pricePerShare": 343.36,
  "transactionValue": 823720.64,
  "sharesOwnedAfter": 32396,
  "ownershipType": "Direct",
  "footnotes": ["This transaction was made pursuant to a Rule 10b5-1 trading plan adopted by the reporting person on May 5, 2026."],
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126041201/xslF345X06/form4.xml",
  "sourceUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126041201/form4.xml",
  "scrapedAt": "2026-11-03T01:30:00.000Z"
}
```

A key-financials row contains `metrics`, for example:

```json
"revenue": {
  "concept": "us-gaap:RevenueFromContractWithCustomerExcludingAssessedTax",
  "unit": "USD",
  "latestAnnual": { "value": 416161000000, "periodEnd": "2025-09-27", "fiscalYear": 2025, "form": "10-K", "filed": "2025-10-31" },
  "latest": { "value": 109417000000, "periodEnd": "2026-06-27", "fiscalPeriod": "Q3", "form": "10-Q", "filed": "2026-07-31" }
}
```

Use the **Insider transactions** dataset view for a ready-made insider table. A run summary is stored in the key-value store record `RUN_SUMMARY`.

### How much does SEC EDGAR data cost?

Pay per event, billed per record type, so you only pay for what you collect. Compute and proxy costs are included. The price is the same on every Apify plan.

| Event | Charged when | Price |
|---|---|---|
| `filing` | One filing row saved (10-K, 10-Q, 8-K, Form 4...) | **$0.50 per 1,000** ($0.0005 each) |
| `insider-transaction` | One Form 3/4/5 transaction or holding row saved | **$3.00 per 1,000** ($0.003 each) |
| `financial-fact` | One XBRL key-financials row saved (one per company) | **$1.00 per 1,000** ($0.001 each) |
| `apify-actor-start` | Once per run (Apify's standard start fee) | $0.00005 |

**Worked examples**

- **1,000 filings** = **$0.50**; **1,000 insider transactions** = **$3.00**; key financials for **1,000 companies** = **$1.00**.
- Test run on 2026-11-03 with the default input (AAPL + MSFT, last 30 days, 6 filings each): 11 filings + 27 insider transactions = 11 × $0.0005 + 27 × $0.003 = **about $0.09**.
- A daily filings-only feed for a 100-company watchlist that files 300 forms a month: **$0.15 per month**.

Set **Maximum cost per run** in the run options; the scraper stops cleanly at the limit.

### How it compares

| | This actor | Calling the EDGAR APIs yourself | Financial data subscriptions |
|---|---|---|---|
| Form 4 parsed to rows with dollar values | Yes | You parse the XML | Yes |
| Filings + insider trades + XBRL in one run | Yes | Three different endpoints and formats | Yes |
| SEC fair-access rules (User-Agent, 10 req/s) | Handled | You implement them | n/a |
| Full EDGAR history | Yes | Yes | Varies |
| Cost | From $0.50 per 1,000 filings, pay as you go | Free + your time and hosting | Subscription |

### FAQ

#### How do I get insider trading data from SEC Form 4?

Select **Insider transactions**, add tickers and a date range. Each Form 4 transaction becomes one row with `insiderName`, `insiderRelationship`, `transactionCode`, `shares`, `pricePerShare` and `transactionValue`.

#### How do I find insider buying (open-market purchases)?

Set **Insider transaction codes** to `P` and, optionally, **Minimum transaction value (USD)** (for example 100000).

#### Can I download 10-K and 8-K filings for a list of companies?

Yes. Select **Filings**, set **Form types** to `10-K`, `8-K` (or any others) and the date range. Each row links to the filing document (`filingUrl`) and index (`filingIndexUrl`).

#### Why do I need to enter a User-Agent?

The SEC's fair-access policy requires automated tools to identify themselves with a contact email and blocks anonymous traffic. The scraper also stays under the SEC limit of 10 requests per second.

#### How far back can I go?

The whole EDGAR history for the company (electronic filings back to 1994-2001, depending on the company). Older filing pages are loaded automatically when your date range needs them.

#### Why does one Form 4 give several rows?

A Form 4 can report several transactions and joint filers. Each transaction for each reporting owner is one row, so you can sum and filter easily.

#### Are foreign companies supported?

Companies that file with the SEC (including 20-F/40-F filers) are supported. Insider Forms 3/4/5 exist only for US-registered issuers.

#### Is it legal to scrape SEC EDGAR?

EDGAR data is public US government information, accessed through the SEC's official APIs within the SEC's documented access rules. Insider names are published by the SEC as part of mandatory public disclosures. This is data, not investment advice.

#### Can an AI agent use this SEC EDGAR API?

Yes. Through the Apify MCP server an agent can find it with `search-actors`, read the input schema and run it, for example "insider purchases over $1M at NVDA in the last 90 days". See **Integrations**.

#### Something wrong?

Open an issue on the Issues tab; we aim to respond within 24 hours.

### Integrations

- **API**: `POST https://api.apify.com/v2/acts/offgrid-labs~sec-edgar-filings-insider/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>` with the input JSON as the body returns the rows directly (runs under 5 minutes; otherwise start a run and read its dataset).
- **Python / JavaScript**: `pip install apify-client` / `npm install apify-client`, then `client.actor("offgrid-labs/sec-edgar-filings-insider").call(run_input={...})`.
- **No-code**: Apify's integrations for **Make**, **Zapier** and **n8n**, plus Google Sheets, Slack, webhooks and Schedules (for example a daily insider-buying alert).
- **MCP / AI agents**: add `https://mcp.apify.com?tools=offgrid-labs/sec-edgar-filings-insider` to your MCP client to expose this actor as a tool.

### Changelog

- **2026-11-03** · README restructured (record-type and transaction-code tables, cost examples, comparison, FAQ, integrations); input field descriptions rewritten with units, defaults and examples for AI agents; output schema and dataset views described; Store title "SEC EDGAR Scraper - Filings, Form 4 Insider Trades & XBRL". Removed an incorrect line about plan discounts: prices are flat on every plan.
- **2026-11-03** · Pricing split by record type: `filing` $0.50, `insider-transaction` $3.00, `financial-fact` $1.00 per 1,000 (was one blended `result` event); Filings and Key financials dataset views; output schema.
- **2026-11-03** · First release: EDGAR submissions JSON, Form 3/4/5 XML parsing, XBRL company facts, SEC fair-access User-Agent and rate limit.

### Related actors

| Actor | What it does |
|---|---|
| Company Registry Lookup (KYB) | Official company records from UK, France, Norway and Finland registers |
| Public Tenders Scraper | Government tenders and contract awards from EU TED and US SAM.gov |
| ATS Jobs Scraper | Open jobs at the companies you follow (Greenhouse, Lever, Ashby, Workable) |

***

```
// OFFGRID LABS ─────────────────────────────────────────────
// status: monitored 24/7 by a self-hosted agent swarm
// health checks: every 6h · auto-repair + rollback on failure
// sources: official public APIs and open data only
// support: open an issue — human-reviewed response within 24h
// ───────────────────────────────────────────────────────────
```

# Actor input Schema

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

Required. One company per line: US stock ticker (AAPL, MSFT, BRK-B) or SEC CIK number (320193). Example: \["AAPL", "NVDA"]

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

Your name or company plus a contact email, e.g. "Acme Research jane.doe@acme.com". SEC's fair-access policy requires every automated request to identify the requester; this is sent only in the request header to sec.gov. If empty on Apify, the actor owner's contact is used.

## `recordTypes` (type: `array`):

Record types to save; each record is one dataset row and is charged by type: filings ($0.50 per 1,000), insider_transactions (Form 3/4/5 rows, $3.00 per 1,000), company_facts (one XBRL key-financials row per company, $1.00 per 1,000). Default \["filings", "insider_transactions"].

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

SEC form types to include, e.g. 10-K, 10-Q, 8-K, 4, S-1, 13D, DEF 14A, 20-F. Default \["10-K", "10-Q", "8-K", "4"]. Leave empty for all forms. Form 4 is added automatically when insider transactions are selected.

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

If true (default), also include amended forms such as 10-K/A and 4/A.

## `filedWithinDays` (type: `integer`):

Only filings from the last N days. Default 90. 0 = no date limit (full EDGAR history). Ignored when 'Filed on or after' is set. Example: 1 for a daily feed

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

Optional fixed start date in YYYY-MM-DD format; overrides 'Filed within last N days'. Older filing history is loaded automatically when needed. Example: 2025-01-01

## `maxFilingsPerCompany` (type: `integer`):

Maximum filings per company, newest first; insider transaction rows come from these filings (one Form 4 can produce several rows). Default 50. 0 = no limit. Example: 20

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

Optional. Keep only these Form 4 transaction codes: P = open-market purchase, S = open-market sale, A = grant/award, M = option exercise, F = tax withholding, G = gift. Leave empty for all. Example: \["P"]

## `minTransactionValue` (type: `integer`):

Optional. Keep only insider transactions where shares x price is at least this many US dollars. Rows without a price are excluded when set. Default 0 = no filter. Example: 100000

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

If true (default), include Form 4 Table II rows: options, RSUs and other derivative securities.

## `includeHoldings` (type: `boolean`):

If true, also output holding-only rows with no transaction (e.g. Form 3 initial holdings). Charged as insider-transaction rows. Default false.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT"
  ],
  "recordTypes": [
    "filings",
    "insider_transactions"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K",
    "4"
  ],
  "includeAmendments": true,
  "filedWithinDays": 30,
  "maxFilingsPerCompany": 6,
  "minTransactionValue": 0,
  "includeDerivatives": true,
  "includeHoldings": false
}
```

# Actor output Schema

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

Every row of every record type with all fields.

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

Compact table: record type, ticker, form, filing date, description, insider, transaction type, shares, price, value and filing link.

# 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"
    ],
    "recordTypes": [
        "filings",
        "insider_transactions"
    ],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K",
        "4"
    ],
    "filedWithinDays": 30,
    "maxFilingsPerCompany": 6
};

// Run the Actor and wait for it to finish
const run = await client.actor("offgrid-labs/sec-edgar-filings-insider").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",
    ],
    "recordTypes": [
        "filings",
        "insider_transactions",
    ],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K",
        "4",
    ],
    "filedWithinDays": 30,
    "maxFilingsPerCompany": 6,
}

# Run the Actor and wait for it to finish
run = client.actor("offgrid-labs/sec-edgar-filings-insider").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"
  ],
  "recordTypes": [
    "filings",
    "insider_transactions"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K",
    "4"
  ],
  "filedWithinDays": 30,
  "maxFilingsPerCompany": 6
}' |
apify call offgrid-labs/sec-edgar-filings-insider --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,offgrid-labs/sec-edgar-filings-insider"
        }
    }
}
```

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/6Tg3rWL7BdtLDGwKK/builds/eyG0vwj5QVahw0CMc/openapi.json