# SEC EDGAR Filings Scraper \[$2.5/1K💰] | 10-K | 8-K | XBRL (`ahmed_jasarevic/sec-scraper`) Actor

Extract SEC EDGAR filing metadata for any US public company by ticker or CIK — form types, dates, accession numbers, XBRL flags and direct links to documents and filing indexes. Built for investment research, due diligence, filing monitoring and compliance. $2.50 per 1,000 filings.

- **URL**: https://apify.com/ahmed_jasarevic/sec-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 results

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

Extract SEC EDGAR filing metadata for any US public company by ticker or CIK — form types, dates, accession numbers and direct links to every filing document and index page — into a clean dataset, paced to SEC's fair-access rules.

**Built for:**

- Investment research, screening and due-diligence workflows
- Building a filings database for a watchlist of companies
- Monitoring new filings (10-K, 10-Q, 8-K, insider forms) on a schedule
- Data pipelines that need structured filing metadata and XBRL flags
- Compliance, newsroom and market-intelligence tracking

### Track SEC Filings & Financial Disclosures by Ticker

Give the actor stock tickers (`AAPL`, `MSFT`, `BRK.B`) or CIKs, optionally restrict form types and a filing-date window, and get one row per filing: company metadata (CIK, tickers, exchanges, entity type, SIC industry, state of incorporation, fiscal year end) and filing details (form type, filing date, period of report, acceptance timestamp, accession number, primary document name, reported items, file/film numbers, size, XBRL availability) plus direct URLs to the primary document and the filing index on sec.gov. A per-run `SUMMARY` record is written to the key-value store for quick pipeline checks.

### How It Works

![How the SEC EDGAR Scraper works: tickers and CIKs become filing rows with forms, dates, direct documents and XBRL flags.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-sec-scraper)

The Actor resolves tickers to 10-digit CIKs, reads each company's submissions JSON and applies form-type, date and result filters. Request starts are paced globally at eight per second to stay inside SEC fair-access limits.

Each row covers one filing with company details, form type, filing and report dates, accession number, primary document, direct document and index links, plus XBRL flags.

1. Tickers are resolved to CIKs through SEC's public `company_tickers.json` mapping (dots and dashes are interchangeable).
2. For each company the actor reads the latest submissions JSON and pages through historical filing files only when the requested date range or per-company limit requires them.
3. Form-type filters, date bounds, amendment handling and per-company caps are applied in the actor before rows are pushed.
4. All SEC requests share a global 8 requests-per-second limit — below SEC's published 10 req/s fair-access ceiling — with retries and backoff; companies are processed in parallel within that budget (concurrency input, default 4).
5. Rows are written to the dataset as they are collected and a `SUMMARY` record closes the run.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `ciks` | array | No\* | `[]` | SEC Central Index Keys with or without leading zeros (e.g. `320193` or `0000320193`). |
| `tickers` | array | No\* | `[]` | Stock tickers (e.g. `AAPL`, `MSFT`), resolved to CIKs through SEC's `company_tickers.json`. Dots/dashes interchangeable (`BRK.B` = `BRK-B`). |
| `formTypes` | array | No | `[]` | Only these forms (e.g. `10-K`, `10-Q`, `8-K`, `4`, `S-1`). Trailing `*` acts as a wildcard (`10-*`). Amendments like `10-K/A` must be listed explicitly. Empty = all forms. |
| `startDate` | string | No | `""` | Earliest filing date, `YYYY-MM-DD`. Empty = no lower bound. |
| `endDate` | string | No | `""` | Latest filing date, `YYYY-MM-DD`. Empty = no upper bound. |
| `maxFilingsPerCompany` | integer | No | `0` | Matching filings saved per company; `0` = no limit. Newest first. |
| `maxItems` | integer | No | `0` | Total filings across all companies; `0` = unlimited for paying users. Free users are capped at 100 filings per run. |
| `concurrency` | integer | No | `4` | Companies processed in parallel (1–10). SEC requests remain globally limited to 8 per second. |
| `proxy` | object | No | disabled | Optional; SEC may rate-limit proxy traffic, so leave it off unless direct access fails. |

\* Provide at least one CIK or ticker.

### Output Fields

One dataset item per filing (`companyName` is repeated on every row):

- **Company:** `companyName`, `cik` (10-digit), `tickers`, `exchanges`, `entityType`, `sic`, `sicDescription`, `stateOfIncorporation`, `fiscalYearEnd`
- **Filing:** `formType`, `filingDate`, `reportDate`, `acceptanceDateTime`, `accessionNumber`, `primaryDocument`, `primaryDocDescription`, `items`, `size`, `act`, `filmNumber`, `fileNumber`
- **Links:** `documentUrl` (primary document on sec.gov), `filingIndexUrl` (full index of the submission)
- **XBRL:** `isXBRL`, `isInlineXBRL`, `isXBRLNumeric`

