# SEC EDGAR Historical Filings (`monlab/sec-edgar-filings`) Actor

Get multi-year SEC filing metadata by CIK or ticker, with original document links, distinct dates and completeness diagnostics.

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

## Pricing

from $0.40 / 1,000 unique company filings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does SEC EDGAR Historical Filings do?

Get **multi-year company filing metadata** from the [SEC's official EDGAR API](https://www.sec.gov/search-filings/edgar-application-programming-interfaces). Specify company CIKs or current tickers and an inclusive filing-date range. Receive clean records for 10-K, 10-Q, 8-K and 20-F, including their amendments when requested.

The Actor follows the additional historical files listed by SEC, so an older date range is not silently limited to the company's recent submissions. A separate coverage report tells you whether processing completed or a limit stopped it. This is a metadata tool: it links to the original filing rather than downloading or summarizing its contents.

### Why use this SEC filing API workflow?

Prepare company research datasets, maintain document inventories, or feed a document-reading pipeline. SEC already provides free JSON APIs; this Actor packages the array-shaped responses and historical files into an exportable dataset, keeps filing dates separate from reporting periods, and provides diagnostic codes for missing or interrupted data.

Apify supplies scheduling, API access, exports and run monitoring. The processing uses deterministic code with no LLM. It has no proxy setting or login flow and does not collect ownership reports, officers' contact details or full company profiles.

### What data can it extract?

| Field | Type | Meaning |
| --- | --- | --- |
| cik, companyName, tickers | string / array | Company identifier, name and current symbols |
| accessionNumber, form | string | Unique filing identifier and exact form |
| isAmendment | boolean | True for a selected form's /A amendment |
| filingDate | date string | Date filed; used by the filters |
| reportDate | date string or null | Reporting-period date |
| acceptanceDateTime | timestamp or null | Timezone-aware acceptance timestamp |
| primaryDocumentUrl, filingIndexUrl | link or null | Original primary document and filing index |
| sourceUrl, retrievedAt | link / timestamp | Source JSON and normalization time |
| missingFields | array | Missing or invalid optional fields |

The full dataset schema defines 17 fields. Missing optional values remain null rather than being guessed. Historical records can lack a primary-document filename or a timezone-aware timestamp; their filing index remains available.

### How to retrieve SEC filings

1. Enter 1–20 company CIKs and/or tickers in total. Apple's CIK is `0000320193`; its current ticker is `AAPL`.
2. Select forms and optionally enter dates in YYYY-MM-DD format. The dates filter when the filing was submitted, not its financial reporting period.
3. Set the maximum results for the whole run, from 1 to 1,000.
4. Start the Actor and inspect the dataset.
5. Read the `REPORT` output before treating results as complete. Download the dataset as JSON, HTML, CSV or Excel, or access it through the API tab.

### Input

See the input tab for all configuration options. For a historical example:

```json
{"ciks":["0000320193"],"fromDate":"1994-01-01","toDate":"1996-12-31","forms":["10-K"],"includeAmendments":true,"maxResults":100}
```

CIKs are normalized to ten digits. Repeated CIKs and tickers resolving to the same company are processed once. Ticker lookup uses SEC's current mapping and cannot resolve historical symbols reliably; use CIKs for historical work. Unknown symbols appear in the report as `ticker_not_found`.

### Output and completeness

One dataset item represents a filing. Amendments are separate items, not replacements of the original filing. An abbreviated synthetic example:

```json
[{"cik":"0000000123","accessionNumber":"0000000123-25-000001","form":"10-K","isAmendment":false,"filingDate":"2025-01-15","reportDate":"2024-12-31"},
 {"cik":"0000000123","accessionNumber":"0000000123-25-000002","form":"10-K/A","isAmendment":true,"filingDate":"2025-02-01","reportDate":"2024-12-31"}]
```

Companies are processed in resolved input order. Their recent page is processed before the historical pages, newest pages first; each page is sorted by filing date and accession. This is not a global sort across companies. Duplicate company/accession pairs are omitted.

`REPORT.complete` means the requested processing exhausted its sources. It does not guarantee SEC's data is exhaustive or that an unknown company exists. Check `errors` too. `max_results`, `request_limit`, `charge_limit` and `aborted` mean partial results. Reaching a result cap conservatively marks the run incomplete even if the cap happens to equal the total. A broken historical pointer or malformed response stops the run instead of presenting partial coverage as complete.

### How much will it cost?

The price is **$0.40 per 1,000 successfully saved unique filing records**, plus **$0.00005 per run start** and **Apify platform usage billed separately**. The pricing tab shows the effective price. Duplicate records, unknown companies or tickers, and empty searches create no result charges; the start fee and platform usage can still apply to empty or failed runs.

Set a maximum charge in the run settings to bound the Actor event fees. The minimum supported maximum charge is $0.01; this is a spending cap, not a minimum purchase. The Actor stops before another record would exceed that cap and reports partial coverage. Platform execution costs are separate from this event cap. Developer test runs are not paid customer revenue.

### Limits and troubleshooting

Requests are sequential, with a fixed minimum two-second pause after each response. The limits are 200 upstream attempts and 1,000 output records per run. Users cannot raise concurrency or lower the delay. A 403 or redirect stops processing; there is no bypass. A 429 honors Retry-After when the wait is at most 120 seconds, with at most three attempts; longer waits stop with a diagnostic. Failed calls also count toward the request cap.

An aborted run persists progress. Resurrecting the same run with unchanged input reconciles existing dataset records and may refetch an unfinished company's source files; these attempts still count toward the cap. Use a new run for changed input. No full SEC payload, credentials or personal contact fields are stored in the recovery state.

### FAQ and support

#### Does this prove that a filing is accurate or provide investment advice?

No. The output is SEC source metadata and original links, not a factual audit of the document, financial calculations or an investment recommendation. Check the original document before relying on it.

#### Why can an older filing have a missing document URL?

Some source records lack a usable primary-document filename. The Actor preserves this as null and returns the filing index link rather than guessing a document. Acceptance timestamps without an explicit timezone are also returned as null.

#### What if the run fails?

Check the safe diagnostic code in REPORT and the run status. The Actor requests publicly available company metadata, respects SEC's access limits, and stops on access refusal. Use the Issues tab for problems and the API tab for programmatic access. It is not affiliated with or endorsed by SEC.

# Actor input Schema

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

One to twenty company CIKs in total with tickers. Strings of 1–10 digits, optionally prefixed CIK. Example: Apple's CIK 0000320193.

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

Optional tickers resolved through SEC's current ticker list. Resolution is not a historical ticker lookup; use a CIK when accuracy matters.

## `fromDate` (type: `string`):

Inclusive filing date YYYY-MM-DD, not the reporting-period date. Empty means no lower bound.

## `toDate` (type: `string`):

Inclusive filing date YYYY-MM-DD. Empty means no upper bound.

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

Select company filing forms. Individual ownership reports are excluded.

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

Include /A amendments of selected forms as separate filings; the isAmendment output identifies them.

## `maxResults` (type: `integer`):

Limit for the whole run across all companies, 1–1,000. Reaching it marks the report incomplete even if it happens to equal the total.

## Actor input object example

```json
{
  "ciks": [
    "0000320193"
  ],
  "tickers": [],
  "fromDate": "",
  "toDate": "",
  "forms": [
    "10-K",
    "10-Q",
    "8-K",
    "20-F"
  ],
  "includeAmendments": true,
  "maxResults": 100
}
```

# Actor output Schema

## `dataset` (type: `string`):

Export filing metadata as JSON, CSV or Excel.

## `report` (type: `string`):

Read complete, stopReason and errors before treating results as exhaustive.

# 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 = {
    "ciks": [
        "0000320193"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("monlab/sec-edgar-filings").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 = { "ciks": ["0000320193"] }

# Run the Actor and wait for it to finish
run = client.actor("monlab/sec-edgar-filings").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 '{
  "ciks": [
    "0000320193"
  ]
}' |
apify call monlab/sec-edgar-filings --silent --output-dataset

```

## MCP server setup

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

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/dS4MEiubNXb9JFIjT/builds/dBrTRZO0vEhZs8yKZ/openapi.json