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

Scrape SEC EDGAR Form 4 insider transactions: buys, sells, grants, exercises, gifts. Filter by ticker, CIK, date range, transaction code, or stream the live feed. 32 fields per row.

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

## Pricing

Pay per event

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 📈 SEC EDGAR Form 4 Insider Trading Scraper

> 🚀 **Pull every SEC Form 4 insider transaction in seconds.** Filter by ticker, CIK, date range, or transaction code. No API key, no registration, no manual XML wrangling.

> 🕒 **Last updated:** 2026-05-17 · **📊 32 fields** per record · **All 20 SEC transaction codes** covered · **10,000+ public US companies** searchable · **Updated every filing day**

The **SEC EDGAR Form 4 Insider Trading Scraper** turns raw Form 4 ownership filings into a clean, transaction-level dataset. Every record is one buy, sell, grant, gift, option exercise, or other coded transaction by an officer, director, or 10% beneficial owner. You get the **issuer**, the **insider**, the **security**, the **shares**, the **price**, the **post-transaction position**, and the **footnotes**. The scraper hits the official SEC EDGAR XML, so the data is identical to what shows up on the SEC viewer, parsed into stable JSON columns.

Form 4 filings have to be submitted within **two business days** of a transaction, which makes them one of the timeliest legally-mandated signals in US public markets. Insider behavior shows up here before it shows up in 13F holdings, in research notes, or in news coverage. This Actor lets quantitative funds, compliance teams, and retail traders pull a **full historical Form 4 backfill for any ticker**, or subscribe to a **rolling latest-filings feed** that updates throughout each filing day.

| Target Audience | Primary Use Cases |
| --- | --- |
| Quantitative analysts and hedge fund researchers | Build insider-activity factors, cluster-buy signals, sale-after-grant detection |
| Compliance officers and corporate secretaries | Verify Section 16 filings, monitor blackout-window violations, audit internal vs. SEC counts |
| Retail investors and financial bloggers | Track C-suite buying or selling, surface 10% owner activity, follow specific insiders |
| Data engineers and fintech builders | Backfill insider-transaction tables, power dashboards, feed downstream ML models |

---

### 📋 What the SEC EDGAR Form 4 Insider Trading Scraper does

- 🔍 **Two scrape modes.** Pick `company` to backfill every Form 4 for a list of tickers or CIKs, or `latest` to subscribe to the SEC's market-wide live feed of the most recent 20 filings.
- 💸 **Transaction-level rows.** One row per non-derivative or derivative transaction line item, joined with issuer, insider, and filing metadata. No filing-only rows, no holding-snapshot noise.
- 🎯 **Filter by transaction code.** Restrict output to specific SEC codes (P, S, A, M, G, and 15 others) when you only care about open-market trades or only care about grants.
- 📅 **Date-range support.** Pass `startDate` and `endDate` to limit historical pulls to any window since EDGAR went online in 1994.
- 🧾 **Footnote text included.** Every footnote referenced by a transaction is pulled into the record, so context like "vests over three years" or "by estate planning vehicle" stays attached to the trade.
- ⚙️ **Derivative-aware.** Options, RSUs, warrants, and convertible notes are parsed with exercise price, exercise date, expiration date, and underlying security shares.

Each record carries the issuer name, ticker, and CIK, the reporting insider's name, CIK, and Section 16 role, the security title and type, the transaction date and code with a human-readable description, share count, price per share, computed USD value, post-transaction position, ownership type (direct or indirect), nature of indirect ownership, and the canonical SEC viewer URL plus the raw XML document URL. Derivative rows add exercise price, exercise date, expiration date, underlying security title, and underlying share count.

> 💡 **Why it matters:** Form 4 data is legally mandated, time-sensitive, and free at the source, but the source is awkward XML scattered across millions of filings. This Actor collapses that into one structured row per transaction so you can write SQL or pandas against it directly.

---

### 🎬 Full Demo