Console views: **Filings**, **Company details** and **XBRL**. The run's `SUMMARY` record lives in the run's key-value store.

### Example Input

```json
{
  "tickers": ["AAPL"],
  "formTypes": ["10-K", "10-Q", "8-K"],
  "startDate": "2024-01-01",
  "maxFilingsPerCompany": 10
}
```

### Example Output

```json
{
  "companyName": "Apple Inc.",
  "cik": "0000320193",
  "tickers": ["AAPL"],
  "exchanges": ["Nasdaq"],
  "entityType": "operating",
  "sic": "3571",
  "sicDescription": "Electronic Computers",
  "stateOfIncorporation": "CA",
  "fiscalYearEnd": "0926",
  "formType": "10-Q",
  "filingDate": "2026-07-31",
  "reportDate": "2026-06-27",
  "acceptanceDateTime": "2026-07-31T14:01:02.000Z",
  "accessionNumber": "0000320193-26-000020",
  "primaryDocument": "aapl-20260627.htm",
  "primaryDocDescription": "10-Q",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000020/aapl-20260627.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000020/0000320193-26-000020-index.htm",
  "items": "",
  "isXBRL": true,
  "isInlineXBRL": true,
  "isXBRLNumeric": true,
  "fileNumber": "001-36743"
}
```

### Automate SEC Filing Monitoring With Schedules & Webhooks

- **Daily watchlist monitoring:** schedule one run per day with your `tickers` and a recent fixed `startDate` (relative offsets are not supported), then keep only rows whose `accessionNumber` is new compared to the previous run.
- **Form-specific alerts:** set `formTypes: ["8-K", "4"]` for material-event and insider-activity feeds and attach a dataset webhook to email, Slack or a warehouse.
- **Quarterly bulk pulls:** fetch 10-K/10-Q metadata for a full industry cohort (`formTypes: ["10-*"]`, wide date window) once per quarter for analytics.
- Scheduled runs are the intended pattern and improve this actor's Store recommendation signals.

### Related Actors

