# SEC EDGAR Filings Scraper — Companies, Forms, Full-Text (`chorelet/sec-edgar-scraper`) Actor

Every SEC filing of a company by ticker, CIK or name, or every filing that mentions your phrase — 10-K, 10-Q, 8-K, S-1, Form 4, 13F and the rest — with dates, form items, EDGAR links and optional full document text.

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

## Pricing

from $0.70 / 1,000 filings

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

## SEC EDGAR Filings Scraper — Companies, Forms, Full-Text

Every filing a US public company has submitted to the SEC, or every filing that mentions your phrase — as JSON, CSV or Excel, or straight into your own tools through the API.

Two ways to ask:

- **By company** — paste tickers (`AAPL`), CIK numbers (`0000320193`) or registrant names. You get the company's whole submission history, newest first, filtered by form type and date.
- **By phrase** — search the text of every filing since 2001: `"going concern"`, `"cybersecurity incident"`, a product name, a person. You get the filings from every company that used the words.

Both read EDGAR's own public APIs — no key, no login, no scraping of HTML — at the request rate the SEC asks automated clients to keep.

### Why this Actor

- **Both ways of asking, one Actor.** A company's full filing history *and* full-text search across every filer since 2001 — most tools do one or the other.
- **Usable rows, not ids.** Ticker, CIK, SIC industry, state, form items and direct EDGAR links come with every filing, so nothing needs a second lookup.
- **The text, when you want it.** Turn on document text and each filing arrives as plain text ready for an LLM, a keyword scan or a diff — charged only for the documents you actually fetch.
- **Polite by design.** EDGAR's published rate limits and a descriptive User-Agent, so runs do not get your IP blocked the way a naive scraper does.

### Sample output

One item of the dataset (long values shortened):

```json
{
  "company": "Astrana Health, Inc.",
  "ticker": "ASTH",
  "form": "8-K",
  "filingDate": "2026-09-23",
  "reportDate": "2026-09-22",
  "items": [
    "1.05"
  ],
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1083446/000110465926109813/0001104659-26-109813-index.htm",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/1083446/000110465926109813/asth-20260922x8k.htm"
}
```

### What you get

- Company, ticker, CIK, SIC industry and state, so filings are usable without a second lookup
- Form type and, for 8-K, the item numbers that say what happened (`2.02` results, `5.02` officer change, `1.05` cybersecurity incident)
- Filing date, period covered, acceptance timestamp, accession and file numbers
- Direct links to the EDGAR filing index and to the primary document
- Optional **plain text of the document itself**, ready for an LLM or a keyword scan
- Monitored daily

### Input

- **Companies** — tickers, CIKs or names. A CIK works even for companies with no ticker (funds, private filers, foreign issuers).
- **Full-text search** — one or more phrases. Quote them for an exact match; without quotes EDGAR matches the words separately and returns far more.
- **Form types** — `10-K`, `10-Q`, `8-K`, `S-1`, `4`, `13F-HR`, `SC 13D`, … Amendments (`8-K/A`) come along automatically.
- **Filed after / Filed before**, **Max filings per company or query**, **Include document text**, **Max characters of document text**.

### Limits and notes

- Full-text search covers filings **from 2001 onwards** — that is EDGAR's own index, not a limit of this Actor. The per-company path goes back to whatever EDGAR holds for that filer.
- Search results come back in EDGAR's relevance order inside your date range; the per-company path is strictly newest first.
- One search can match hundreds of thousands of filings — narrow it with a date range and form types rather than raising the limit.
- Document text is the filing's primary document. For a 10-K that can be megabytes, so it is cut at the length you set and charged separately.
- The SEC asks automated clients to identify themselves and stay under ten requests a second; the Actor does both, which is why a run of thousands of filings takes minutes rather than seconds.

### Input example

```json
{
  "companies": [
    "AAPL",
    "NVDA"
  ],
  "formTypes": [
    "8-K"
  ],
  "filedAfter": "30 days",
  "maxFilings": 50,
  "includeDocumentText": false,
  "maxTextChars": 200000
}
```

### How much does it cost?

Pay per filing — no subscription, no minimum, no charge for platform usage.

| Volume | Price |
|---|---|
| 1,000 filings | $1.00 (+ $2.00 with `document`) |
| 10,000 filings | $10.00 (+ $20.00 with `document`) |
| 100,000 filings | $100.00 (+ $200.00 with `document`) |

The Apify **free plan includes $5 of usage every month** — about 5,000 filings with this Actor, no card needed. Nothing else is charged: platform usage is included in the price, and Apify Bronze, Silver and Gold subscribers get 10%, 20% and 30% off these prices.

### Use it from code, n8n, Make, Zapier or an AI agent

Run the Actor and download the dataset in one call (JSON by default; add `&format=csv` or `xlsx`):

