# SEC EDGAR Filings Scraper (`datamule/sec-edgar-filings-scraper`) Actor

Scrape U.S. SEC EDGAR company filings + metadata from the official public JSON APIs. Query by ticker, CIK, or full-text keyword; filter by form type (10-K, 10-Q, 8-K…) and filing-date range. One clean record per filing with the index + document URLs. Pay per filing.

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

## Pricing

from $0.35 / 1,000 filing scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## SEC EDGAR Filings Scraper

Pull U.S. **SEC EDGAR** company filings and their metadata using EDGAR's **official public
JSON APIs** — no scraping of HTML pages, no anti-bot workarounds, no API key. Three query
modes, freely combinable, plus form-type and date-range filters.

### Query modes

| Mode | Input | What it does |
|------|-------|--------------|
| **By ticker** | `tickers: ["AAPL", "MSFT"]` | Resolves each ticker to its CIK via SEC's official `company_tickers.json`, then pulls that company's filings. |
| **By CIK** | `ciks: ["0000320193", 789019]` | Pulls filings for exact Central Index Keys (with or without zero-padding). |
| **By keyword** | `query: "artificial intelligence"` | Full-text search across filing **documents** via EDGAR full-text search (covers filings from 2001 onward). |

Filters (apply to every mode):

- `formTypes` — e.g. `["10-K", "10-Q", "8-K"]`. Exact match on the form label. Empty = all forms.
- `startDate` / `endDate` — `YYYY-MM-DD`, inclusive, on the **filing date**.
- `maxResults` — hard cap on records returned (default 50).
- `userAgent` — SEC **requires** a descriptive User-Agent on every request. A generic default
  is provided; set your own contact string (e.g. `"MyCompany you@example.com"`) to be a good
  EDGAR citizen.

### Example input

```json
{
  "tickers": ["AAPL"],
  "formTypes": ["10-K"],
  "maxResults": 5
}
```

```json
{
  "query": "data breach",
  "formTypes": ["8-K"],
  "startDate": "2024-01-01",
  "endDate": "2024-06-30",
  "maxResults": 100
}
```

### Output

One dataset record per filing:

| Field | Description |
|-------|-------------|
| `companyName` | Registrant name |
| `cik` | 10-digit zero-padded CIK |
| `ticker` | Ticker symbol (when resolvable) |
| `formType` | SEC form (10-K, 8-K, 4, …) |
| `filingDate` | Date filed (YYYY-MM-DD) |
| `reportDate` | Period of report (YYYY-MM-DD) |
| `acceptanceDateTime` | When EDGAR accepted the filing (company mode) |
| `accessionNumber` | EDGAR accession number |
| `primaryDocument` | Primary document filename |
| `primaryDocDescription` | Primary document description |
| `items` | 8-K item codes / hit items (when present) |
| `fileNumber` | SEC file number |
| `size` | Filing size in bytes (company mode) |
| `isXBRL` | Whether the filing is XBRL (company mode) |
| `filingIndexUrl` | URL of the filing index page on EDGAR |
| `documentUrl` | Direct URL to the primary document |

### Data sources (all official, public)

- `https://www.sec.gov/files/company_tickers.json` — ticker → CIK
- `https://data.sec.gov/submissions/CIK##########.json` — company profile + filings
- `https://efts.sec.gov/LATEST/search-index` — full-text filing search

### Pricing

Pay-per-event: charged per filing record returned.

### Notes & limits

- EDGAR **full-text search covers filings from 2001 onward**; older filings are reachable by
  ticker/CIK (the submissions API spans a company's full history).
- The Actor sends the mandatory `User-Agent` header and throttles well under SEC's documented
  10 requests/second fair-access limit.
- This Actor returns filing **metadata and links**, not the parsed body text of each document.

# Actor input Schema

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

Stock ticker symbols to fetch filings for, e.g. AAPL, MSFT, TSLA. Resolved to the company CIK via SEC's official company\_tickers.json map. Combine with formTypes / date range to narrow.

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

SEC Central Index Keys (CIK) to fetch filings for, e.g. 0000320193 or 320193. Use this for companies you already know by CIK, or entities without a ticker. Zero-padding is handled automatically.

## `query` (type: `string`):

Full-text search across filing documents via SEC EDGAR full-text search (covers filings from 2001 onward). e.g. "artificial intelligence", "going concern", "data breach". Returns filings whose documents contain the phrase. Leave empty to query by ticker / CIK only.

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

Restrict to specific SEC form types, e.g. 10-K, 10-Q, 8-K, S-1, DEF 14A, 4. Leave empty for all forms. Matching is exact on the form label.

## `startDate` (type: `string`):

Only include filings filed on or after this date (YYYY-MM-DD). Leave empty for no lower bound.

## `endDate` (type: `string`):

Only include filings filed on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

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

Maximum number of filing records to return across all query modes. Protects against pulling a company's entire multi-decade history by accident.

## `userAgent` (type: `string`):

SEC requires a descriptive User-Agent on every request (e.g. "MyCompany contact@example.com"). A generic default is used if left empty; set your own contact to be a good EDGAR citizen.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "ciks": [],
  "formTypes": [
    "10-K"
  ],
  "maxResults": 50
}
```

# Actor output Schema

## `results` (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"
    ],
    "ciks": [],
    "query": "",
    "formTypes": [
        "10-K"
    ],
    "startDate": "",
    "endDate": "",
    "maxResults": 50,
    "userAgent": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamule/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"],
    "ciks": [],
    "query": "",
    "formTypes": ["10-K"],
    "startDate": "",
    "endDate": "",
    "maxResults": 50,
    "userAgent": "",
}

# Run the Actor and wait for it to finish
run = client.actor("datamule/sec-edgar-filings-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "tickers": [
    "AAPL"
  ],
  "ciks": [],
  "query": "",
  "formTypes": [
    "10-K"
  ],
  "startDate": "",
  "endDate": "",
  "maxResults": 50,
  "userAgent": ""
}' |
apify call datamule/sec-edgar-filings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/W1n3sbo9L6Zxnd8ii/builds/CP7HrALu9D5b0Tys6/openapi.json