🚧 Coming soon: a 3-minute walkthrough showing how to backfill a ticker, monitor the latest feed, and filter by transaction code.

---

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Notes</th></tr>
<tr><td><code>mode</code></td><td>enum</td><td><code>company</code> backfills tickers or CIKs you supply. <code>latest</code> pulls the most recent market-wide Form 4 feed.</td></tr>
<tr><td><code>tickers</code></td><td>array of strings</td><td>Stock tickers (AAPL, TSLA, NVDA). Each is resolved to its SEC CIK using the official ticker map.</td></tr>
<tr><td><code>ciks</code></td><td>array of strings</td><td>SEC Central Index Keys, with or without leading zeros.</td></tr>
<tr><td><code>startDate</code></td><td>date</td><td>YYYY-MM-DD lower bound on filing date. Inclusive.</td></tr>
<tr><td><code>endDate</code></td><td>date</td><td>YYYY-MM-DD upper bound on filing date. Inclusive.</td></tr>
<tr><td><code>transactionCodes</code></td><td>array of strings</td><td>Output only rows matching these SEC codes. Empty means all codes.</td></tr>
<tr><td><code>includeDerivatives</code></td><td>boolean</td><td>Set to false for share-only rows. Default true keeps options, RSUs, warrants, and other derivatives.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>Total rows to return. Free plan caps at 10, paid plans up to 1,000,000.</td></tr>
<tr><td><code>userAgent</code></td><td>string</td><td>Optional SEC-compliant contact header. The default works for casual use.</td></tr>
</table>

Example: backfill three tickers and only keep open-market buys and sales.

