# SEC EDGAR Filings API: 8-K, 10-K, 10-Q feed since 1994 (`bosco_labs/sec-filings-feed`) Actor

SEC EDGAR filings (8-K, 10-K, 10-Q, S-1, 13D, 13G, Form 4 and every other form) for any company or the whole market, live or back to 1994, from the SEC's own feeds. Filter by ticker, CIK, form, 8-K item and date; flags earnings releases (Item 2.02). Returns links to each filing, not its text.

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

## Pricing

from $1.00 / 1,000 sec filings

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 API: 8-K, 10-K, 10-Q feed since 1994

Get **SEC EDGAR filings as clean JSON**: 8-K current reports, 10-K annual reports, 10-Q, S-1,
13D, 13G, Form 4, DEF 14A, 20-F and every other form, for one company, a watchlist or the whole market, from filings accepted
minutes ago back to 1994. Each row has the company, CIK, ticker, form, filing date and exact
acceptance time, the **8-K item codes** (2.02 earnings, 5.02 officer changes, 1.01 material
agreements, ...) and direct links to the filing and its main document. For investors, news and alert services, compliance teams and AI agents.

**Pricing (pay per event):** $0.001 per filing ($1 per 1,000). No start fee. You only pay for
filings delivered, a scheduled feed never charges the same filing twice, and the Actor stops at
your max charge limit.

Everything comes straight from the SEC: the EDGAR submissions API, the EDGAR full and daily
indexes and the "latest filings" live feed. No third-party sites, no logins.

### What you get

One row per filing. Real output, Apple's Q4 2026 earnings release:

```json
{
  "accession_number": "0000320193-26-000024",
  "form": "8-K",
  "company_name": "Apple Inc.",
  "cik": "0000320193",
  "ticker": "AAPL",
  "filing_date": "2026-11-02",
  "accepted_at": "2026-11-02T16:30:23-05:00",
  "market_timing": "after_close",
  "report_date": "2026-11-02",
  "items": ["2.02", "9.01"],
  "item_descriptions": ["Results of Operations and Financial Condition", "Financial Statements and Exhibits"],
  "parties": null,
  "filing_index_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000024/0000320193-26-000024-index.htm",
  "primary_document_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000024/aapl-20261102.htm",
  "source": "submissions-api",
  "source_url": "https://data.sec.gov/submissions/CIK0000320193.json",
  "retrieved_at": "2026-11-05T16:23:00+00:00"
}
```

For whole-market searches, `parties` lists everyone on the filing with their role, e.g. a
SCHEDULE 13D's `Subject` (the company) and `Filed by` (the investor); `company_name` is then the
subject company.

### Earnings release dates

Set `earningsReleasesOnly` to get only 8-Ks with **Item 2.02 (Results of Operations and Financial
Condition)**: the moment a company published its quarterly results. `accepted_at` gives the exact
time and `market_timing` says whether it was `before_open`, during `market_hours` or
`after_close` (New York). That's an earnings calendar with history, for any SEC filer, including
companies that no longer exist.

### Input

```json
{ "tickers": ["AAPL", "MSFT", "NVDA"], "formTypes": ["8-K", "10-Q", "10-K"], "dateFrom": "2020-01-01", "maxResults": 1000 }
```

| Field | Meaning |
|---|---|
| `formTypes` | Exact EDGAR forms (`10-K/A` for amendments). `13D`/`13G` also match `SC 13D` and `SCHEDULE 13D`. Empty = all |
| `tickers` / `ciks` | Companies. Empty = the whole market |
| `earningsReleasesOnly` | 8-K Item 2.02 only |
| `itemCodes` | 8-Ks with any of these items, e.g. `5.02` |
| `dateFrom` / `dateTo` | Filing date range, back to 1993 |
| `lookbackDays` | Without `dateFrom`: the last N days. Empty: 7 days for the whole market; for tickers/CIKs, each company's newest filings |
| `maxResults` | Newest first, default 100 |
| `onlyNewSinceLastRun` | For schedules: only filings you haven't received with the same filters |

Running without input returns the 100 newest filings of any form, from the live feed.

### How fresh, how fast

- **Companies (tickers or CIKs):** one request per company to the SEC submissions API, which
  updates within minutes of a filing. A company's complete history back to 1994 takes a few
  seconds.
- **Whole market:** today's filings from the live feed, earlier days from the EDGAR daily index
  and quarterly full index (back to 1993). Each filing's items and main document come from its
  index page, at about 8 filings per second (the SEC allows 10 requests per second). Example: the
  50 latest earnings releases of a week in February 2015 took 52 seconds.

### Use cases

- **Event-driven trading and research:** earnings releases with exact times, officer changes
  (5.02), M\&A (1.01, 2.01), cybersecurity incidents (1.05), delistings (3.01).
- **Earnings calendars with history:** every Item 2.02 8-K of any company since 2004.
- **Activist and ownership tracking:** new 13D and 13G filings, with the subject company and filer.
- **IPO and capital-raise monitoring:** S-1, F-1, 424B prospectuses.
- **Alerts:** schedule every 15 minutes with `onlyNewSinceLastRun` and push new filings to Slack,
  email or a sheet.
- **AI agents and RAG:** links straight to the primary document for summarisation.

