# SEC EDGAR Filings - US Public Company Disclosure Metadata (`j0401/sec-edgar`) Actor

SEC EDGAR filings as structured metadata (public, no API key): search filings by full text, form, company or date and get company, form, dates, SIC, 8-K items and the document index URL - not the document text. Also a company's profile with its recent filings, and the 10,434-company ticker list.

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

## Pricing

from $0.03 / 1,000 sec filing records

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 - US Public Company Disclosure Metadata

US public company disclosure filings with the SEC, as **structured
metadata** - full-text searchable since 2001 by keyword, form type, company or
date. Straight from EDGAR, with **no API key**.

### Low cost

**From $0.00005 per record, down to $0.00003 at Gold.** Pay only for the records
you actually receive - the whole corpus stays searchable, you are never billed
for the scan behind it.

### Why metadata, not documents

EDGAR stores the filing documents; this actor returns the **record about each
filing**, which is what most systems actually want to index, join or alert on:

- **The company** - every filer name and CIK on the filing
- **The form** - `10-K`, `10-Q`, `8-K`, `DEF 14A`, `S-1`, `13F-HR`, `Form 4`
  and the rest, plus the root form and file type
- **The dates** - filing date and period ending
- **The classification** - SIC industry code, incorporation states, business
  states and locations
- **8-K items** - the event item numbers (e.g. 2.02 results, 5.02 officer
  changes) where the filing carries them
- **The accession number** and the public document-index URL

### Three modes

- **`filings`** (default) - the full-text search across all of EDGAR. Query by
  keyword, form, company or date window.
- **`company`** - one company's profile (name, SIC, tickers) plus its most recent
  \~1,000 filings, by `cik`.
- **`tickers`** - the listed-company directory: **10,434** companies with CIK,
  name, ticker and exchange.

### Filter it

- **Keyword** - `query="revenue"` or a `"quoted phrase"`; the word is matched
  across the full text of every filing, so it can appear anywhere in a document.
- **Form type** - `forms="10-K"`, `forms="8-K"`, `forms="10-K,10-Q"`.
- **Company** - `entityName="Apple"` (all Apple-named filers) or
  `ciks="320193"` (one exact company).
- **Date window** - `filedFrom="2026-01-01"`, `filedTo="2026-09-30"`. A date
  window must be combined with a keyword, form type or company - EDGAR's full-text
  search cannot search by date alone (a bare window is rejected, not silently
  empty).

### Example inputs

**Recent 8-Ks** - the newest 8-K filings, latest first.

```json
{ "forms": "8-K", "maxResults": 100 }
```

**Keyword inside a form** - full-text search across every 10-K.

```json
{ "query": "revenue", "forms": "10-K", "filedFrom": "2026-01-01", "maxResults": 50 }
```

**One company's filings** - exact CIK.

```json
{ "ciks": "320193", "forms": "10-K", "maxResults": 25 }
```

**A company's profile and recent filings** - `mode=company`.

```json
{ "mode": "company", "cik": "320193", "maxResults": 100 }
```

**Look up a ticker** - `mode=tickers`.

```json
{ "mode": "tickers", "ticker": "AAPL" }
```

### Example output

**One filing** (abridged - every record carries the full field set) -
`ciks=320193, forms=10-K`:

```json
{
 "platform": "sec-edgar",
 "mode": "filings",
 "recordType": "filing",
 "accessionNumber": "0000320193-25-000079",
 "form": "10-K",
 "fileDate": "2025-10-31",
 "periodEnding": "2025-09-27",
 "ciks": "0000320193",
 "companyNames": "Apple Inc.  (AAPL)  (CIK 0000320193)",
 "sics": "3571",
 "incorporationStates": "CA",
 "items": "",
 "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/"
}
```

**`mode=aggregate` is not offered** - EDGAR's search returns counts, not group
rollups; narrow with `forms` or a date window instead.

### Notes on the data, from the source

- 🔴 **10,000 is a hard ceiling.** EDGAR's full-text search will not return a
  count above 10,000. When a query matches more, the run summary reports
  `totalCapped: true` and `truncated: true` and the count as "10,000 or more" -
  it is never presented as exact. Narrow it with a `forms` value or a `filedFrom`
  / `filedTo` window.
- **`items` is often empty.** The 8-K item numbers are present where EDGAR
  indexes them and blank on many filings, so treat it as "where recorded".
- **A company's `mode=company` list is its most recent ~1,000 filings**, which
  is what the submissions endpoint returns - older filings live in separate
  archive files this actor does not walk.
- **The `User-Agent` is set** - EDGAR requires it and answers 403 without one.
  No key, no account, no login.
- **`sourceUpdatedAt` carries today's date** after confirming EDGAR has accepted
  filings in the last 30 days.

# Actor input Schema

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

EDGAR full-text search, e.g. 'revenue' or a "quoted phrase". Blank = no keyword restriction.

## `forms` (type: `string`):

Comma-separated form types, e.g. '10-K,10-Q' or '8-K'.

## `ciks` (type: `string`):

One or more company CIK numbers, comma-separated, e.g. '320193' (Apple).

## `entityName` (type: `string`):

Company name to search, e.g. 'Apple' (matches all Apple-named filers).

## `filedFrom` (type: `string`):

Earliest filing date, YYYY-MM-DD.

## `filedTo` (type: `string`):

Latest filing date, YYYY-MM-DD.

## `cik` (type: `string`):

A company CIK for mode=company, e.g. '320193'.

## `ticker` (type: `string`):

A ticker symbol filter for mode=tickers, e.g. 'AAPL'.

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

filings = EDGAR full-text search over all filings (default). company = one company's profile and its recent filings (requires cik). tickers = the listed-company ticker directory.

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

Cap the number of records returned (0 = default 100). Records are charged individually; there is no per-run charge cap.

## Actor input object example

```json
{
  "query": "",
  "forms": "",
  "ciks": "",
  "entityName": "",
  "filedFrom": "",
  "filedTo": "",
  "cik": "",
  "ticker": "",
  "mode": "filings",
  "maxResults": 100
}
```

# Actor output Schema

## `recordsUrl` (type: `string`):

SEC EDGAR Filings - US Public Company Disclosure Metadata records - as JSON

## `datasetUrl` (type: `string`):

No description

## `runUrl` (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 = {};

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

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

```

## MCP server setup

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

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/FohUJDsOMnvIKZNV7/builds/5IsIBec6JjvzwzARt/openapi.json