- [SEC Edgar Filings Scraper](https://apify.com/constant_quadruped/sec-edgar-filings-scraper) — the most-used EDGAR actor on the Store, closest direct alternative.
- [SEC EDGAR Filings — 10-K, 10-Q, 8-K & More](https://apify.com/benthepythondev/sec-edgar-filings-intelligence) — filings intelligence with its own field set.
- [SEC EDGAR Filings API — Official Source, No API Key](https://apify.com/nexgendata/sec-edgar-filings-api) — official-source flavored option.
- [SEC EDGAR Full-Text Search MCP Server](https://apify.com/rl1987/sec-edgar-mcp) — full-text keyword search across filings, complementary to metadata extraction.
- [SEC EDGAR Full-Text Search & Financial Filings](https://apify.com/gettingtechnicl/edgar-scraper) — full-text search scraper using EDGAR's public JSON search API.

### Frequently Asked Questions

#### Why use this actor instead of the official API?

SEC's own data APIs are free, keyless and excellent — this actor is built directly on them, and if you only need to call `data.sec.gov` yourself, that route is perfectly valid. The actor adds the orchestration around that data: ticker-to-CIK resolution from `company_tickers.json`, form-type wildcards, date-window filtering that pages through historical filing files automatically, per-company and global caps, parallel companies under a polite global 8 requests/second budget with retries and backoff, XBRL flags, direct document and index URLs, a `SUMMARY` record per run, plus Apify's dataset export, scheduling and webhooks — without writing or maintaining any of it.

#### Is there a SEC EDGAR API?

Yes — `data.sec.gov` serves submissions history and XBRL company data as JSON with no authentication or API key, under a fair-access policy of at most 10 requests per second and a descriptive User-Agent with contact details. SEC also publishes nightly bulk ZIPs. This actor stays below the limit (8 req/s) and identifies itself with a fixed descriptive User-Agent.

#### How do I download SEC filings for a list of tickers?

Enter the tickers in `tickers` and run — CIKs are resolved automatically. Add `formTypes` to keep only the forms you need (e.g. `10-K`, `10-Q`), set `maxFilingsPerCompany` to bound each company, and export the dataset as CSV/Excel/JSON, or schedule the run for continuous collection.

#### Can I search the full text of filings with this actor?

No — this actor collects filing metadata by company (a different job from EDGAR full-text search). For phrase-level search across all filings, use a full-text search actor such as the ones linked under Related Actors; you can combine both: find candidate filings there, then pull structured metadata here.

#### Does it work without an API key or account?

Yes. It uses SEC's public JSON endpoints, sends a descriptive User-Agent, needs no registration, and requires no API key. Proxies are disabled by default because SEC may treat proxy traffic differently.

#### What is an accession number and why is it useful?

The accession number (e.g. `0000320193-26-000020`) is SEC's unique identifier for a filing. It is the most reliable key for deduplication, so scheduled monitoring runs typically diff new dataset rows by `accessionNumber`.

### For AI Agents & LLM Apps

**Purpose:** returns SEC EDGAR filing metadata rows for given tickers/CIKs — company fields, form details, XBRL flags and direct sec.gov document/index URLs — keyless.

**Minimal input:**

```json
{ "tickers": ["AAPL"], "maxItems": 5 }
```

**Watchlist variant:**

```json
{ "tickers": ["AAPL", "MSFT"], "formTypes": ["10-K", "10-Q"], "startDate": "2025-01-01", "maxFilingsPerCompany": 20 }
```

**Output fields:** companyName, cik, tickers, exchanges, entityType, sic, sicDescription, stateOfIncorporation, fiscalYearEnd, formType, filingDate, reportDate, acceptanceDateTime, accessionNumber, primaryDocument, primaryDocDescription, documentUrl, filingIndexUrl, items, size, act, filmNumber, fileNumber, isXBRL, isInlineXBRL, isXBRLNumeric.

**Behaviors an agent should know:**

- At least one `ciks` or `tickers` entry is required; both can be combined.
- `formTypes` wildcards are trailing-only (`10-*`); amendments (`10-K/A`) must be listed explicitly.
- `maxItems: 0` means unlimited for paying users; free users are capped at 100 filings per run — always set an explicit cap in agentic runs.
- `concurrency` (default 4) parallelizes companies, but SEC requests stay globally limited to 8 per second.
- Keep `proxy` disabled (default) — SEC advises against proxy traffic for this data.
- The run writes a `SUMMARY` record to the default key-value store alongside the dataset.

**Billing:** pay-per-event — `result` at $0.0025 per result row, plus a run-start event.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the U.S. Securities and Exchange Commission. It reads SEC EDGAR data through SEC's own public JSON interfaces, sends a fixed descriptive User-Agent, and keeps its request rate at 8 per second — below SEC's published fair-access ceiling of 10 per second. No login, account or API key is used. SEC filings are public regulatory documents; users are responsible for their own compliance with SEC's access policies and applicable law when storing, redistributing or automating access to the collected data.

### SEO Keywords

sec edgar scraper, sec filings scraper, sec edgar api, sec filings api, data.sec.gov, edgar filings download, 10-k filings data, 10-q data, 8-k filings, sec filing monitor, company filings database, xbrl data, edgar scraper, sec edgar alternative, ticker to cik, sec filing alerts, public company data, investment research data, insider form 4 filings, sec disclosure tracking

# Actor input Schema

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

SEC Central Index Keys, with or without leading zeros (for example 320193 or 0000320193).

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

Stock tickers (for example AAPL or MSFT). Resolved to CIKs through SEC's company_tickers.json. Dots and dashes are interchangeable (BRK.B = BRK-B).

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

Only include these SEC form types, for example 10-K, 10-Q, 8-K, 4, S-1. Use a trailing asterisk as a wildcard (10-\* matches 10-K and 10-Q). Leave empty to include all forms. Amendments such as 10-K/A must be listed explicitly.

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

Earliest filing date to include, in YYYY-MM-DD format. Leave empty for no lower bound.

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

Latest filing date to include, in YYYY-MM-DD format. Leave empty for no upper bound.

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

Maximum number of matching filings to save per company. Use 0 for no limit. The newest matching filings are returned first.

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

Maximum number of filings to save across all companies. Use 0 for no limit. Free users are capped at 100 filings per run; paying users can use 0 for unlimited results.

## `concurrency` (type: `integer`):

Number of companies processed in parallel. SEC requests are still globally rate-limited to 8 requests per second.

## `proxy` (type: `object`):

Optional proxy. SEC may rate-limit or block proxy traffic, so leave it disabled unless direct access fails.

## Actor input object example

```json
{
  "ciks": [
    "0000320193",
    "0000789019"
  ],
  "tickers": [
    "AAPL",
    "MSFT"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "startDate": "2020-01-01",
  "endDate": "2025-12-31",
  "maxFilingsPerCompany": 0,
  "maxItems": 0,
  "concurrency": 4,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One item per filing, with company metadata, form details, XBRL flags and links to sec.gov.

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

Per-company filing counts, failures and the number of SEC requests made.

# 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"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/sec-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"],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/sec-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"
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/sec-scraper --silent --output-dataset

```

## MCP server setup

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