### Use with AI agents (MCP)

Agents can call this Actor as a tool through the
[Apify MCP server](https://github.com/apify/apify-mcp-server). Add this server URL to your MCP
client (Claude, Cursor, VS Code, ...):

```text
https://mcp.apify.com?tools=bosco_labs/sec-filings-feed
```

It loads this Actor as a tool, plus the tools that read its results (`get-actor-run`,
`get-dataset-items`). The hosted server signs you in with OAuth, or accepts your Apify token as
`Authorization: Bearer <APIFY_TOKEN>`. On the default server (`https://mcp.apify.com`), agents
can also find this Actor with `search-actors` and run it with `call-actor`.

Example prompts this Actor answers:

- *"When did Nvidia release its last four quarterly results, and was it before or after the market closed?"*
- *"Which companies filed a 13D in the last 7 days, and who filed it?"*
- *"Give me links to Apple's 10-K annual reports since 2015."*

For the first one, the agent passes:

```json
{"tickers": ["NVDA"], "earningsReleasesOnly": true, "maxResults": 4}
```

**Output for agents:** stable, typed JSON, one row per filing. Every row has `schema_version` and a `source_url` pointing to the SEC data it came from, plus `filing_index_url` and `primary_document_url` for the filing itself, so the agent can cite its source. For tickers or CIKs without dates, a run returns each company's newest filings (no date
needed for "the latest 10-K"); a whole-market run without dates reads the last 7 days. If
nothing matches, the run's status message says so and why.

**Cost:** $0.001 per filing, billed to the Apify account the MCP server is signed in with.

### FAQ

**Which forms?** All of them: whatever EDGAR accepts, from 10-K to N-PORT. Use the exact form
type as EDGAR names it.

**Since when do 8-Ks have items?** The numbered items (2.02 etc.) exist since August 2004; older
8-Ks have an empty `items` list. Filings from the 1990s have a date but no acceptance time, so
`market_timing` is `null` there.

**Why is the ticker empty sometimes?** Tickers come from the SEC's current ticker list. Delisted
companies, funds and private filers have none; their CIK always works.

**Company names?** For company searches, the current name in the SEC's records (Apple Inc. for
1994 filings too); for whole-market searches, the name on the filing.

**Do I get the documents' text?** No, links only (`primary_document_url`, `filing_index_url`).
That keeps rows small and cheap; fetch the documents you need.

**Legal basis?** SEC filings are US government public records. See LEGAL.md.

# Actor input Schema

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

EDGAR form types, exact match, e.g. \["8-K", "10-K", "10-Q"]; also S-1, 13D, 13G, 4, DEF 14A, 20-F, 6-K and any other form. Add "10-K/A" etc. for amendments. 13D and 13G also match the SC 13D and SCHEDULE 13D names. Empty = every form.

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

Company tickers, e.g. \["AAPL", "MSFT"]. Mapped to the CIK with the SEC's own company_tickers.json. Empty (and `ciks` empty) = the whole market.

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

SEC Central Index Keys as digits, leading zeros optional, e.g. \["320193"] for Apple. Use for delisted companies, funds and filers without a ticker. Empty = no CIK filter.

## `earningsReleasesOnly` (type: `boolean`):

true = only 8-Ks with Item 2.02 (Results of Operations and Financial Condition): the dates and exact times companies released earnings. Overrides `formTypes` and `itemCodes`. Default false.

## `itemCodes` (type: `array`):

Only 8-Ks reporting at least one of these items, as strings, e.g. \["5.02"] (director/officer change), "1.01" (material agreement), "2.01" (acquisition), "1.05" (cybersecurity incident). Without `formTypes`, reads 8-K and 8-K/A. Empty = no item filter.

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

Earliest filing date, YYYY-MM-DD, e.g. "2020-01-01". EDGAR's index goes back to 1993. Empty = `lookbackDays` days before today (or, for tickers/CIKs without `lookbackDays`, the company's newest filings).

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

Latest filing date, YYYY-MM-DD. Empty = today, including filings accepted minutes ago (live EDGAR feed).

## `lookbackDays` (type: `integer`):

Used only when `dateFrom` is empty: read filings from this many days back until today, e.g. 365. Empty = 7 days for the whole market; for `tickers`/`ciks`, empty = each company's newest filings (its last 1,000), so "latest 10-K of AAPL" needs no dates.

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

Maximum filings, newest first, e.g. 10 for a company's latest 10 filings. Default 100. The run stops once it has this many; you pay per filing returned.

## `onlyNewSinceLastRun` (type: `boolean`):

true = skip (and don't charge for) filings an earlier run with the same filters already delivered. For scheduled runs. Default false. Remembered in a named key-value store in your account.

## Actor input object example

```json
{
  "formTypes": [
    "8-K",
    "10-K",
    "10-Q"
  ],
  "earningsReleasesOnly": false,
  "maxResults": 50,
  "onlyNewSinceLastRun": 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 = {
    "formTypes": [
        "8-K",
        "10-K",
        "10-Q"
    ],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("bosco_labs/sec-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 = {
    "formTypes": [
        "8-K",
        "10-K",
        "10-Q",
    ],
    "maxResults": 50,
}

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

```

## MCP server setup

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