```bash
curl -X POST "https://api.apify.com/v2/acts/chorelet~sec-edgar-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["AAPL", "NVDA"], "formTypes": ["8-K"], "filedAfter": "30 days", "maxFilings": 50, "includeDocumentText": false, "maxTextChars": 200000}'
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("chorelet/sec-edgar-scraper").call(run_input={"companies": ["AAPL", "NVDA"], "formTypes": ["8-K"], "filedAfter": "30 days", "maxFilings": 50, "includeDocumentText": false, "maxTextChars": 200000})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

- **n8n, Make, Zapier** — use the Apify node/module: run the Actor, then "get dataset items".
- **Google Sheets, Slack, webhooks** — add an integration on the run's *Integrations* tab.
- **AI agents** — the Actor is available as a tool through the Apify MCP server; the dataset schema describes every field for the model.
- **Schedules** — run it hourly, daily or weekly from the *Schedules* tab.

### FAQ

**Do I need an SEC API key?**

No. EDGAR publishes both the submissions API and full-text search openly. The SEC only asks that automated clients identify themselves and keep under ten requests a second, which the Actor does.

**How far back does the search go?**

Full-text search covers filings from 2001 onwards — that is EDGAR's index. A company's submission history goes back as far as EDGAR holds it for that filer.

**How do I watch for new filings?**

Give the companies (or the phrase), set *Filed after* to `1 day` and schedule the Actor daily. Each run returns only what is new, so a watchlist of 50 companies costs cents a day.

**What is in the document text?**

The filing's primary document — the 10-K, the 8-K body, the press release exhibit — converted from HTML to plain text and cut at the length you choose. Exhibits other than the primary document are not fetched.

**Can I get XBRL financial figures?**

Not in this Actor: it returns filings and their text. The `isXBRL` flag tells you which filings carry structured data, and the EDGAR company-facts API is the place to pull the numbers from.

### Support

Questions, missing fields or a source that changed? Open an issue on the *Issues* tab or write to support@chorelet.app — problems are usually fixed within a day, and the Actor is checked every morning by an automated test run. If the Actor saved you time, a short review on its Store page helps other people find it.

# Actor input Schema

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

Tickers (`AAPL`), CIK numbers (`0000320193` or `320193`) or registrant names (`NVIDIA CORP`). Every filing the company has on EDGAR, newest first.

## `queries` (type: `array`):

Search the text of filings from 2001 on, e.g. `"artificial intelligence"`, `going concern`, `cybersecurity incident`. Quotes match a phrase. Returns filings from every company that used the words.

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

Keep only these forms, e.g. `10-K`, `10-Q`, `8-K`, `S-1`, `4`, `13F-HR`, `SC 13D`. Amendments (`8-K/A`) are included automatically. Empty = every form.

## `filedAfter` (type: `string`):

Absolute date `2026-01-01` or relative `30 days`, `6 months`, `1 year`. Use it for daily runs that return only new filings.

## `filedBefore` (type: `string`):

Optional upper bound, `YYYY-MM-DD`.

## `maxFilings` (type: `integer`):

Newest first.

## `includeDocumentText` (type: `boolean`):

Download the filing's primary document and store it as plain text. Charged separately — a 10-K is a big document, so start with it off if you only need the index.

## `maxTextChars` (type: `integer`):

Longer documents are cut at this length.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "NVDA"
  ],
  "queries": [],
  "formTypes": [
    "8-K"
  ],
  "filedAfter": "30 days",
  "maxFilings": 50,
  "includeDocumentText": false,
  "maxTextChars": 200000
}
```

# Actor output Schema

## `filings` (type: `string`):

All filings — items of the default dataset. Use ?format=csv or xlsx on this URL for spreadsheets.

## `summary` (type: `string`):

Filings per company and query, documents fetched, and errors.

# 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",
        "NVDA"
    ],
    "queries": [],
    "formTypes": [
        "8-K"
    ],
    "filedAfter": "30 days",
    "filedBefore": "",
    "maxFilings": 50,
    "includeDocumentText": false,
    "maxTextChars": 200000
};

// Run the Actor and wait for it to finish
const run = await client.actor("chorelet/sec-edgar-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 = {
    "companies": [
        "AAPL",
        "NVDA",
    ],
    "queries": [],
    "formTypes": ["8-K"],
    "filedAfter": "30 days",
    "filedBefore": "",
    "maxFilings": 50,
    "includeDocumentText": False,
    "maxTextChars": 200000,
}

# Run the Actor and wait for it to finish
run = client.actor("chorelet/sec-edgar-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 '{
  "companies": [
    "AAPL",
    "NVDA"
  ],
  "queries": [],
  "formTypes": [
    "8-K"
  ],
  "filedAfter": "30 days",
  "filedBefore": "",
  "maxFilings": 50,
  "includeDocumentText": false,
  "maxTextChars": 200000
}' |
apify call chorelet/sec-edgar-scraper --silent --output-dataset

```

## MCP server setup

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