# SEC EDGAR Filings Feed — 10-K, 10-Q, 8-K by Ticker (`keyman98/sec-edgar-filings-feed`) Actor

List SEC filings for any US-listed company by ticker or CIK, straight from the official SEC EDGAR API. Filter by form type (10-K, 10-Q, 8-K, S-1, Form 4...) and date range. Direct links to each filing and its main document.

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

## Pricing

from $2.00 / 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.

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 Feed

Get the latest SEC filings — **10-K**, **10-Q**, **8-K**, and every other form type — for any US public company, by ticker or by SEC CIK. Pulls data through the SEC's own official, public JSON API (**data.sec.gov**) — no HTML scraping of filing index pages, no third-party data provider — and exports the results to CSV, Excel, or JSON.

### What you get (output fields)

For each filing, one dataset row with:

- `ticker` / `cik` — as given in the input (ticker uppercased; null ticker if the row came from a CIK).
- `companyName` — company legal name as registered with the SEC.
- `formType` — SEC form type, e.g. `10-K`, `10-Q`, `8-K`.
- `filingDate` / `reportDate` — when the filing was submitted, and the period it covers (YYYY-MM-DD).
- `accessionNumber` — SEC accession number that uniquely identifies the filing.
- `primaryDocument` / `primaryDocDescription` — the filing's main document.
- `filingUrl` / `documentUrl` — public URL of the filing's index page, and of its primary document, on sec.gov.
- `items` — for 8-K filings, the reported item numbers (e.g. `["2.02", "9.01"]`); null otherwise.
- `fileNumber` — SEC file number, when available.
- `sic` / `sicDescription` — the company's industry classification code and description.
- `error` — set only on rows that could not be resolved (see below); null otherwise.

### Who it's for

- **Analysts and researchers** — pull a company's filing history without clicking through EDGAR's web interface.
- **Fintech and data products** — feed structured filing metadata into a pipeline, dashboard, or alert.
- **8-K monitoring** — get notified about material events (earnings, leadership changes, acquisitions) as soon as a company files.

This Actor does not extract or interpret filing contents — only public metadata and a direct link to the document. See "Limitations" below.

### How to use

1. **Tickers** — one or more US stock tickers, e.g. `AAPL`, `MSFT`. Matched against SEC's own ticker list.
2. **CIKs (optional)** — SEC Central Index Keys, for companies without a ticker or when you already know the CIK.
3. **Form types (optional)** — e.g. `10-K`, `10-Q`, `8-K`. Leave empty for every form type a company has filed.
4. **Filed from / Filed until (optional)** — restrict to a date range, format `YYYY-MM-DD`.
5. **Run the Actor.** Each matching filing becomes one row, most recent first.

### Input example (JSON)

```json
{
  "tickers": ["AAPL", "MSFT"],
  "ciks": [],
  "formTypes": ["10-K", "10-Q", "8-K"],
  "dateFrom": "",
  "dateTo": "",
  "maxFilingsPerCompany": 20
}
```

### Output example (JSON)

```json
{
  "ticker": "AAPL",
  "cik": 320193,
  "companyName": "Apple Inc.",
  "formType": "8-K",
  "filingDate": "2026-07-30",
  "reportDate": "2026-07-30",
  "accessionNumber": "0000320193-26-000018",
  "primaryDocument": "aapl-20260730.htm",
  "primaryDocDescription": "8-K",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/0000320193-26-000018-index.htm",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/aapl-20260730.htm",
  "items": ["2.02", "9.01"],
  "fileNumber": "001-36743",
  "sic": "3571",
  "sicDescription": "Electronic Computers",
  "error": null
}
```

### If a ticker or CIK is not found

That entry becomes one **error row**: `error` is set to a short explanation, every other field is null. The run does not fail, the rest of the list keeps running, and **you are not charged** for that row.

### Pricing

Pay only for filings actually returned, after filters — nothing charged for a ticker/CIK that could not be resolved. Pricing model: **pay-per-event**.

