# SEC EDGAR Scraper: Filings, Full-Text Search & XBRL Facts (`winterlock/sec-edgar-scraper`) Actor

Pull SEC filings, EDGAR full-text search results, XBRL financial facts and company profiles straight from the SEC's official APIs. Look companies up by ticker or CIK. No key, no login, no scraping.

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

## Pricing

from $15.00 / 1,000 company profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper: Filings, Full-Text Search & XBRL Facts

Pull US public-company data straight from the SEC's own APIs. Look companies up by ticker or CIK, search the full text of every filing since 2001, and get machine-readable financial figures without touching a PDF.

One Actor, four jobs:

| Mode | What you get |
|---|---|
| **Company filings** | Every filing for a company: form type, dates, accession number, SEC item codes, and a direct link to the document |
| **Full-text search** | Every filing containing a phrase, with the company, form, date and the exact exhibit that matched |
| **XBRL financial facts** | Reported figures as numbers — revenue, net income, assets — with the period, unit, form and filing they came from |
| **Company profiles** | Name, tickers, exchanges, CIK, SIC industry, state of incorporation, address and former names |

### Why use this one

- **Official APIs only.** Everything comes from `data.sec.gov`, `efts.sec.gov` and `www.sec.gov/files`. There is no HTML parsing anywhere in this Actor, so an EDGAR redesign cannot break it, and there is no terms-of-service grey area.
- **Tickers just work.** Enter `AAPL` instead of hunting for `0000320193`. The Actor resolves symbols through the SEC's own published company list.
- **Numbers, not documents.** XBRL mode returns one row per reported value, so you can chart a company's revenue over twenty years without opening a single filing.
- **Built to the SEC's rules.** The Actor sends a declared User-Agent and defaults to 2 parallel requests, which is what the SEC asks of automated clients. Most scrapers ignore this and get their IP blocked.
- **Complete history on request.** Turn on *Include the full filing history* and the Actor also reads the SEC's archive files, so you get every filing a company has ever made, not just the recent set.

### How to use it

1. Choose **What to collect**.
2. Add **Companies** (tickers or CIKs), or **Search queries** for full-text search.
3. Optionally narrow by **Form types** and a date range.
4. Click **Start**, then download results as JSON, CSV, Excel or HTML, or fetch them through the Apify API.

#### Example input: every 8-K Apple and Microsoft filed this year

```json
{
  "mode": "companyFilings",
  "contactEmail": "you@example.com",
  "companies": [
    "AAPL",
    "MSFT"
  ],
  "formTypes": [
    "8-K"
  ],
  "dateFrom": "2026-01-01"
}
```

#### Example input: find every company disclosing a material weakness

```json
{
  "mode": "fullTextSearch",
  "contactEmail": "you@example.com",
  "searchQueries": [
    "\"material weakness\""
  ],
  "formTypes": [
    "10-K"
  ],
  "dateFrom": "2026-01-01",
  "maxResultsPerQuery": 500
}
```

#### Example input: twenty years of revenue and net income

```json
{
  "mode": "companyFacts",
  "contactEmail": "you@example.com",
  "companies": [
    "AAPL"
  ],
  "xbrlTags": [
    "Revenues",
    "NetIncomeLoss"
  ],
  "xbrlTaxonomy": "us-gaap"
}
```

### Output

Each item has a `type` field: `filing`, `searchHit`, `fact` or `company`. The dataset has ready-made **Filings**, **XBRL facts** and **Companies** table views.

**Filing**

```json
{
  "type": "filing",
  "accessionNumber": "0001140361-26-039785",
  "cik": "0000320193",
  "companyName": "Apple Inc.",
  "form": "8-K",
  "filingDate": "2026-10-15",
  "reportDate": "2026-10-13",
  "acceptanceDateTime": "2026-10-16T02:30:17Z",
  "items": ["2.02", "9.01"],
  "isXBRL": true,
  "primaryDocument": "form8k.htm",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126039785/form8k.htm",
  "indexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126039785/0001140361-26-039785-index.htm"
}
```

**XBRL fact**

```json
{
  "type": "fact",
  "cik": "0000320193",
  "companyName": "Apple Inc.",
  "taxonomy": "us-gaap",
  "tag": "AccountsPayableCurrent",
  "label": "Accounts Payable, Current",
  "unit": "USD",
  "value": 5520000000,
  "end": "2008-09-27",
  "fiscalYear": 2009,
  "fiscalPeriod": "FY",
  "form": "10-K",
  "filed": "2009-10-27",
  "accessionNumber": "0001193125-09-214859"
}
```

### Before your first run

The SEC asks automated clients to identify themselves and can answer traffic
that does not with HTTP 403. Fill in **Contact email** with an address you
monitor — it is sent only to sec.gov, in the `User-Agent` header, and nowhere
else. Without one the Actor still declares itself by name and Store page, which
is fine for small runs; add the email before running large or scheduled jobs.

Full-text search covers 2001 onwards, serves 100 hits a page and stops at
10,000 hits for one query; narrow the dates or form types to reach past that.

### Pricing

Pay only for results:

