# SEC EDGAR Filings Monitor: 8-K, 10-K, 10-Q, 13F by Ticker (`ailu_studio/sec-edgar-filings-monitor`) Actor

Monitor SEC EDGAR filings (8-K, 10-K, 10-Q, 13F, S-1 and more) for any list of tickers or CIKs. Returns new and changed filings with document URLs, dates and 8-K item codes from the official SEC submissions API. No login, no proxies.

- **URL**: https://apify.com/ailu_studio/sec-edgar-filings-monitor.md
- **Developed by:** [Ailu Studio](https://apify.com/ailu_studio) (community)
- **Categories:** Business, Automation, Agents
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 filing rows

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Monitor: 8-K, 10-K, 10-Q, 13F by Ticker

Monitor SEC EDGAR filings for any list of public companies and get them back as clean, flat rows. Give the Actor tickers (`AAPL`) or CIK numbers (`320193`), optionally a list of form types (`8-K`, `10-K`, `10-Q`, `13F-HR`, `4`, `S-1`, `DEF 14A`, ...) and a look-back window, and it returns each matching filing with its filing date, acceptance time, 8-K item codes, primary document link and filing-folder link. Built-in change detection tags every row as `new`, `updated` or `unchanged` against the previous run, so it works as a scheduled filings alert, as an MCP tool for AI agents, or as a one-off export. Data comes from the official SEC submissions API; no login, no proxies, no HTML scraping.

### Use cases

- Earnings and event alerts: get every new 8-K (with item codes such as 2.02 Results of Operations) for a watchlist within minutes of a scheduled run.
- Annual and quarterly report tracking: collect 10-K and 10-Q links for a portfolio as soon as they are filed.
- Fund holdings monitoring: watch 13F-HR filings of institutional investors by CIK.
- Insider activity: track Form 4 and Form 144 filings per company.
- AI agents and research pipelines: a small, predictable JSON table with stable ids and direct document URLs.

### Input

| Field | Default | Meaning |
|---|---|---|
| `companies` | `["AAPL","MSFT","NVDA"]` | Tickers or CIK numbers. Tickers are resolved via the SEC ticker list (fallback: EDGAR company search). Use CIKs for filers without a ticker. |
| `forms` | `["8-K","10-K","10-Q"]` | Form types to keep, exact match, case-insensitive. Empty list = every form. |
| `includeAmendments` | `true` | Also return `<form>/A` amendments of the selected forms. |
| `sinceDays` | `90` | Keep filings filed within the last N days. `0` = no date filter. |
| `outputMode` | `all` | `all` = every matching filing with a `changeType`; `changes` = only `new` + `updated` since the last run; `new` = only never-seen filings. |
| `stateStoreName` | `sec-edgar-state` | Key-value store that remembers seen filings. Use one name per watchlist. |
| `maxItems` | `200` | Maximum rows per run. Rows are sorted newest first across all companies before the cap is applied. |

### Output

| Field | Meaning |
|---|---|
| `id` | Stable key `<cik>:<accessionNumber>`. |
| `cik`, `ticker`, `companyName`, `exchange`, `sic`, `sicDescription` | Filer identity as recorded by the SEC. |
| `form` | Form type, e.g. `8-K`, `10-K/A`, `13F-HR`. |
| `filingDate`, `reportDate` | Filing date and period/event date (`YYYY-MM-DD`). |
| `acceptanceDateTime` | ISO 8601 UTC time EDGAR accepted the filing. |
| `items` | 8-K item codes, e.g. `["2.02","9.01"]`; empty for other forms. |
| `primaryDocument`, `primaryDocDescription` | Primary document file name and SEC description. |
| `documentUrl` | Direct link to the primary document. |
| `indexUrl` | Filing folder with all documents and exhibits. |
| `sizeBytes`, `isXBRL` | Submission size and whether it carries XBRL data. |
| `changeType`, `firstSeenAt`, `lastSeenAt` | Change status versus the previous run with the same `stateStoreName`. |
| `fetchedAt` | ISO 8601 UTC time the row was fetched. |

```json
{
  "id": "320193:0000320193-26-000024", "cik": 320193, "ticker": "AAPL", "companyName": "Apple Inc.", "exchange": "Nasdaq",
  "sic": "3571", "sicDescription": "Electronic Computers", "form": "8-K", "filingDate": "2026-11-02", "reportDate": "2026-11-02",
  "acceptanceDateTime": "2026-11-02T21:30:23.000Z", "items": ["2.02", "9.01"],
  "primaryDocument": "aapl-20261102.htm", "primaryDocDescription": "8-K",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000024/aapl-20261102.htm",
  "indexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000024/",
  "sizeBytes": 420455, "isXBRL": true, "changeType": "new",
  "firstSeenAt": "2026-11-03T15:00:00.000Z", "lastSeenAt": "2026-11-03T15:00:00.000Z", "fetchedAt": "2026-11-03T15:00:00.000Z"
}
```

The run summary (companies resolved, counts of new/updated/unchanged, errors) is stored in the `OUTPUT` record of the default key-value store.

### How it works and limits

- One request resolves all tickers (`https://www.sec.gov/files/company_tickers.json`); if that file is unavailable the Actor falls back to the EDGAR company-search endpoint, one request per ticker, accepting only exact ticker matches. Then one request per company reads `https://data.sec.gov/submissions/CIK##########.json`.
- Only the SEC "recent" block is read, which holds the latest ~1,000 filings per company (for very active filers this can cover less than a year). Older filings in the paginated history files are not fetched. Set `sinceDays` to `0` to get the whole recent block.
- Rate limits: the SEC fair-access policy allows at most 10 requests per second and requires a descriptive `User-Agent`. This Actor sends `apify-actor-sec-edgar-filings-monitor/0.1 (contact via Apify Store issues)` and stays at or below 4 requests per second, with retries and back-off on 429/5xx.
- Freshness: the submissions API is updated by the SEC continuously during EDGAR hours; a filing usually appears within minutes of acceptance. Schedule the Actor as often as you need alerts.
- Change detection: state is kept per company inside `stateStoreName`, so a company that fails in one run keeps its previous state and does not produce false `new` rows later. EDGAR never deletes filings; a filing that leaves the `sinceDays` window simply drops out of state and no `removed` rows are emitted. On the first run (or with a new `stateStoreName`) every filing is `new`; filings beyond `maxItems` are still recorded as seen.
- Not covered: filing contents (financial statements, XBRL facts, full text), exhibits other than the primary document link, and historic filings beyond the recent block. Unknown tickers are reported in the run summary and skipped; the run finishes with status `partial`.

### Pricing

Pay per result: **$2.00 per 1,000 rows** (`result` event). Platform usage is billed separately by Apify. Removed/free rows are not charged.

A default run (3 companies, 90 days of 8-K/10-K/10-Q) returns roughly 10 to 30 rows and takes a few seconds.

### Legal

Not affiliated with the U.S. Securities and Exchange Commission. Uses the public SEC EDGAR submissions API only. Data licence/terms: SEC data is in the public domain; access rules are described at https://www.sec.gov/os/accessing-edgar-data (fair-access policy: declare a User-Agent, at most 10 requests per second).

### FAQ

**Can I monitor companies that have no ticker, e.g. hedge funds for 13F?** Yes. Put the CIK number in `companies` (find it on EDGAR company search) and set `forms` to `["13F-HR"]`.

**Why is a filing from last year missing?** Either it is outside `sinceDays` (default 90 days), or the company files so much that it fell out of the SEC "recent" block of ~1,000 filings, which is the only block this Actor reads.

**How do I get only brand-new filings in a scheduled run?** Use `outputMode: "changes"` (or `"new"`) with a fixed `stateStoreName`. The first run establishes the baseline; later runs return zero rows when nothing was filed.

**Does it include exhibits or the full text?** No. Each row links to the primary document and to the filing folder, where all exhibits are listed. Fetch those yourself if you need the content.

**What happens when a ticker is misspelled?** The ticker is listed in the run summary `errors`, the other companies are processed normally and the run status is `partial`.

# Actor input Schema

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

Stock tickers (e.g. "AAPL", "BRK-B") or SEC CIK numbers (e.g. "320193" or "CIK0000320193"). Tickers are resolved through the official SEC ticker list; use the CIK for companies without a ticker (funds, private filers).

## `forms` (type: `array`):

Only return these SEC form types, e.g. \["8-K", "10-K", "10-Q"], \["13F-HR"], \["4"], \["S-1"], \["DEF 14A"]. Exact match, case-insensitive. Leave empty to return every form type.

## `includeAmendments` (type: `boolean`):

When true (default), amended filings such as 10-K/A or 8-K/A are returned together with the form they amend. Set false to skip all amendments.

## `sinceDays` (type: `integer`):

Only filings with a filing date within the last N days (default 90). 0 disables the date filter. Only the latest ~1,000 filings per company (the SEC 'recent' block) are checked, so very old filings are never returned.

## `outputMode` (type: `string`):

"all" (default) returns every filing that matches the filters, each tagged with changeType. "changes" returns only filings that are new or changed since the previous run with the same stateStoreName; "new" returns only never-seen filings. On the first run every filing counts as new.

## `stateStoreName` (type: `string`):

Name of the key-value store that remembers which filings were seen; change detection compares against it. Use one name per watchlist (e.g. "portfolio-13f"). A new name starts fresh, so its first run reports every filing as new. Default "sec-edgar-state".

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

Upper limit on returned rows for this run (default 200). Rows are sorted newest first across all companies before the limit is applied, so the newest filings are kept. Filings beyond the limit are still recorded as seen.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT",
    "NVDA"
  ],
  "forms": [
    "8-K",
    "10-K",
    "10-Q"
  ],
  "includeAmendments": true,
  "sinceDays": 90,
  "outputMode": "all",
  "stateStoreName": "sec-edgar-state",
  "maxItems": 200
}
```

# Actor output Schema

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

All rows in the default dataset.

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

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

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

```

## MCP server setup

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

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/tklBTrfzN0Nj9nfWc/builds/eNBgoe1YfRP7ImhsM/openapi.json