# SEC Filings Scraper: 10-K, 8-K, Full-Text Search (`automation_craft/sec-filings-scraper`) Actor

Pull SEC filings by ticker, CIK, form, date or EDGAR full-text search past its 10,000 hit cap, no login or API key: 1,000 filings in 15 seconds. Rows hold form, filed and accepted time, period, 8-K items, documents, company profile; text and XBRL figures as add-ons. JSON or CSV, pay per filing.

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

## Pricing

from $0.10 / 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 Filings Scraper: 10-K, 8-K, Full-Text Search

**SEC filings scraper** for 10-K, 10-Q, 8-K and every other EDGAR form: one row per filing, by ticker, CIK, company name, accession number, full-text search or date window, with no login, no API key and no proxy setting.

Each Filing row carries the form and what it is, the filing date and the acceptance time, the report period (with fiscal year and quarter when the filer's fiscal year end is known), the 8-K item codes with their names, the filer's industry (SIC), state of incorporation, tickers and exchanges, file and film number, size, the links to the index page, the folder, the full submission, the main document and the inline XBRL viewer, and a one sentence summary built from those fields. Two paid add-ons read further: the main document as plain text with its report sections, and the XBRL figures a 10-K, 10-Q, 20-F or 40-F reported for its own period. Use it as an SEC filings API for your own code (curl, Node and Python examples below), as a scheduled feed of new 8-Ks, or as a CSV export for a spreadsheet.

#### Why this one

- **Pay per filing delivered, plus a small start fee per run.** One Filing event per filing row. Company profile rows, filing details, status rows and the run summary are free. An unknown ticker, CIK or name, a filing that is not found, a filing your filters leave out and a filing found twice cost nothing, and every miss is named in a free row.
- **Full-text search past the 10,000 result cap.** The SEC's full-text search lists at most 10,000 results per query. Newest first, this Actor splits a search by date and, for one large day, by form, and reads every part. Measured on 2026-11-01, the parts of one day with more than 10,000 results added up to the day's total (10,319 results).
- **Complete company histories.** Each company's whole filer record is read, its older pages included, back to 1994 for the oldest filers. A date window reads only the pages it reaches.
- **Every filing of a date window.** Leave the targets empty and you get every filing of the last 7 days (or your window) of the forms you choose. Ready-made searches cover going concern, material weakness, restatement, cybersecurity incident, layoffs, guidance withdrawn, CEO departure, chapter 11, share buyback, activist investor, artificial intelligence and tariffs.
- **Screen with several searches at once.** Give several queries or presets: each filing is one row that lists every one that found it (`matchedQueries`, `matchedPresets`), charged once, and every row carries a materiality, novelty and signal score from published weights with the tokens that drove them. The run also stores its filings ranked by signal score.
- **8-K items with names, 16 event categories and risk flags.** Earnings, leadership change, cybersecurity incident, auditor change and the rest are filters and fields of the row, read from the SEC's own item codes and form types.
- **Fast and polite.** On the platform at 256 MB, the newest 1,000 filings of the window 2026-10-22 to 2026-11-01 took 15 seconds, and 989 filings of 20 large companies since 2024 with their 20 company rows took 23 seconds (2026-11-01 UTC). The SEC is asked at most 5 times per second, half its published limit of 10, with a declared User-Agent.

### Quick start

1. For one company, put its ticker into **Tickers** (the prefill is `AAPL` with the form types 10-K, 10-Q and 8-K). For a filer without a ticker, use **CIK numbers**.
2. Or put words or "exact phrases" into **Full-text search queries**, or pick **Ready-made searches**.
3. Or leave every target empty for every filing of the last 7 days; set **Form types**, **Filed from** and **Filed until** (YYYY-MM-DD) or **Days back** to change what is read.
4. Optional: narrow with **8-K item codes** or **8-K event categories**, and turn on **Filing details** (free), **Document text** or **Financial data** (paid add-ons).
5. Set **Maximum filings** (the prefill is 10; 100 is used when the field is left out) and click **Start**. Rows appear in the Dataset tab; export JSON, CSV or Excel, or read them through the API.

### What you get

Every row has a `type`: `filing` (the paid row), `company` (a free profile of each company read by ticker, CIK or name), `status` (free, one per kind of miss or input problem) and `summary` (free, the last row of every run).

#### Filing row

One row per filing, 62 fields. The blocks:

- **Identity:** `accessionNumber`, `form`, `formDescription`, `rootForm`, `isAmendment`, `filedAt`, `acceptedAt`, `reportDate`, `fiscalYear`, `fiscalPeriod`, `act`, `fileNumber`, `filmNumber`, `sizeBytes`.
- **Filer:** `cik`, `companyName`, `tickers`, `exchanges`, `filers` (`cik`, `name`, `role`), `sic`, `sicDescription`, `stateOfIncorporation`, `fiscalYearEnd`, `entityType`, `businessLocation`.
- **Events:** `items`, `itemDescriptions`, `eventCategories`, `riskFlags`.
- **Documents and links:** `isXBRL`, `isInlineXBRL`, `primaryDocument`, `primaryDocDescription`, `filingIndexUrl`, `filingFolderUrl`, `fullSubmissionUrl`, `primaryDocumentUrl`, `inlineXbrlViewerUrl`, `companyFilingsUrl`.
- **Search:** `searchQuery` (the first query that found the filing), `matchedQueries` (every query and preset of the run that found it), `matchedPresets`, `matchedDocuments` (`fileName`, `type`, `description`, `score`) and `relevanceScore`, on rows found by a full-text search.
- **Signals:** `materialityScore`, `materialityLevel`, `noveltyScore`, `noveltyLevel`, `noveltyBasis`, `priorSimilarInRun`, `signalScore`, `signalDrivers`, `alertSeverity`, on every filing row (see Signals below).
- **Add-ons:** `filingDetails`, `documentText`, `financialData`, `addOnNotes` (why an add-on was left off a row).
- **Run:** `summary`, `source` (`filer_record`, `full_text_search` or `index_page`), `subjectKey`, `scrapedAt`, `type`.

`riskFlags` names what the SEC's codes say: `bankruptcy`, `cybersecurity_incident`, `material_impairment`, `delisting_notice`, `auditor_change`, `non_reliance_restatement`, `change_in_control`, `officer_or_director_change` from 8-K items, and `late_annual_report`, `late_quarterly_report`, `deregistration`, `delisting` from the form type.

#### Fill rates

Measured on two runs of this Actor on the platform (2026-11-01 UTC). **Company mode rows (989)**: the filings since 2024-01-01 of 20 large companies, up to 50 each (by form with its amendments: 480 Form 4, 114 Form 144, 87 8-K, 52 424B2, 33 10-Q and 223 of 32 other forms). **Date window rows (1,000)**: the newest 1,000 filings of the window 2026-10-22 to 2026-11-01, without filing details (335 Schedule 13G, 261 Form 4, 168 8-K, 103 6-K, 91 10-Q and 42 of 5 other forms). A field counts as filled when it is not null, not an empty text and not an empty list. The rates follow the mix of forms: a Form 4 has no report period and no 8-K items.

| Field | What it holds | Company mode rows (989) | Date window rows (1,000) |
|---|---|---|---|
| `form`, `filedAt`, `companyName`, `primaryDocument`, `primaryDocumentUrl` | Form, filing date, filer, main document | 100% | 100% |
| `acceptedAt` | Acceptance time (UTC) | 100% | 0% (100% with filing details) |
| `sizeBytes` | Size of the whole submission | 100% | 0% (100% with filing details) |
| `isInlineXBRL` | Inline XBRL flag | 100% | 0% (100% with filing details) |
| `isXBRL` | XBRL flag | 100% | 0% |
| `reportDate` | Report period, all rows | 66.9% | 64.4% |
| `reportDate` | Report period, 10-K and 10-Q rows | 100% | 100% |
| `fiscalPeriod` | `FY`, `Q1` to `Q3`, 10-K and 10-Q rows | 100% | 0% |
| `items` | 8-K item codes, 8-K rows | 100% | 100% |
| `tickers` | Tickers of the filer | 100% | 70.4% |
| `sic` | Industry code | 100% | 39.1% |
| `stateOfIncorporation` | State of incorporation | 100% | 66.8% |
| `fiscalYearEnd` | Fiscal year end (MMDD) | 100% | 0% |
| `businessLocation` | City and state of the filer's business address | 100% | 39% |
| `act` | Securities act | 49% | 0% |
| `fileNumber`, `filmNumber` | SEC file and film number | 49.2%, 48.9% | 39.7%, 39.7% |
| `primaryDocDescription` | Description of the main document | 81.8% | 58.6% |

The "with filing details" figures are from a run of 30 8-K filings of a 5 day window with `includeFilingDetails` on (2026-11-01 UTC). The filers of a Form 4 or a Schedule 13G are often people, who have no industry code, no tickers and no fiscal year end. Since 2026-11-06 the business location of every filer is delivered as the SEC serves it (the figures above were measured before, when it was left out for a filer without an industry code); for many people the SEC serves none.

Example Filing row (real run 5pASsU42HyuViOnSf of 2026-11-02, the 20 company bulk run; shortened: 42 of its 62 fields):

```json
{
  "type": "filing",
  "accessionNumber": "0000320193-26-000018",
  "form": "8-K",
  "formDescription": "Current report",
  "isAmendment": false,
  "filedAt": "2026-07-30",
  "acceptedAt": "2026-07-30T20:30:28.000Z",
  "reportDate": "2026-07-30",
  "cik": "0000320193",
  "companyName": "Apple Inc.",
  "tickers": ["AAPL"],
  "exchanges": ["Nasdaq"],
  "sic": "3571",
  "sicDescription": "Electronic Computers",
  "stateOfIncorporation": "CA",
  "fiscalYearEnd": "0926",
  "businessLocation": "CUPERTINO, CA",
  "items": ["2.02", "9.01"],
  "itemDescriptions": ["Results of Operations and Financial Condition", "Financial Statements and Exhibits"],
  "eventCategories": ["earnings"],
  "riskFlags": [],
  "materialityScore": 35,
  "materialityLevel": "medium",
  "noveltyScore": 99,
  "noveltyLevel": "high",
  "noveltyBasis": 34,
  "priorSimilarInRun": 0,
  "signalScore": 61,
  "signalDrivers": ["high_novelty", "first_of_its_kind_in_run"],
  "alertSeverity": "medium",
  "act": "34",
  "fileNumber": "001-36743",
  "filmNumber": "261223821",
  "sizeBytes": 417360,
  "isXBRL": true,
  "isInlineXBRL": true,
  "primaryDocument": "aapl-20260730.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/0000320193-26-000018-index.htm",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/aapl-20260730.htm",
  "summary": "Apple Inc. filed an 8-K (current report) on 2026-07-30 for the period ending 2026-07-30. Items: 2.02 Results of Operations and Financial Condition; 9.01 Financial Statements and Exhibits.",
  "source": "filer_record",
  "scrapedAt": "2026-11-02T03:37:10.295Z"
}
```

#### Signals

Every filing row is scored by fixed rules, the same on every run, with nothing read from the filing's text:

- **`materialityScore`** (0 to 100): the form's weight plus the weight of every 8-K item it states plus the weight of every preset it matched, at most 100. Forms (with their amendments): 10-K, 20-F and 40-F 30; 10-Q and 8-K 20; 6-K 15; S-1, F-1, S-4 and F-4 25; 424B4 15; Schedule 13D 35, Schedule 13G 15; tender offers (SC TO-T, SC 14D9) 35; proxy contest DEFC14A 40, PREC14A 35; DEF 14A 15, PRE 14A 10; NT 10-K and NT 20-F 40, NT 10-Q 35; 15-12B, 15-12G, 25 and 25-NSE 40, 15-15D 35; Form 4 10; Forms 3, 5, 144 and D 5; any other form 10. 8-K items: 1.03 bankruptcy 60, 4.02 non reliance 55, 1.05 cybersecurity 50, 3.01 delisting 45, 5.01 change in control 40, 2.06 impairment 35, 4.01 auditor change 35, 2.01 and 2.05 30, 1.04 30, 2.04 and 5.02 25, 1.01 and 1.02 20, 5.06 20, 2.02 and 2.03 15, 3.03 15, 3.02, 5.03, 5.04 and 5.05 10, 5.07, 5.08, 7.01 and 8.01 5. Presets: bankruptcy 40, going concern 35, material weakness 30, restatement 30, cybersecurity incident 30, guidance withdrawn, CEO departure and activist investor 20, layoffs 15, share buyback and tariffs 5. `materialityLevel`: `critical` from 75, `high` from 50, `medium` from 30, else `low`.
- **`noveltyScore`** (0 to 100): how rare the filing is among the filings this run delivered before it: 40 x (1 - the share of those with its form) + 40 x (1 - the share of those with its event kind) + 20 when the same company has no filing of that kind earlier in the run. The event kind is the 8-K event category (the rarest one), else the form. `noveltyBasis` says how many filings it was compared with; the first row of a run has none, so its novelty is null. `noveltyLevel`: `high` from 75, `medium` from 45, else `low`. `priorSimilarInRun` counts the same company's earlier filings of that kind in the run.
- **`signalScore`**: 0.6 x materiality + 0.4 x novelty, rounded (materiality alone on the first row). **`signalDrivers`** lists why: the row's `riskFlags`, presets weighted 20 or more, `high_materiality`, `high_novelty`, `first_of_its_kind_in_run`. **`alertSeverity`** is the materiality level (`critical`, `high`, `medium`), `low` for a low row with a risk flag, else `none`.

The dataset keeps the order the filings were read (newest first). The 1,000 highest signal scores of the run, highest first, are stored in the run's key-value store as `SIGNAL_RANKING` (`rank`, `signalScore`, `materialityLevel`, `noveltyLevel`, `filedAt`, `form`, `companyName`, `cik`, `accessionNumber`, `filingIndexUrl`), linked from the run's output and named in the summary row.

#### Company row (free)

With `includeCompanyRows` on (the default), every company read by ticker, CIK or name gets one free `company` row: `cik`, `name`, `entityType`, `tickers`, `exchanges`, `sic`, `sicDescription`, `industryOffice`, `category` (for example `Large accelerated filer`), `ein`, `stateOfIncorporation`, `stateOfIncorporationDescription`, `fiscalYearEnd`, `phone`, `website`, `investorWebsite`, `businessAddress`, `mailingAddress`, `formerNames` (with `from` and `to` dates), `isInsiderFiler`, `hasInsiderFilingsAsIssuer`, `personalDataWithheld`, `filingsOnRecord`, `olderFilingPages`, `companyFilingsUrl`, `subjectKey`. For Apple in the run above: `filingsOnRecord` 2271, phone `(408) 996-1010`, three former names back to `APPLE COMPUTER INC` (1994-01-26). Every filer's addresses, phone and EIN are delivered as the SEC serves them, a filer without an industry code (who may be a person) included; `personalDataWithheld` stays in the row and is always null.

#### Four ways to ask

- **Companies** (`tickers`, `ciks`, `companyNames`): each company's filer record, newest first, with its older pages as far as the date window reaches. A ticker is looked up in the SEC's list of listed tickers; a name is used only when exactly one listed company carries it. For a list of two or more companies with a date window from 2001 on, each batch of 100 companies is first checked with one page of the full-text index; when that page holds the batch's whole answer (100 filings or fewer in the window), only the companies it lists are read, otherwise every company of the batch is read.
- **Filings** (`accessionNumbers`): each filing's own index page, by accession number or EDGAR link, delivered as asked (date, form, item and size filters cannot be combined with them).
- **Full-text search** (`searchQueries`, `searchPresets`): the SEC's full-text search with its own syntax ("exact phrase", OR, a leading minus to exclude), optionally within companies given by `tickers` or `ciks`, newest first or by relevance. One row per filing, with the documents that matched; a filing that several queries or presets find is one row that lists them all in `matchedQueries`.
- **Date window** (no target): every filing of the window, newest first, from the full-text index (one search per part, no query).

#### Add-ons

- **Filing details (free, `includeFilingDetails`).** Reads each filing's index page into `filingDetails`: every document and exhibit (`sequence`, `description`, `name`, `type`, `sizeBytes`, `url`, `group`), every filer with its role (`filer`, `issuer`, `subject`, `reporting`, `filed_by`) and its `sic`, `ein`, `stateOfIncorporation`, `fiscalYearEnd`, `fileNumber`, `filmNumber`, `act` and `addresses`, and `totalSizeBytes`. It also fills `acceptedAt`, `sizeBytes` and `isInlineXBRL` on search and window rows. One extra request per filing makes a run slower.
- **Document text (paid, `includeDocumentText`).** Reads the main document into `documentText`: `text` (up to `maxTextCharacters`, 200,000 by default), `characters`, `totalCharacters`, `truncated`, and `sections` (`item`, `title`, `characters`, `text`) for 10-K, 10-Q, 20-F and 40-F reports (Item 1A Risk Factors, Item 7 MD\&A and the rest) and the items of an 8-K or 6-K. For an 8-K or 6-K it adds the press release (exhibit 99.1) in `pressRelease`, the sentences that state an outlook with a number and a period in `guidanceSentences`, and a count of finance words in `sentiment` (`words`, `positive`, `negative`, `uncertain`, `net`), from fixed word lists. For a Schedule 13D or 13G filed as XML it reads the stake of each reporting person into `ownership` (`reportingPersons` with `aggregateAmountOwned`, `percentOfClass`, sole and shared voting and dispositive power). With `textChunkSize` the text is also cut into `chunks` at paragraph or sentence ends, for retrieval and AI pipelines.
- **Financial data (paid, `includeFinancialData`).** Attaches to a 10-K, 10-Q, 20-F or 40-F the XBRL figures it reported for its own period, in `financialData` (`taxonomy`, `concept`, `label`, `value`, `unit`, `periodStart`, `periodEnd`, `fiscalYear`, `fiscalPeriod`, `frame`): revenue, net income, operating income, earnings per share, assets, liabilities, equity, cash, operating cash flow and long-term debt (US GAAP; the IFRS set for a 20-F or 40-F without US GAAP figures), plus shares outstanding from the cover, or the concepts you list in `financialConcepts`. A 10-Q gives its quarter and its year to date.

A real Financial data entry (Apple's 10-Q for the quarter ended 2026-06-27, platform run of 2026-11-01):

```json
{"taxonomy": "us-gaap", "concept": "RevenueFromContractWithCustomerExcludingAssessedTax", "label": "Revenue from Contract with Customer, Excluding Assessed Tax", "value": 109417000000, "unit": "USD", "periodStart": "2026-03-29", "periodEnd": "2026-06-27", "fiscalYear": 2026, "fiscalPeriod": "Q3", "frame": "CY2026Q2"}
```

An add-on that cannot deliver for a row (a form without XBRL figures, a document that cannot be read, no room left under your charge limit) is left off that row with a note in `addOnNotes` and is not charged.

#### Status rows (free)

Every input problem and every miss gets a free `type: "status"` row with `scope`, `status` and a `message` in plain words. Misses of one kind share one row with the `items` and their `count`.

| `status` | `scope` | What it means |
|---|---|---|
| `invalid_input` | `input` | A setting that cannot be used (a date, a filter value, a cap, an unknown field name, own proxy URLs). The run stops before any paid work; only the run's start fee is charged. |
| `unusable_item` | `input` | Items of a target list that are not a ticker, CIK, name, accession number or query; their `positions` are listed and the other items run. |
| `not_searchable` | `input` | Form types with a slash other than the amendment mark, which the full-text search cannot filter on. |
| `unknown_ticker` | `miss` | Tickers that are not in the SEC's list of listed tickers. |
| `unknown_cik` | `miss` | CIKs the SEC does not know. |
| `name_not_found` | `miss` | Names that match no listed company name. |
| `name_ambiguous_or_inexact` | `name` | Names no listed company carries exactly; `names` lists each one (`input`, `position`) with up to 10 near `candidates` (`cik`, `name`, `ticker`, `exchange`). Nothing is guessed. |
| `same_company_twice` | `miss` | A company asked twice (for example by ticker and by CIK); its filings are delivered once. |
| `accession_not_found` | `miss` | Filings not found under the CIK of their link. |
| `accession_not_found_or_agent_filed` | `miss` | Bare accession numbers not found under the CIK their first ten digits name; for a filing an agent filed, give the EDGAR link. |

A real status row (platform run of 2026-11-02; shortened: `key` and `scrapedAt` left out, two of the candidates shown):

```json
{"type": "status", "scope": "name", "status": "name_ambiguous_or_inexact", "message": "1 name(s): no listed company carries exactly this name. Run again with the CIK of the company you mean (candidates below). Nothing was charged for them.", "names": [{"input": "Apple", "position": 1, "candidates": [{"cik": "0000320193", "name": "Apple Inc.", "ticker": "AAPL", "exchange": "Nasdaq"}, {"cik": "0001418121", "name": "Apple Hospitality REIT, Inc.", "ticker": "APLE", "exchange": "NYSE"}]}], "count": 1}
```

The last row of every run is a free `type: "summary"` row: `status` (`complete`, `partial` or `invalid_input`), `mode`, `stoppedBy` (for example `max_items`, `charge_limit`, `work_allowance`, `source_unavailable`), `filingsDelivered`, `window`, `chargedEvents`, `counts`, `coverage` (per company, search or window: `status`, `delivered`, `oldestFilingDateReached`, `reason`), `sourceFailures`, `requests`, `allowance`, `signalRanking` (the ranking record, its entries and whether it was saved), `resumed` and `message`. `status` is `complete` only when nothing stopped the run and every company, search and page it had to read was read.

### How much does it cost to scrape SEC filings?

You pay per Filing row delivered plus a small start fee per run. The two paid add-ons are charged per row, only when they deliver. Company profile rows, filing details, status rows and the run summary are free.

| Event | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|
| Filing (one SEC filing delivered as a row) | $0.11 / 1,000 | $0.105 / 1,000 | $0.10 / 1,000 | $0.095 / 1,000 |
| Document text (add-on: the main document read into text) | $0.70 / 1,000 | $0.65 / 1,000 | $0.58 / 1,000 | $0.50 / 1,000 |
| Financial data (add-on: XBRL figures of the report's own period) | $0.70 / 1,000 | $0.65 / 1,000 | $0.58 / 1,000 | $0.50 / 1,000 |
| Actor start (once per run) | $0.002 | $0.002 | $0.002 | $0.002 |

Platinum and Diamond plans pay the Gold price. The Actor start event is a flat fee with no tier discount, charged once per run whatever the run delivers (it is charged per GB of memory, and this Actor runs at 256 MB).

The Store pricing card shows these same prices per 1,000 events: "$0.11 / 1,000" on the Filing row means one filing costs 0.011 cents, and "$0.70 / 1,000" on the Document text row means one document costs 0.07 cents.

Worked examples (start fee included):

| Run | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|
| A search that finds nothing | $0.002 | $0.002 | $0.002 | $0.002 |
| 10 filings (the prefill) | $0.0031 | $0.00305 | $0.003 | $0.00295 |
| 1,000 filings | $0.112 | $0.107 | $0.102 | $0.097 |
| 10,000 filings | $1.102 | $1.052 | $1.002 | $0.952 |
| 100 10-K and 10-Q filings, each with document text and financial data delivered | $0.153 | $0.1425 | $0.128 | $0.1115 |

What is free (no event other than the start fee): an invalid input, an unknown ticker, CIK or name, an ambiguous name, a filing that is not found, a filing your filters leave out, a filing found twice (by two queries, or a company asked twice), a filing past `maxFilingsPerForm`, every company row, filing details, every status row and the run summary. A document text or financial data read that delivers nothing is not charged. Rows are charged only after they are in your dataset, and your maximum charge per run is respected: a filing that does not fit is not delivered, and the summary says `stoppedBy: charge_limit`. A platform restart never charges a filing twice (the platform itself charges the start fee once more when a run is resurrected).

### Input

| Field | Default | What it does |
|---|---|---|
| `tickers` | empty (prefill `AAPL`) | Stock tickers such as `AAPL`, `MSFT` or `BRK-B` (`BRK.B` is read as `BRK-B`), matched through the SEC's list of listed tickers. |
| `ciks` | empty | SEC Central Index Keys of companies, funds or people, with or without leading zeros, or an EDGAR company link. Use a CIK for any filer without a ticker. |
| `companyNames` | empty | Names of listed companies, for example `Apple Inc.`; used only when exactly one listed company carries the name (case, punctuation and spacing aside). |
| `accessionNumbers` | empty | Filings by accession number (`0000320193-26-000011`) or EDGAR filing link, read as asked. Cannot be combined with companies or searches. |
| `searchQueries` | empty | Full-text queries in the SEC's syntax: "exact phrase", OR between alternatives, a leading minus to exclude a word. Narrow them with `tickers` or `ciks`, form types and dates. |
| `searchPresets` | none | Ready-made searches: `going_concern`, `material_weakness`, `restatement`, `cybersecurity_incident`, `layoffs`, `guidance_withdrawn`, `ceo_departure`, `bankruptcy`, `share_buyback`, `activist_investor`, `artificial_intelligence`, `tariffs`. |
| `formTypes` | every form (prefill 10-K, 10-Q, 8-K) | EDGAR form types to keep, for example `10-K`, `8-K`, `4`, `S-1`, `DEF 14A`, `SC 13D`. A form includes its amendments unless `includeAmendments` is false; `10-K/A` alone means amendments only. |
| `includeAmendments` | `true` | Keep amended filings (form types ending in /A). |
| `dateFrom`, `dateTo` | empty | First and last filing date, `YYYY-MM-DD`. Without `dateFrom`: a company's whole history, a search from 2001 on, the last 7 days for a date window. |
| `daysBack` | empty | Instead of `dateFrom`: the last N days on the SEC's calendar (US Eastern); 0 is today only. |
| `items8K` | none | Keep 8-K filings that report at least one of these items, for example `2.02`, `5.02`, `1.01`. |
| `eventCategories` | none | Groups of 8-K items: `earnings`, `material_agreement`, `mergers_acquisitions`, `bankruptcy`, `cybersecurity`, `debt_financing`, `restructuring`, `delisting`, `equity_sale`, `auditor_change`, `restatement`, `leadership_change`, `governance`, `shareholder_vote`, `regulation_fd`, `other_events`. |
| `minFilingSizeKb` | none | Keep filings whose whole submission is at least this many KB (searches and windows read each index page first). |
| `companyNameContains` | empty | Keep search and window rows where a filer's name contains this text. |
| `sortBy` | `newest` | `newest` (every match, split past 10,000) or `relevance` (the search's own score, at most 10,000 results). |
| `includeFilingDetails` | `false` | Free: documents, filer roles and the acceptance time from each filing's index page. |
| `includeDocumentText` | `false` | Paid add-on: the main document as text, sections, press release, 13D or 13G stake. |
| `maxTextCharacters` | 200,000 | Characters of text kept per document, 1,000 to 2,000,000; the full length is reported. |
| `textChunkSize` | 0 | Chunks of about this many characters (500 to 100,000) for retrieval; 0 means none. |
| `includeFinancialData` | `false` | Paid add-on: XBRL figures of a 10-K, 10-Q, 20-F or 40-F for its own period. |
| `financialConcepts` | default set | Up to 40 XBRL concepts instead of the default set, for example `Revenues`, `us-gaap:NetIncomeLoss`, `ifrs-full:Revenue`. |
| `includeCompanyRows` | `true` | One free profile row per company read. |
| `includePersonalData` | `false` | All public data is always delivered, so this setting has no effect (it is kept so saved inputs keep working). |
| `maxItems` | 100 (prefill 10) | The most Filing rows this run delivers and charges, 1 to 100,000. |
| `maxFilingsPerCompany` | none | The most filings per company, so a list of companies shares the run. |
| `maxFilingsPerForm` | none | The most filings per form type (a form and its amendments together); the rest are skipped free. |
| `maxRequestsPerSecond` | 5 | How fast the run asks the SEC, 1 to 5. |
| `proxyConfiguration` | off | Not needed. With Apify Proxy on, every request goes through one Apify datacenter proxy session from the start. Own proxy URLs are not used. |

Which targets are present decides the kind of run: when any target field is present, even empty, the run reads those targets and is never widened into a date window (an empty list is a free `invalid_input` row). An input field this Actor does not know stops the run with a free row, because it could be a filter under another name.

### Limits

- **Date window coverage.** The date window and the full-text search read the SEC's full-text index. On a day we compared with the SEC's daily index (2026-10-29) it held every 8-K, 10-Q, 10-K and Form 4; about 1.2 percent of the day's filings were not in it: SEC staff letters (`UPLOAD`, `CORRESP`), notices of effectiveness (`EFFECT`) and draft registrations (`DRS`). Company mode reads each company's complete filer record and gets those too, except in one case: when a batch of 100 listed companies filed 100 filings or fewer in a date window from 2001 on, only the companies the full-text index lists are read, so a company whose only filings in the window are of those kinds gets no rows.
- **How far back.** Filer records reach back to 1994 for the oldest filers; the full-text search and the date window cover filings from 2001 on.
- **Several queries, newest first,** are read side by side one filing day at a time: each day is read to its end in every search before its rows are delivered, so a run with several broad queries reads a whole day of each before its first row of that day. A run cut by a cap (`maxItems`, the charge limit, the free work room used up) or by one search failing delivers the filings already read, as far as the cap allows, and their rows can list fewer queries than a complete day would; the summary marks those searches `partial`. After a stop (an abort, a timeout, the SEC refusing the run) nothing of the cut day is delivered or charged. In relevance order the queries are read one after another and a row names the query that delivered it. With several searches and a charge limit, the free work room a run may use before its rows are charged is counted as if every filing took the add-ons you asked for at their full price, so near the limit such a run can stop earlier with `stoppedBy: work_allowance` (the filings read so far are delivered; nothing is charged past what it earns).
- **Relevance order** reads at most 10,000 results and says so in the summary. Newest first, a single form on a single day with 10,000 or more matches ends that part with a note naming it.
- **Acceptance time.** Rows read by ticker, CIK, name or accession number carry it; search and window rows carry it with filing details. `isXBRL` is filled only on rows read by ticker, CIK or name, and `fiscalYear` and `fiscalPeriod` only on 10-K, 10-Q, 20-F and 40-F rows whose filer's fiscal year end is known (rows read by ticker, CIK, name or accession number).
- **Company names** are matched among listed companies only (the SEC's list of tickers). For any other filer, give its CIK.
- **Bare accession numbers** are looked up under the CIK their first ten digits name: that always works when the company filed for itself, and often (not always) for a filing an agent filed; when it does not, the free row asks for the EDGAR link, which always works.
- **Documents** larger than 12 MB are not read, and the text of one row is kept under about 3,000,000 characters in total.
- **Per run:** up to 500 tickers, CIKs, names and accession numbers together, 20 queries of up to 500 characters, 200 values per filter list.
- **Free work is limited.** Reads that end without a Filing row earn nothing, so a run does a bounded amount of them, and every filing it delivers earns it more room. When the room is used up the run stops starting new reads, delivers what it has and ends with `stoppedBy: work_allowance`. The add-ons have their own room: when it is spent, rows go without the add-on, with a note, uncharged.
- **Pace:** at most 5 requests per second. Requests go out from the run's own address; if the SEC refuses it three times in a row, the rest of the run goes through one Apify datacenter proxy session at the same pace, and the summary says so. If the SEC refuses that too, the run stops with `stoppedBy: source_unavailable` and nothing more is charged.

### What this Actor does NOT do

- No "new only" mode and no memory between runs: each run reads what its input asks. For a feed, schedule it with `daysBack` or `dateFrom`; a filing inside two runs' windows is delivered by both.
- No Form 4 transaction rows, no 13F holding rows and no XBRL statement rows: a Form 4 or a 13F-HR comes as one Filing row, and the Financial data add-on attaches only the figures a report filed for its own period.
- No AI summaries: `summary` is one sentence built from the row's own fields, and the outlook sentences and word counts come from fixed word lists.
- No earnings call transcripts: they are not filed with the SEC.
- No scores from the filing's text and no company memory: the signals come from the form, the 8-K item codes, the presets a filing matched and the filings of the same run. Nothing is remembered between runs (rule above), so there is no escalation, stability score, company baseline or cross filing pattern across runs.
- No website or domain lookup: the SEC's filer records carry no usable website (empty on 20 of 20 company rows of a run on 2026-11-01), so a domain such as apple.com cannot be matched to a company; use the ticker or the CIK.
- No hour windows: windows are whole days on the SEC's calendar (`daysBack`, `dateFrom`, `dateTo`), because search and window rows carry no acceptance time unless each filing's index page is read; cut by `acceptedAt` after the run.
- No contact e-mail address in its requests: the User-Agent names Automation Craft and its Store page.
- No free first rows: every filing row is charged from the first one.
- No own proxy URLs: `proxyUrls` in `proxyConfiguration` stops the run with a free row.
- No alerts or delivery connectors of its own (Slack, e-mail, a database): use Apify's schedules, integrations and webhooks on the dataset.

### About the data

The data is the SEC's public filing data as filed, read from EDGAR (filer records, the full-text search, filing index pages, documents and XBRL facts) with a declared User-Agent at half the SEC's published request rate. The SEC's website policy says its information may be copied or further distributed by users of the website without the SEC's permission. Document texts are the document's own text: HTML is converted to plain text the way a browser shows it (runs of spaces collapsed, table cells separated by a tab), and a plain text document keeps its spacing and columns (only line ends are normalised and runs of blank lines shortened to one). This Actor is an independent tool. It is not affiliated with or approved by the U.S. Securities and Exchange Commission (SEC).

### API examples

Every run is also an SEC filings API call over the Apify API: send the input, read the rows.

curl (synchronous run, returns the rows):

```bash
curl -X POST "https://api.apify.com/v2/acts/automation_craft~sec-filings-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"formTypes":["8-K"],"eventCategories":["earnings"],"daysBack":3,"maxItems":50}'
```

Node.js with `apify-client`:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation_craft/sec-filings-scraper').call({
    searchQueries: ['"material weakness"'],
    formTypes: ['10-K', '10-Q'],
    daysBack: 30,
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const row of items) if (row.type === 'filing') console.log(row.companyName, row.form, row.filedAt, row.filingIndexUrl);
```

Python with `apify-client`:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation_craft/sec-filings-scraper").call(
    run_input={"tickers": ["AAPL", "MSFT"], "formTypes": ["10-K", "10-Q"], "maxFilingsPerCompany": 4, "includeFinancialData": True}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["type"] == "filing":
        print(row["companyName"], row["form"], row["reportDate"], len(row["financialData"] or []))
```

### FAQ

#### How can I find a company's SEC filings?

Put its ticker into `tickers` (or its CIK into `ciks`, or its exact listed name into `companyNames`): the run reads the company's whole filer record, newest first, back to 1994 for the oldest filers. Narrow it with `formTypes` and a date window, and set `maxFilingsPerCompany` when you give a list of companies.

#### How far back does SEC EDGAR go?

Company filer records reach back to 1994 for the oldest filers, and this Actor reads them to their end, older pages included. The full-text search and the date window cover filings from 2001 on.

#### Can I search the full text of SEC filings past the 10,000 result limit?

Yes, in the default newest first order: a search with 10,000 or more results is split by date and, for one large day, by form, and every part is read (a single form on a single day with 10,000 or more matches is named in the run summary instead). Relevance order reads at most 10,000 results and says so in the run summary.

#### Are SEC filings public, and can I reuse the data?

Yes. The SEC's website policy says its information may be copied or further distributed without the SEC's permission, and every row links back to the filing on sec.gov. Some filers are people (insiders, reporting owners): their names, addresses, phone and EIN are delivered as the SEC publishes them. You are responsible for a lawful use of personal data (GDPR included).

#### Will the SEC block my runs?

The SEC refuses requests from undeclared tools with an HTTP 403 page. This Actor sends a declared User-Agent and asks at most 5 times per second, half the SEC's published limit of 10. If the SEC refuses the run's own address three times in a row, the run moves to one Apify datacenter proxy session; if that is refused too, it stops with `stoppedBy: source_unavailable` and nothing more is charged.

#### Why does this Actor run with limited permissions?

It runs with Apify's limited permissions, the least privilege level: it reads its input and writes only its own run's dataset and key-value store, and it reads its dataset back after a platform restart so no filing is charged twice. It opens no named store and touches nothing else in your account.

### Changelog

See the Changelog tab of this Actor (CHANGELOG.md in the source).

### More data tools by Automation Craft

- [SEC Form D Scraper: Offerings & Funding Leads](https://apify.com/automation_craft/sec-form-d-scraper)
- [Yahoo Finance Scraper: Quotes, History, Financials](https://apify.com/automation_craft/yahoo-finance-scraper)
- [US New Business Registrations Scraper - LLC Leads](https://apify.com/automation_craft/us-new-business-registrations-scraper)
- [Google News Scraper: Search, Topics, Decoded URLs](https://apify.com/automation_craft/google-news-scraper)
- [UK Contracts Finder Scraper: Tenders & Awards](https://apify.com/automation_craft/uk-contracts-finder-scraper)
- [Grants.gov Scraper: Federal Grant Opportunities](https://apify.com/automation_craft/grants-gov-scraper)

# Changelog

This Actor's version history is a separate document: https://apify.com/automation_craft/sec-filings-scraper/changelog.md

# Actor input Schema

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

Stock ticker symbols of listed companies, for example AAPL, MSFT or BRK-B (BRK.B is read as BRK-B). Each is matched to its company through the SEC's list of listed tickers; a ticker the SEC does not list gets a free status row. Every filing of the company is read, newest first, from its filer record.

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

SEC Central Index Keys (CIK) of companies, funds or people, with or without leading zeros (320193 or 0000320193), or an EDGAR company link. Use a CIK for any filer that has no ticker. A CIK the SEC does not know gets a free status row.

## `companyNames` (type: `array`):

Names of listed companies, for example Apple Inc. A name is used only when exactly one listed company carries it (letters and digits compared; case, punctuation and spacing aside). Otherwise a free status row lists the nearest listed names, so you can run again with a ticker or CIK. For a company that is not listed, use its CIK. Given as one text instead of a list, put one name per line (a name can hold commas).

## `accessionNumbers` (type: `array`):

Filings to read as asked, by accession number (0000320193-26-000011) or EDGAR filing link. A bare accession number is looked up under the CIK its first ten digits name, which is the filer's own CIK when the company filed for itself; for a filing an agent filed, paste its EDGAR link. Filters do not apply to these. Cannot be combined with companies or searches.

## `searchQueries` (type: `array`):

Words or exact phrases to find in the text of filings, written as on the SEC's full-text search: "exact phrase" in quotes, OR between alternatives, a leading minus to exclude a word. One row per matching filing (newest first), with the documents that matched. A filing that several queries or presets find is one row that lists every one of them (matchedQueries), charged once. Narrow a search with tickers or CIKs, form types and dates. The full-text search covers filings from 2001 on. Given as one text instead of a list, put one query per line (a query can hold commas).

## `searchPresets` (type: `array`):

Named full-text searches, run like searchQueries: going concern, material weakness, restatement, cybersecurity incident, layoffs, guidance withdrawn, CEO departure, bankruptcy (chapter 11), share buyback, activist investor, artificial intelligence, tariffs.

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

EDGAR form types to keep, for example 10-K, 10-Q, 8-K, 4, S-1, DEF 14A, SC 13D. A form includes its amendments (10-K/A) unless includeAmendments is false; give 10-K/A alone for amendments only. Leave empty for every form type.

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

Keep amended filings (form types ending in /A) along with the original form types. True when left empty.

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

Keep filings filed on or after this date (YYYY-MM-DD). Left empty: a company's whole history, a search's whole span (2001 on), or the last 7 days when no company, filing or query is given.

## `dateTo` (type: `string`):

Keep filings filed on or before this date (YYYY-MM-DD). Left empty: today.

## `daysBack` (type: `integer`):

Instead of a start date: keep filings of the last N days, counted from the run's start on the SEC's calendar (US Eastern). 0 means today only. Cannot be combined with dateFrom.

## `items8K` (type: `array`):

Keep only filings that report at least one of these Form 8-K items, for example 2.02 (results of operations), 5.02 (officer and director changes) or 1.01 (material agreement). Filings without items (every form but 8-K) are left out when this is set.

## `eventCategories` (type: `array`):

Shortcuts for groups of 8-K items, joined to items8K: earnings, material agreement, mergers and acquisitions, bankruptcy, cybersecurity incident, debt financing, restructuring, delisting, equity sale, auditor change, restatement, leadership change, governance, shareholder vote, Regulation FD, other events.

## `minFilingSizeKb` (type: `integer`):

Keep only filings whose whole submission is at least this many kilobytes. In searches and date windows the size is read from each filing's index page first (slower).

## `companyNameContains` (type: `string`):

Keep only filings where a filer's name contains this text (case and spacing aside), for example "Bank" or "Therapeutics". For full-text searches and date windows; companies are named by ticker, CIK or name instead.

## `sortBy` (type: `string`):

Order of full-text search results: newest first (every match, split by date past the search's 10,000 result window), or by relevance (the search's own score; at most 10,000 results). In relevance order several queries are read one after another, so a row names the query that delivered it.

## `includeFilingDetails` (type: `boolean`):

Read each filing's index page: every document and exhibit with its type, description and size, every filer with its role (filer, issuer, reporting owner, subject company), and the acceptance time for search and date window rows. Free; one extra request per filing makes a run slower.

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

Read the filing's main document into plain text, priced per filing as the Document text event, charged only when the text was read. Adds report sections for 10-K, 10-Q and 20-F (Item 1A Risk Factors, Item 7 MD\&A and the rest), item sections for 8-K, the 8-K press release (exhibit 99.1) with its outlook sentences and a finance word count, and the stake of each reporting person on Schedule 13D and 13G. May be left off a row when its allowance is spent; the row then says so.

## `maxTextCharacters` (type: `integer`):

The most characters of a document's text kept in a row (200,000 when left empty). The full length is reported. Only with includeDocumentText.

## `textChunkSize` (type: `integer`):

Also cut the document text into chunks of about this many characters at paragraph or sentence ends, for retrieval and AI pipelines. 0 or empty: no chunks. Only with includeDocumentText.

## `includeFinancialData` (type: `boolean`):

Attach the XBRL figures a 10-K, 10-Q, 20-F or 40-F reported for its own period: revenue, net income, operating income, earnings per share, assets, liabilities, equity, cash, operating cash flow, long-term debt and shares outstanding (or the concepts you list). Priced per filing as the Financial data event, charged only when at least one figure was found.

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

The XBRL concepts to read instead of the default set, for example Revenues, us-gaap:NetIncomeLoss or ifrs-full:Revenue (us-gaap when no taxonomy is named). Only with includeFinancialData.

## `includeCompanyRows` (type: `boolean`):

One free row per company read by ticker, CIK or name: name, tickers, exchanges, industry (SIC), state of incorporation, fiscal year end, addresses, phone, former names.

## `includePersonalData` (type: `boolean`):

All public data is always delivered, so this setting has no effect (it is kept so saved inputs keep working).

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

The most filing rows (charged events) one run delivers. Free status, company and summary rows do not count.

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

The most filings delivered for each company given by ticker, CIK or name, so a list of companies shares the run. Only for companies.

## `maxFilingsPerForm` (type: `integer`):

The most filings delivered of each form type (a form and its amendments count together), for example 5 of each when several form types are asked. Filings past it are skipped free.

## `maxRequestsPerSecond` (type: `integer`):

How fast this run asks the SEC (the SEC allows 10 per second per user; this Actor never sends more than 5).

## `proxyConfiguration` (type: `object`):

Not needed: the SEC is read from the run's own address, with one Apify datacenter proxy session as an automatic fallback. Turn on Apify Proxy to send every request through that session from the start. Own proxy URLs are not used.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "sortBy": "newest",
  "includeFilingDetails": false,
  "includeDocumentText": false,
  "includeFinancialData": false,
  "includeCompanyRows": true,
  "includePersonalData": false,
  "maxItems": 10,
  "maxRequestsPerSecond": 5
}
```

# Actor output Schema

## `items` (type: `string`):

No description

## `signalRanking` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "tickers": [
        "AAPL"
    ],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/sec-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"],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation_craft/sec-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"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "maxItems": 10
}' |
apify call automation_craft/sec-filings-scraper --silent --output-dataset

```

## MCP server setup

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