| Result | Price |
|---|---|
| Filing or search hit | $10.00 per 1,000 |
| XBRL fact | $2.00 per 1,000 |
| Company profile | $15.00 per 1,000 |

Set a maximum spend per run in the run options and the Actor stops cleanly when it's reached.

### Limits to know about

These come from the SEC, not from this Actor:

- **Full-text search covers 2001 onwards** and will not return results past the 10,000th match for a query. Narrow by form type or date range to get under that ceiling.
- **The submissions file holds at least the most recent 1,000 filings.** Anything older needs *Include the full filing history*, which costs one extra request per archive file.
- **Downloading every XBRL fact is a big file** for a large filer. Naming the tags you want under *XBRL tags* is far faster and cheaper.
- **Rate limit.** The SEC asks for no more than 10 requests per second from an identified client. The default of 2 parallel requests stays well inside that. Raising it risks a temporary block.
- **XBRL only exists for filings from roughly 2009 onwards**, and small filers may have no tagged data at all.

### FAQ

**Do I need an SEC account or API key?** No. These endpoints are open and keyless. The only requirement is identifying your client, which the Actor does for you.

**Can I monitor new filings every day?** Yes. Use Company filings with a `dateFrom` of the last few days, or Full-text search with a date window, and schedule the Actor daily in Apify Console. Connect the dataset to Slack, Google Sheets, Zapier or Make.

**Why did a ticker return nothing?** The SEC's company list only covers issuers with a registered ticker. Funds, foreign private issuers and individual filers have a CIK but no symbol, so look those up by CIK.

**What is an accession number?** The SEC's unique ID for one submission, like `0001140361-26-039785`. Every filing row includes one, plus ready-made links to the document and its index page.

**Is this legal?** Yes. These are public APIs the SEC publishes for exactly this purpose, and they require no authentication. Automated access must comply with the SEC's privacy and security policy, which is why the Actor identifies itself and limits its request rate.

### Feedback

Found a bug or need a field that's missing? Open an issue on the Actor's **Issues** tab.

# Actor input Schema

## `mode` (type: `string`):

Filings for specific companies, an EDGAR full-text search, XBRL financial facts, or company profiles.

## `contactEmail` (type: `string`):

Strongly recommended. The SEC asks every automated client to name a contact address and can refuse undeclared traffic with HTTP 403. Use an address you monitor; it is sent only to sec.gov, in the User-Agent header. Left empty, the Actor identifies itself by name and Store page instead.

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

Ticker symbols (AAPL, MSFT) or CIK numbers (320193, CIK0000320193). Tickers are resolved through the SEC's own company list.

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

For Full-text search. Wrap a phrase in double quotes to match it exactly, for example "material weakness". EDGAR full-text search covers 2001 onwards.

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

Limit to these forms, such as 10-K, 10-Q, 8-K, S-1, 4, 13F-HR, DEF 14A. Leave empty for every form.

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

YYYY-MM-DD. Leave empty for no lower bound.

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

YYYY-MM-DD. Leave empty for no upper bound.

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

Applies to Company filings. The submissions file holds at least the most recent 1,000 filings.

## `includeOlderFilings` (type: `boolean`):

Fetches the SEC's extra archive files so you get every filing ever made, not just the recent set. Costs one extra request per archive file.

## `maxResultsPerQuery` (type: `integer`):

Applies to Full-text search. EDGAR pages 10 hits at a time and will not return results past the 10,000th.

## `xbrlTags` (type: `array`):

Specific tags to pull, such as Revenues, NetIncomeLoss, Assets, EarningsPerShareDiluted. Leave empty to download every fact the company has filed, which is a large file.

## `xbrlTaxonomy` (type: `string`):

Usually us-gaap. Other options include dei, ifrs-full and srt.

## `maxFactsPerCompany` (type: `integer`):

Facts are sorted newest first, so a low number gives you the most recent figures. When you name tags, the limit applies to each tag.

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

Stop the run after saving this many items. Leave empty for no limit.

## `maxConcurrency` (type: `integer`):

The SEC asks clients to stay under 10 requests per second. Leave this at 2 unless you know you need more; going high risks a temporary block of the IP.

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

Not needed. The SEC's APIs are open to datacenter traffic that identifies itself and respects the rate limit.

## Actor input object example

```json
{
  "mode": "companyFilings",
  "contactEmail": "you@example.com",
  "companies": [
    "AAPL"
  ],
  "searchQueries": [
    "\"material weakness\""
  ],
  "maxFilingsPerCompany": 100,
  "includeOlderFilings": false,
  "maxResultsPerQuery": 100,
  "xbrlTaxonomy": "us-gaap",
  "maxFactsPerCompany": 500,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "companies": [
        "AAPL"
    ],
    "searchQueries": [
        "\"material weakness\""
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("winterlock/sec-edgar-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "companies": ["AAPL"],
    "searchQueries": ["\"material weakness\""],
}

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

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

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

```

## CLI example

```bash
echo '{
  "companies": [
    "AAPL"
  ],
  "searchQueries": [
    "\\"material weakness\\""
  ]
}' |
apify call winterlock/sec-edgar-scraper --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0ezGellmsCOAlUWrA/builds/N0Q0CqV7SwVaKYQzg/openapi.json