# SEC EDGAR Filings Scraper - 10-K, 10-Q, Insider Trades (`punkrecordsdata/sec-edgar-filings-scraper`) Actor

Scrape SEC EDGAR filings, insider transactions (Form 3/4/5) and XBRL financial facts for any public company. Export to CSV, Excel, JSON.

- **URL**: https://apify.com/punkrecordsdata/sec-edgar-filings-scraper.md
- **Developed by:** [PunkRecordsData](https://apify.com/punkrecordsdata) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.40 / 1,000 filing records

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

<p align="center">
  <img src="https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner" alt="PunkRecordsData" width="100%" />
</p>

## 📈 SEC EDGAR Filings Scraper: 10-K, Insider Trades & XBRL, PunkRecordsData

> 🚀 **SEC filings, insider trades and financial data for any public company, in one run.** Filing history, parsed Form 3/4/5 insider transactions, XBRL financial time series, and full-text search across every filer, straight from SEC's own public API.

Scrape SEC EDGAR data straight from `data.sec.gov`, the SEC's own official API: filing history for any ticker or CIK, insider buy/sell transactions parsed out of Form 3/4/5 filings, structured financial facts (revenue, net income, assets and more) reported in XBRL, and full-text search across every company's filings. No login, no session, no scraping of rendered HTML pages, just SEC's own public data returned as clean, structured rows.

Built for the [Apify platform](https://apify.com): schedule daily runs to catch new insider trades, pull filing history over the API, or feed financial time series straight into a model.

### 📋 What the SEC EDGAR Filings Scraper does

Give it a ticker (like "AAPL") or a CIK and it returns filing history: form type, filing date, accession number, document URL. Turn on **Insider transactions** to get every buy/sell parsed out of that company's Form 3/4/5 filings: who transacted, how many shares, at what price. Turn on **Financial facts** to get XBRL-reported revenue, net income, assets and other concepts as a full time series, and **Industry peer benchmark** to see every other real company's reported value for that same concept in the same fiscal year, sorted highest to lowest. Or skip companies entirely and use **Full-text search** to find any phrase across every filer's filings.

> 💡 **Why it matters:** most SEC scrapers on the market return a flat list of filings and stop there. This one also parses the actual insider-trading numbers out of Form 4 XML and pulls structured financial data out of XBRL, the two things an investor or analyst actually wants, not just a list of documents to open by hand.

### 📊 Output

Real sample fields from a verified run, one of four record types identified by `recordType`.

**`filing-record`** (primary, one row per filing):

| Field | Type | Example |
|---|---|---|
| 🆔 `cik` / 📈 `ticker` | string | `0000320193` / `AAPL` |
| 🏢 `companyName` | string | `Apple Inc.` |
| 📄 `form` | string | `4` |
| 📅 `filingDate` / `reportDate` | string | `2026-09-10` / `2026-09-08` |
| 🔗 `documentUrl` | string | link to the actual filing document |
| 💹 `isXBRL` | boolean | `false` |
| 🧑‍💼 `insiderTransactions` | object or `Not Requested`/`N/A` | see below |

When **Insider transactions** is on and the filing is a Form 3/4/5, `insiderTransactions` holds the reporting owner and every parsed transaction:

```json
{
  "reportingOwnerName": "Newstead Jennifer",
  "isOfficer": true,
  "officerTitle": "SVP, GC and Government Affairs",
  "transactions": [
    { "transactionType": "non-derivative", "transactionCode": "S", "shares": 1438, "pricePerShare": 317.23, "sharesOwnedAfter": 34352 }
  ]
}
```

**`financial-fact-record`** (one row per XBRL concept per company):

```json
{ "concept": "Revenues", "unit": "USD", "series": [{ "periodStart": "2015-09-27", "periodEnd": "2016-09-24", "value": 215639000000, "fiscalYear": 2018, "form": "10-K" }] }
```

When **Industry peer benchmark** is on, the same row also carries `peerBenchmark`, real reported values from every other company for that concept in the same fiscal year:

```json
{ "year": "2018", "totalCompaniesReporting": 3268, "peers": [{ "companyName": "Walmart Inc.", "value": 514405000000 }, { "companyName": "Exxon Mobil Corporation", "value": 290212000000 }] }
```

**`search-hit-record`** (one row per full-text search match, any company):

```json
{ "companyName": "HSBC USA INC /MD/  (CIK 0000083246)", "form": "FWP", "filingDate": "2008-08-13", "documentUrl": "https://www.sec.gov/Archives/edgar/data/83246/..." }
```

Every extra you don't enable returns `"Not Requested"` instead of an empty field, and data a filing genuinely doesn't have returns `"N/A"`. You always know why a field is empty, never guess.

### ✨ Why choose this Actor

- **Insider trades actually parsed, not just linked.** Most competitors give you a list of Form 4 filings; this Actor opens the XML and returns who bought or sold, how many shares, and at what price.
- **Financial time series, not a document dump.** Pull XBRL-reported revenue, net income and other concepts as clean numbers with real periods, no PDF/HTML parsing on your end.
- **Industry peer benchmarking built in.** See how a company's own reported numbers stack up against every other real company reporting the same concept in the same fiscal year, straight from SEC's own XBRL Frames data.
- **Full-text search across every filer**, independent of picking a specific company first, useful for finding every company that mentions a specific risk or event.
- **SEC's own data, respectfully accessed.** Uses the descriptive User-Agent SEC's own fair-access policy asks for, not a workaround.

### 📈 How it compares to alternatives

Measured against the closest published SEC EDGAR actors on the Apify Store:

| Actor | Primary price | Billable events |
|---|---|---|
| Free/no pricing set (22 users/30d) | Free | 1 |
| AI-enriched competitor (7 users/30d) | $0.40 / 1,000 | 9, several AI-generated (summaries, risk-factor diffs) |
| Niche form-type scraper (10 users/30d) | $3.50 / 1,000 | 1 |
| **This Actor** | $4.00 / 1,000 | **5** (filing, insider transaction, financial fact, peer benchmark, search hit), all raw SEC source data, none inferred |

### 🚀 How to use

1. Create a free [Apify account](https://console.apify.com). New accounts get $5 in free credit.
2. Open the SEC EDGAR Filings Scraper and enter a ticker (e.g. "AAPL") or CIK, or a full-text search query.
3. Toggle on Insider transactions and/or Financial facts if you need them.
4. Click **Start** and wait for the run to finish.
5. Download your data as CSV, Excel, JSON or XML, or pull it via the API.

### 💼 Business use cases

**Investment research & hedge funds**
Track insider buying and selling activity across a watchlist of tickers, or pull financial time series for screening models.

**Compliance & legal**
Monitor a company's filing history for new disclosures, or search across all filers for a specific risk disclosure or event.

**Fintech & data products**
Feed structured SEC data into a dashboard or research tool without maintaining your own EDGAR integration.

**Journalism & research**
Full-text search across every company's filings to find who's disclosing a specific risk, technology, or event.

### 🔌 Automating SEC EDGAR Filings Scraper

Connect this Actor to **Make**, **Zapier**, **Slack** or **Airbyte** to push new filings or insider trades into a spreadsheet, database or channel automatically. Schedule a daily run per ticker to catch new Form 4s the day they're filed.

### 🌟 Beyond business use cases

**Research:** academic finance and accounting research using real filing and XBRL data.
**Personal projects:** track insider trading on stocks you follow.
**Non-profit:** government-transparency and accountability projects tracking corporate disclosures.
**Experimentation:** test financial prediction or NLP models against real structured filing data.

### 🤖 Ask an AI assistant about this scraper

Paste this Actor's Store page into ChatGPT, Claude or Perplexity and ask: "Does this SEC EDGAR scraper parse the actual insider trading numbers from Form 4, or just link to the filing?" The README and input schema are structured so AI assistants can answer accurately from the page alone.

### ❓ Frequently Asked Questions

**Does this actually parse Form 4 data, or just list the filings?**
It parses the raw XML: reporting owner, transaction code (buy/sell), shares, price per share, and shares owned after the transaction. Verified against real Apple filings.

**What financial concepts can I pull?**
Any SEC us-gaap XBRL concept name (Revenues, NetIncomeLoss, Assets, Liabilities, StockholdersEquity, EarningsPerShareBasic are prefilled). Check a company's own `companyfacts` API if you need an exact tag not in the default list.

**Can I search for a topic without knowing which company filed about it?**
Yes. Use Full-text search query with an optional form-type filter, independent of the Tickers field.

**Do I need a login or API key for SEC EDGAR?**
No. Every field comes from SEC's own public API; no login or session required anywhere.

**Why does full-text search sometimes return old filings?**
The search covers SEC's entire historical archive by default; there's no date-range filter in this version since SEC's own date-range parameters returned server errors in testing. Narrow with a more specific query or a form-type filter instead.

**What happens if a ticker doesn't resolve?**
The Actor logs a warning and skips it rather than failing the whole run. Use the exact ticker symbol, or a CIK number directly if the name lookup doesn't find it.

**How fresh is the data?**
As fresh as SEC EDGAR itself, filings typically appear within minutes of being filed with the SEC.

**Why does a peer benchmark sometimes show older years than expected?**
The benchmark uses the most recent annual period your company actually reports under that exact XBRL concept name. Companies sometimes migrate to a more specific concept (for example, most large filers moved from the generic `Revenues` tag to `RevenueFromContractWithCustomerExcludingAssessedTax` around the 2018-2019 adoption of the ASC 606 accounting standard), which can make an older, more generic tag look like it "stopped" even though the company still reports the underlying number under its newer tag.

### 🔌 Integrate with any app

Every run's output is available as CSV, Excel, JSON or XML, or through Apify's API and client libraries for Python and JavaScript.

### 🔗 Recommended Actors

Browse the rest of the [PunkRecordsData](https://apify.com/punkrecordsdata) catalog for more scrapers covering sports data, prediction markets, remote jobs and social media intelligence.

> 💡 **Pro Tip:** browse the complete [PunkRecordsData collection](https://apify.com/punkrecordsdata).

**🆘 Need Help?** contact.punkrecordsdata@gmail.com

> **⚠️ Disclaimer:** This is an independent tool, not affiliated with, endorsed by, or sponsored by the U.S. Securities and Exchange Commission. It collects only publicly available filing data from SEC EDGAR.

# Actor input Schema

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

Stock tickers (e.g. "AAPL") or company names to look up. Resolved against SEC's own ticker list.

## `searchQuery` (type: `string`):

Search the text of every EDGAR filing for this phrase, across ALL companies, independent of Tickers above. Leave empty to skip. Billed per hit as search-hit-record.

## `searchForms` (type: `array`):

Only used with Full-text search query. Restrict the search to these form types (e.g. "10-K"). Leave empty for all forms.

## `maxSearchHits` (type: `integer`):

Maximum number of full-text search hits to deliver.

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

SEC Central Index Key numbers, if you already know them. Bypasses the ticker lookup. Any digit count accepted, zero-padded automatically.

## `forms` (type: `array`):

Only keep filings of these form types (e.g. "10-K", "10-Q", "8-K", "4"). Leave empty for every form type. SEC defines hundreds of form codes; check a company's own EDGAR page if unsure which ones it files.

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

Maximum number of recent filings to fetch per company, most recent first.

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

Maximum number of filing rows to deliver in total. Free users: limited to 10 (preview). Paid users: optional, max 1,000,000.

## `includeInsiderTransactions` (type: `boolean`):

Parse the reporting owner, transaction code, shares and price from Form 3/4/5 filings. Billed per parsed transaction as insider-transaction-record.

## `includeFinancialFacts` (type: `boolean`):

Pull structured financial data (revenue, net income, assets, etc.) reported in XBRL. Billed per financial concept per company as financial-fact-record — 6 concepts on one company is 6 events, only for concepts the company actually reports.

## `financialConcepts` (type: `array`):

Which XBRL us-gaap concepts to pull when Financial facts is on. Uses SEC's own concept names — check a company's companyfacts API if you need an exact tag not listed here.

## `includePeerBenchmark` (type: `boolean`):

For each financial concept, pull every other real company's reported value for the same concept in the same fiscal year (SEC's XBRL Frames API), sorted highest to lowest. Requires Financial facts to also be on. Billed per peer company as peer-benchmark-record.

## `maxPeers` (type: `integer`):

How many peer companies to include per concept when Industry peer benchmark is on.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "maxSearchHits": 20,
  "maxPerCompany": 50,
  "maxItems": 100,
  "includeInsiderTransactions": false,
  "includeFinancialFacts": false,
  "financialConcepts": [
    "Revenues",
    "NetIncomeLoss",
    "Assets",
    "Liabilities",
    "StockholdersEquity",
    "EarningsPerShareBasic"
  ],
  "includePeerBenchmark": false,
  "maxPeers": 20
}
```

# Actor output Schema

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

Key fields: company, form, filing date, document URL

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

Complete dataset with every field, including parsed insider transactions and financial time series

# 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"
    ],
    "maxSearchHits": 20,
    "maxPerCompany": 50,
    "maxItems": 100,
    "financialConcepts": [
        "Revenues",
        "NetIncomeLoss",
        "Assets",
        "Liabilities",
        "StockholdersEquity",
        "EarningsPerShareBasic"
    ],
    "maxPeers": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("punkrecordsdata/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"],
    "maxSearchHits": 20,
    "maxPerCompany": 50,
    "maxItems": 100,
    "financialConcepts": [
        "Revenues",
        "NetIncomeLoss",
        "Assets",
        "Liabilities",
        "StockholdersEquity",
        "EarningsPerShareBasic",
    ],
    "maxPeers": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("punkrecordsdata/sec-edgar-filings-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 '{
  "tickers": [
    "AAPL"
  ],
  "maxSearchHits": 20,
  "maxPerCompany": 50,
  "maxItems": 100,
  "financialConcepts": [
    "Revenues",
    "NetIncomeLoss",
    "Assets",
    "Liabilities",
    "StockholdersEquity",
    "EarningsPerShareBasic"
  ],
  "maxPeers": 20
}' |
apify call punkrecordsdata/sec-edgar-filings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,punkrecordsdata/sec-edgar-filings-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/lekiezv1MKhOSvhJP/builds/YsyB6AsbYTesPSzJT/openapi.json