```json
{
    "mode": "company",
    "tickers": ["AAPL", "TSLA", "NVDA"],
    "transactionCodes": ["P", "S"],
    "startDate": "2026-01-01",
    "maxItems": 500
}
````

Example: subscribe to the SEC's live feed of the latest Form 4 filings.

```json
{
    "mode": "latest",
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** SEC EDGAR is rate-limited to **10 requests per second** per User-Agent. The scraper paces itself well under that limit. Apple alone has roughly **1,300 Form 4 filings** since 1994, so a full historical backfill of a high-volume issuer can run for several minutes if you do not set a `startDate`.

***

### 📊 Output

Each row in the dataset is one Form 4 transaction. Below is the schema, then three real records from a live SEC pull on 2026-05-17.

#### 🧾 Schema

| Field | Type | Example |
| --- | --- | --- |
| 🏢 `issuerName` | string | `Apple Inc.` |
| 💹 `issuerTradingSymbol` | string | `AAPL` |
| 🆔 `issuerCik` | string | `0000320193` |
| 👤 `reportingOwnerName` | string | `LEVINSON ARTHUR D` |
| 🆔 `reportingOwnerCik` | string | `0001214128` |
| 🎭 `reportingOwnerRelationship` | array of strings | `["Director"]` |
| 🪪 `reportingOwnerTitle` | string | `Senior Vice President, CFO` |
| 📦 `securityType` | string | `non-derivative` or `derivative` |
| 🏷️ `securityTitle` | string | `Common Stock` |
| 📅 `transactionDate` | string (ISO date) | `2026-05-06` |
| 🔣 `transactionCode` | string | `S` |
| 📖 `transactionCodeDescription` | string | `Open market or private sale` |
| 🔢 `transactionShares` | number | `149527` |
| 💵 `transactionPricePerShare` | number | `284.57` |
| 💰 `transactionValueUsd` | number | `42550898.39` |
| ➕ `acquiredOrDisposed` | string | `A` (acquired) or `D` (disposed) |
| 📊 `sharesOwnedFollowingTransaction` | number | `3920049` |
| 🤝 `directOrIndirectOwnership` | string | `D` (direct) or `I` (indirect) |
| 🏦 `natureOfOwnership` | string | `By estate planning vehicle` |
| 🎯 `exercisePrice` | number | `12.50` |
| 📆 `exerciseDate` | string | `2027-01-01` |
| ⏳ `expirationDate` | string | `2030-12-31` |
| 🧷 `underlyingSecurityTitle` | string | `Class A Common Stock` |
| 🔗 `underlyingSecurityShares` | number | `83333` |
| 🗓️ `periodOfReport` | string | `2026-05-06` |
| ⏰ `filedAt` | string (ISO datetime) | `2026-05-08T22:30:09.000Z` |
| 🧾 `accessionNumber` | string | `0001140361-26-020298` |
| 🔗 `filingUrl` | string | SEC filing index URL |
| 📄 `documentUrl` | string | Raw Form 4 XML URL |
| 🗒️ `footnotes` | string | Pipe-separated footnote text |
| 🕒 `scrapedAt` | string (ISO datetime) | `2026-05-17T04:19:17.962Z` |
| ❌ `error` | string | Only set on filing-level failures |

#### 📦 Sample records

<details>
<summary>📈 Typical: a director sells shares on the open market</summary>

```json
{
    "issuerName": "Apple Inc.",
    "issuerTradingSymbol": "AAPL",
    "issuerCik": "0000320193",
    "reportingOwnerName": "LEVINSON ARTHUR D",
    "reportingOwnerCik": "0001214128",
    "reportingOwnerRelationship": ["Director"],
    "reportingOwnerTitle": null,
    "securityType": "non-derivative",
    "securityTitle": "Common Stock",
    "transactionDate": "2026-05-06",
    "transactionCode": "S",
    "transactionCodeDescription": "Open market or private sale",
    "transactionShares": 149527,
    "transactionPricePerShare": 284.57,
    "transactionValueUsd": 42550898.39,
    "acquiredOrDisposed": "D",
    "sharesOwnedFollowingTransaction": 3920049,
    "directOrIndirectOwnership": "D",
    "natureOfOwnership": null,
    "exercisePrice": null,
    "exerciseDate": null,
    "expirationDate": null,
    "underlyingSecurityTitle": null,
    "underlyingSecurityShares": null,
    "periodOfReport": "2026-05-06",
    "filedAt": "2026-05-08T22:30:09.000Z",
    "accessionNumber": "0001140361-26-020298",
    "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126020298/0001140361-26-020298-index.htm",
    "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126020298/form4.xml",
    "footnotes": null,
    "scrapedAt": "2026-05-17T04:19:17.962Z"
}
```

</details>

<details>
<summary>🧷 Edge case: a derivative grant with footnotes (RSU vesting schedule)</summary>

```json
{
    "issuerName": "PSQ Holdings, Inc.",
    "issuerTradingSymbol": "PSQH",
    "issuerCik": "0001847064",
    "reportingOwnerName": "Rinn James",
    "reportingOwnerCik": "0001985227",
    "reportingOwnerRelationship": ["Director", "Officer"],
    "reportingOwnerTitle": "Chief Financial Officer",
    "securityType": "derivative",
    "securityTitle": "Restricted Stock Units",
    "transactionDate": "2026-05-12",
    "transactionCode": "M",
    "transactionCodeDescription": "Exercise or conversion of derivative security",
    "transactionShares": 83333,
    "transactionPricePerShare": 0,
    "transactionValueUsd": 0,
    "acquiredOrDisposed": "D",
    "sharesOwnedFollowingTransaction": 166667,
    "directOrIndirectOwnership": "D",
    "natureOfOwnership": "",
    "exercisePrice": null,
    "exerciseDate": null,
    "expirationDate": null,
    "underlyingSecurityTitle": "Class A Common Stock",
    "underlyingSecurityShares": 83333,
    "periodOfReport": "2026-05-12",
    "filedAt": "2026-05-15T21:43:42-04:00",
    "accessionNumber": "0001985227-26-000003",
    "filingUrl": "https://www.sec.gov/Archives/edgar/data/1847064/000198522726000003/0001985227-26-000003-index.htm",
    "documentUrl": "https://www.sec.gov/Archives/edgar/data/1847064/000198522726000003/form4-05162026_010538.xml",
    "footnotes": "Each restricted stock unit (\"RSU\") represents a continent right to receive one share of the issuer's Class A Common Stock. | The reporting person was granted 250,000 RSUs under the Company's 2023 Stock Incentive Plan, to vest over three years, with one-third of the RSUs vesting on each of the first three anniversaries commencing on June 1, 2025.",
    "scrapedAt": "2026-05-17T04:19:53.388Z"
}
```

</details>

<details>
<summary>🪶 Sparse: a stock grant with no price and no footnotes</summary>

```json
{
    "issuerName": "AMDOCS LTD",
    "issuerTradingSymbol": "DOX",
    "issuerCik": "0001062579",
    "reportingOwnerName": "Hortig Shimie",
    "reportingOwnerCik": "0002122638",
    "reportingOwnerRelationship": ["Director", "Officer"],
    "reportingOwnerTitle": "See Remarks",
    "securityType": "non-derivative",
    "securityTitle": "Ordinary Shares",
    "transactionDate": "2026-05-13",
    "transactionCode": "A",
    "transactionCodeDescription": "Grant, award, or other acquisition",
    "transactionShares": 84483,
    "transactionPricePerShare": 0,
    "transactionValueUsd": 0,
    "acquiredOrDisposed": "A",
    "sharesOwnedFollowingTransaction": 181696,
    "directOrIndirectOwnership": "D",
    "natureOfOwnership": null,
    "exercisePrice": null,
    "exerciseDate": null,
    "expirationDate": null,
    "underlyingSecurityTitle": null,
    "underlyingSecurityShares": null,
    "periodOfReport": "2026-05-13",
    "filedAt": "2026-05-15T21:45:03-04:00",
    "accessionNumber": "0001193125-26-227582",
    "filingUrl": "https://www.sec.gov/Archives/edgar/data/1062579/000119312526227582/0001193125-26-227582-index.htm",
    "documentUrl": "https://www.sec.gov/Archives/edgar/data/1062579/000119312526227582/ownership.xml",
    "footnotes": null,
    "scrapedAt": "2026-05-17T04:19:52.659Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
| --- | --- |
| 🎯 | **Transaction-level, not filing-level.** Every row is one buy, sell, grant, gift, exercise, or other coded line item. Filings with multiple transactions split into multiple rows so you can group and aggregate however you like. |
| 📡 | **Two modes in one Actor.** `company` for historical backfills, `latest` for live monitoring. No need to wire two scrapers. |
| 🔣 | **All 20 SEC transaction codes parsed.** Each code is mapped to its plain-English description (P, S, A, M, F, G, X, V, and 12 more). |
| 💵 | **Computed USD value.** `transactionValueUsd` is derived from shares times price, ready for filters like "show me trades over $1M". |
| 🧾 | **Footnotes attached to transactions.** Each transaction carries the text of every footnote it references, so context like vesting schedules and indirect-ownership disclosures stays with the trade. |
| 🛰️ | **Derivative columns when relevant.** Exercise price, exercise date, expiration date, underlying security title, and underlying share count are populated for options, RSUs, warrants, and convertibles. |
| ✅ | **Official SEC XML source.** The scraper hits SEC EDGAR directly, so every value is identical to the canonical SEC viewer. No third-party reformatting, no AI hallucinations. |

> 📊 **The scraper resolves any of the 10,000+ tickers in SEC's official ticker map to the right CIK automatically.** Just pass a ticker and you get the full Form 4 history.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
| --- | --- | --- | --- | --- | --- |
| **⭐ SEC EDGAR Form 4 Scraper** *(this Actor)* | Low Apify usage | Every public US company since 1994 | Every filing day | Ticker, CIK, dates, codes, derivatives | One JSON input |
| Manual SEC EDGAR browsing | Free, but slow | Every filing | Manual | Page-by-page | Hours per ticker |
| Paid commercial feeds | Hundreds to thousands per month | Same source | Real-time | Vendor-specific | Contract negotiation |
| Legacy community CSV dumps | Free | Outdated, incomplete | Whenever the maintainer remembers | Limited | Download and merge |
| Building your own EDGAR XML parser | Engineering time | Custom | Custom | Custom | Days to weeks |

For most teams, the value of this Actor is in skipping the XML parser work and the rate-limit handling, not in the data itself, which is free at the source.

***

### 🚀 How to use

1. 🆕 **Sign up.** Create a free Apify account at [console.apify.com/sign-up?fpr=vmoqkp](https://console.apify.com/sign-up?fpr=vmoqkp). No credit card required for the preview.
2. 🔎 **Open the Actor.** Find the SEC EDGAR Form 4 Insider Trading Scraper in the Apify Store.
3. ⚙️ **Configure the input.** Choose `company` mode with a list of tickers, or `latest` mode with no extra parameters. Optionally narrow by `startDate`, `endDate`, or `transactionCodes`.
4. ▶️ **Run.** Click Start and watch the log. The scraper streams transactions to the dataset as it parses each filing.
5. 📥 **Export.** Download the dataset as JSON, CSV, Excel, or RSS, or query it via the Apify API.

> ⏱️ **Total time:** about 30 seconds for a 10-item preview run, 5 to 10 minutes for a full historical backfill of a high-volume ticker like Apple.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%">

#### 📊 Quantitative analysts

- Build cluster-buy signals from coincident insider purchases
- Detect unusual sale sizes against rolling baselines
- Backtest the "Sell after grant" pattern across the Russell 3000
- Feed Form 4 transaction counts into multi-factor models

</td>
<td width="50%">

#### 🛡️ Compliance officers

- Audit Section 16 filings against internal trade records
- Flag transactions inside blackout windows automatically
- Reconcile counts across multiple insider trading systems
- Build internal dashboards for the general counsel

</td>
</tr>
<tr>
<td width="50%">

#### 📰 Financial journalists

- Surface large director and officer sales in real time
- Build watchlists of specific insiders and track every trade
- Compare insider behavior to public guidance and earnings calls
- Power newsletter alerts on cluster activity

</td>
<td width="50%">

#### 🛠️ Fintech developers

- Backfill an insider-transaction table with one input
- Drive consumer alerts when a watched CEO buys shares
- Build a Form 4 history view inside a research product
- Replace expensive commercial feeds for the same data

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating SEC EDGAR Form 4 Insider Trading Scraper

Run this Actor on a schedule or from your own code.

- [**Apify Node.js SDK**](https://docs.apify.com/sdk/js) for JavaScript and TypeScript integrations.
- [**Apify Python SDK**](https://docs.apify.com/sdk/python) for data-science workflows.
- [**Apify API reference**](https://docs.apify.com/api/v2) for any HTTP client.

Schedules let you run the Actor every hour, every morning, or on any cron pattern. A common setup is to run `latest` mode every 15 minutes during market hours and push new rows into your warehouse.

***

### ❓ Frequently Asked Questions

<details>
<summary>📜 What is SEC Form 4 and who has to file it?</summary>

Form 4 is a Statement of Changes in Beneficial Ownership of Securities, required under Section 16(a) of the Securities Exchange Act of 1934. It must be filed within two business days by officers, directors, and beneficial owners of more than 10% of any class of equity security registered with the SEC.

</details>

<details>
<summary>🔁 How often is the data refreshed?</summary>

EDGAR publishes Form 4 filings continuously throughout each filing day (Monday to Friday, excluding US federal holidays). This Actor reads directly from EDGAR, so every run reflects whatever is live at SEC at that moment.

</details>

<details>
<summary>🧾 What transaction codes are supported?</summary>

All 20 codes documented by the SEC: P, S, V, A, D, F, I, M, C, E, H, O, X, G, L, W, Z, J, K, and U. Each transaction in the output carries both the raw code and a plain-English `transactionCodeDescription` field.

</details>

<details>
<summary>🪙 Are derivative securities (options, RSUs, warrants) included?</summary>

Yes by default. Each derivative transaction populates `exercisePrice`, `exerciseDate`, `expirationDate`, `underlyingSecurityTitle`, and `underlyingSecurityShares`. Set `includeDerivatives` to false if you only want common-stock rows.

</details>

<details>
<summary>🆔 Can I pass either a ticker or a CIK?</summary>

Both. Tickers are resolved to CIKs using SEC's official ticker map at run time. You can mix tickers and CIKs in a single run, and unknown tickers are reported as errors rather than crashing the run.

</details>

<details>
<summary>📅 Can I limit results to a date range?</summary>

Yes. Pass `startDate` and `endDate` in `YYYY-MM-DD` format. The bounds are inclusive and applied to the filing date, not the transaction date.

</details>

<details>
<summary>📈 Is one row per filing or one row per transaction?</summary>

One row per transaction. A Form 4 that reports three open-market sales and one option exercise produces four rows, all sharing the same `accessionNumber`. Group by `accessionNumber` to recover the per-filing view.

</details>

<details>
<summary>💼 Can I use this commercially?</summary>

Yes. SEC EDGAR data is public-domain government data with no copyright restrictions. The Actor itself is licensed for both commercial and non-commercial use under your Apify subscription.

</details>

<details>
<summary>💳 Do I need a paid plan?</summary>

The free plan returns up to 10 transactions per run as a preview. Any paid plan unlocks up to 1,000,000 transactions per run. There is no separate subscription for the Actor.

</details>

<details>
<summary>🛟 What happens if a run fails part-way?</summary>

Per-filing errors are isolated. If SEC returns an error for one filing, the Actor logs it and continues with the next. The run only fails completely if a fatal input issue or a long-running SEC outage prevents any filings from being read.

</details>

<details>
<summary>⚖️ Is this scraper legal?</summary>

Yes. EDGAR is the SEC's public dissemination system and is explicitly intended for programmatic access. The Actor respects SEC's request to send a contact User-Agent and stays well below the 10-requests-per-second rate limit.

</details>

<details>
<summary>📤 What output formats are available?</summary>

The Apify dataset can be exported as JSON, JSONL, CSV, Excel, HTML, XML, or RSS. You can also pull data via the Apify API, set up webhooks on dataset writes, or integrate with downstream tools.

</details>

***

### 🔌 Integrate with any app

- [**Zapier**](https://zapier.com/apps/apify/integrations) - trigger workflows whenever a new Form 4 row lands.
- [**Make**](https://www.make.com/en/integrations/apify) - build visual automations on top of the dataset.
- [**Airtable**](https://docs.apify.com/integrations) - sync transactions into a base for collaborative review.
- [**Google Sheets**](https://docs.apify.com/integrations/google-sheets) - feed insider data into a spreadsheet dashboard.
- [**Slack**](https://docs.apify.com/integrations/slack) - alert a channel when a watched insider sells.
- [**Webhooks**](https://docs.apify.com/integrations/webhooks) - push run results to any HTTP endpoint.

***

### 🔗 Recommended Actors

- [**📑 SEC Forms Scraper**](https://apify.com/parseforge/sec-forms-scraper) - top-level metadata for every SEC filing type (10-K, 10-Q, 8-K, Form 4, and more).
- [**🏛️ SEC 13F Holdings Scraper**](https://apify.com/parseforge/sec-13f-holdings-scraper) - institutional holdings disclosed by hedge funds and large investors.
- [**🚀 SEC Form D Scraper**](https://apify.com/parseforge/sec-form-d-scraper) - private-placement and Reg D fundraising notices.
- [**🧑‍⚖️ FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - regulatory backgrounds for brokers and investment advisors.
- [**🏦 SEC IAPD Investment Adviser Scraper**](https://apify.com/parseforge/sec-iapd-scraper) - registered investment adviser profiles and ADV filings.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more financial, regulatory, and corporate-data scrapers.

***

**🆘 Need Help?** Reach out via [**Open our contact form**](https://tally.so/r/BzdKgA) and we will respond within one business day.

***

> ⚖️ **Disclaimer:** This Actor extracts publicly available data from SEC EDGAR for legitimate research, compliance, and analytical purposes. Form 4 filings are public government records. Users are responsible for ensuring their use of the data complies with applicable laws and regulations in their jurisdiction. ParseForge is not affiliated with the SEC or any other government agency.

# 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`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `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("💾 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 '{
  "maxItems": 10,
  "tickers": [
    "AAPL",
    "TSLA",
    "NVDA"
  ]
}' |
apify call parseforge/sec-form4-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC EDGAR Form 4 Insider Trading Scraper",
        "description": "Scrape SEC EDGAR Form 4 insider transactions: buys, sells, grants, exercises, gifts. Filter by ticker, CIK, date range, transaction code, or stream the live feed. 32 fields per row.",
        "version": "0.1",
        "x-build-id": "C4Zub3raizfCU7gJc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~sec-form4-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-sec-form4-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~sec-form4-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-sec-form4-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~sec-form4-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-sec-form4-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Scrape Mode",
                        "enum": [
                            "company",
                            "latest"
                        ],
                        "type": "string",
                        "description": "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.",
                        "default": "company"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "tickers": {
                        "title": "Tickers",
                        "type": "array",
                        "description": "Stock ticker symbols. Each ticker is resolved to its SEC CIK and all Form 4 filings are fetched. Used when mode = `company`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ciks": {
                        "title": "CIK Numbers",
                        "type": "array",
                        "description": "SEC Central Index Keys, with or without leading zeros (e.g. 0000320193 or 320193). Used when mode = `company`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Earliest filing date to include, in YYYY-MM-DD format. Inclusive."
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "Latest filing date to include, in YYYY-MM-DD format. Inclusive."
                    },
                    "transactionCodes": {
                        "title": "Transaction Codes",
                        "type": "array",
                        "description": "Only output transactions matching these SEC transaction codes. Leave empty to include every coded transaction.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "P",
                                "S",
                                "V",
                                "A",
                                "D",
                                "F",
                                "I",
                                "M",
                                "C",
                                "E",
                                "H",
                                "O",
                                "X",
                                "G",
                                "L",
                                "W",
                                "Z",
                                "J",
                                "K",
                                "U"
                            ],
                            "enumTitles": [
                                "P - Open market or private purchase",
                                "S - Open market or private sale",
                                "V - Voluntary early-reported transaction",
                                "A - Grant, award, or other acquisition",
                                "D - Disposition to issuer",
                                "F - Payment of exercise or tax",
                                "I - Discretionary transaction",
                                "M - Exercise or conversion of derivative",
                                "C - Conversion of derivative",
                                "E - Expiration of short derivative",
                                "H - Expiration of long derivative",
                                "O - Exercise of out-of-the-money derivative",
                                "X - Exercise of in-the-money derivative",
                                "G - Bona fide gift",
                                "L - Small acquisition under Rule 16a-6",
                                "W - Acquisition or disposition by will",
                                "Z - Deposit or withdrawal from voting trust",
                                "J - Other acquisition or disposition",
                                "K - Equity swap",
                                "U - Disposition pursuant to tender of shares"
                            ]
                        }
                    },
                    "includeDerivatives": {
                        "title": "Include derivative transactions",
                        "type": "boolean",
                        "description": "Include rows for derivative securities (options, RSUs, warrants, convertible notes). Disable for cleaner share-level data only.",
                        "default": true
                    },
                    "userAgent": {
                        "title": "SEC User-Agent",
                        "type": "string",
                        "description": "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.",
                        "default": "ParseForge SEC Form 4 Scraper contact@parseforge.dev"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