| Event | When it's charged | Price |
| --- | --- | --- |
| `filing-scraped` | a filing was returned in the results (after filters) | 0.002 USD |

### Limitations

- Metadata only: no parsing of the filing's text, tables, or XBRL financial data — `documentUrl` links straight to the SEC's own document if you need the full content.
- `formType` matching is exact, not fuzzy: filtering on `10-K` does **not** also include `10-K/A` amendments — add both explicitly if you want them.
- `maxFilingsPerCompany` caps how many matching filings come back per company, for predictable run time and cost on companies with decades of history.
- Very old filings (roughly pre-2015, company-dependent) live in secondary SEC pages; this Actor follows up to 5 of them per company when needed to satisfy a date filter or a high `maxFilingsPerCompany` — beyond that, older filings may not be returned.
- Works only for SEC-registered entities — not international-only companies.

### FAQ

#### Am I charged if a ticker or CIK is not found?

No. You are only charged for filings actually returned in the results.

#### How do I get a company's CIK?

Use the ticker input instead — this Actor looks it up automatically against SEC's own ticker list. If a company has no ticker, its CIK is on its EDGAR filer page (`sec.gov/cgi-bin/browse-edgar?action=getcompany&company=<name>`).

#### What's the difference between 10-K, 10-Q, and 8-K?

A **10-K** is the annual report, a **10-Q** is the quarterly report, and an **8-K** reports a specific material event (earnings release, executive change, acquisition) as soon as it happens — filed year-round, not on a fixed schedule.

#### How far back can I go?

There's no fixed limit — SEC EDGAR's electronic filings start in the mid-1990s for most companies. Set `dateFrom` to pull older filings; see "Limitations" on how far this Actor follows them.

#### Does this respect SEC's rate limits?

Yes. Every request declares a User-Agent as required by SEC, and stays at or below 5 requests/second — half of SEC's own 10 requests/second limit for automated access.

#### Can I monitor a company for new filings over time?

Yes. Set `dateFrom` to your last check's date and run the Actor on a schedule (Apify's built-in scheduler) — each run then only returns filings submitted since then.

#### Can I filter by multiple form types or multiple companies at once?

Yes. `tickers`, `ciks`, and `formTypes` all accept multiple values.

#### Can I use this through the Apify API or an MCP server?

Yes, like any Apify Actor — through the standard Apify API, or through the Apify MCP server if you use Claude, Cursor, or another MCP-enabled client.

### Export

Results can be downloaded from the Apify dataset as JSON, CSV, or Excel, or accessed via the Apify API.

# Actor input Schema

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

US stock tickers (e.g. "AAPL"). Looked up against SEC's official ticker list. Leave empty if you only use CIKs.

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

SEC Central Index Keys, with or without leading zeros (e.g. "320193" or "0000320193"). Use this if a company has no ticker (e.g. it's not publicly traded stock, or you already know the CIK).

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

Only keep filings of these form types (e.g. "10-K", "10-Q", "8-K"). Leave empty to keep every form type.

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

Only keep filings filed on or after this date. Format: YYYY-MM-DD.

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

Only keep filings filed on or before this date. Format: YYYY-MM-DD.

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

Stop after this many matching filings for each company (most recent first), to keep cost and run time predictable.

## Actor input object example

```json
{
  "tickers": [
    "AAPL",
    "MSFT"
  ],
  "ciks": [],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "maxFilingsPerCompany": 20
}
```

# Actor output Schema

## `results` (type: `string`):

All results in the default dataset (JSON, CSV, Excel).

# 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",
        "MSFT"
    ],
    "ciks": [],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("keyman98/sec-edgar-filings-feed").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",
        "MSFT",
    ],
    "ciks": [],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("keyman98/sec-edgar-filings-feed").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",
    "MSFT"
  ],
  "ciks": [],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ]
}' |
apify call keyman98/sec-edgar-filings-feed --silent --output-dataset

```

## MCP server setup

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

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/vShLIxiO7fRfMEo28/builds/TEz5umacF3Q8KZFzL/openapi.json