# SEC EDGAR Filing Monitor - New Filings by Ticker (`technicaldost/sec-edgar-filing-monitor`) Actor

Track new SEC filings for any list of US public companies by ticker or CIK. Filter by form type (10-K, 10-Q, 8-K, Form 4, 13F), get direct document links and 8-K item codes, and receive only filings you have not already seen. Official SEC EDGAR API, no key needed.

- **URL**: https://apify.com/technicaldost/sec-edgar-filing-monitor.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## SEC EDGAR Filing Monitor — New Filings by Ticker

**Watch any list of US public companies and get their new SEC filings the moment they appear — with direct document links, 8-K item codes, and no repeats.**

Give it tickers or CIK numbers, pick the form types you care about, and put it on a schedule. Each run returns only filings you have not already been sent, so it works as a clean feed into a research pipeline, a Slack alert or a database.

Built on the **official SEC EDGAR JSON API**. No API key, no scraping, no browser.

***

### What you get

```json
{
  "companyName": "Apple Inc.",
  "ticker": "AAPL",
  "cik": "0000320193",
  "form": "10-Q",
  "filingDate": "2026-07-31",
  "reportDate": "2026-06-27",
  "acceptanceDateTime": "2026-07-31T10:01:02.000Z",
  "items": [],
  "primaryDocDescription": "10-Q",
  "accessionNumber": "0000320193-26-000020",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000020/0000320193-26-000020-index.htm",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000020/aapl-20260627.htm",
  "filingDirectoryUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000020/",
  "sic": "3571",
  "sicDescription": "Electronic Computers",
  "entityType": "operating",
  "stateOfIncorporation": "CA",
  "fiscalYearEnd": "0926",
  "sizeBytes": 5946811,
  "isXBRL": true,
  "isInlineXBRL": true,
  "scrapedAt": "2026-08-17T17:18:55.386Z"
}
```

For 8-K filings, `items` carries the item codes that say **why** the 8-K was filed — `2.02` earnings, `5.02` officer departure, `1.01` material agreement — so you can route alerts by significance instead of reading every one.

***

### Main use cases

- **Earnings and event alerts.** Watch a portfolio for 8-K filings and trigger on the item codes that matter.
- **Insider trading feeds.** Form 4 filings for a watchlist, as they land.
- **13F position tracking.** Follow institutional managers quarter by quarter.
- **Financial research pipelines.** Pull 10-K and 10-Q document URLs straight into a parser or an LLM.
- **Compliance and IR monitoring.** Track what competitors and peers are filing.
- **Prospectus and offering tracking.** S-1, S-3 and 424B filings for capital-markets work.

***

### Quick start

Yesterday's 8-K filings for two companies:

```json
{
  "companies": ["AAPL", "MSFT"],
  "formTypes": ["8-K"],
  "onlyNew": true
}
```

Insider transactions across a watchlist:

```json
{
  "companies": ["NVDA", "TSLA", "AMD", "INTC"],
  "formTypes": ["4"],
  "onlyNew": true
}
```

A historical pull of annual reports:

```json
{
  "companies": ["0000320193"],
  "formTypes": ["10-K"],
  "onlyNew": false,
  "filedFrom": "2020-01-01",
  "maxFilingsPerCompany": 10
}
```

***

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `companies` | array | **required** | Tickers (`AAPL`, `BRK.B`) or CIKs (`320193`, `0000320193`). Mix freely. Up to 500. |
| `formTypes` | array | — | `10-K`, `10-Q`, `8-K`, `4`, `13F-HR`, `S-1`, `DEF 14A`… Empty means all forms. |
| `onlyNew` | boolean | `true` | Skip filings returned by an earlier run. |
| `maxFilingsPerCompany` | integer | `50` | Newest-first cap per company. |
| `maxFilings` | integer | `1000` | Hard cap on filings returned **and charged** this run. |
| `filedFrom` / `filedTo` | string | — | `YYYY-MM-DD` range, inclusive. |
| `stateStoreName` | string | `sec-edgar-state` | Named store holding the "already seen" list. |

#### Form-type matching

Matching is case-insensitive and **includes amendments**: asking for `10-K` also returns `10-K/A`. It will not over-match — asking for `4` returns `4` and `4/A` but never `424B5`.

***

### Running it on a schedule

1. Set your companies and form types, and save them as a **Task**.
2. Add a daily or hourly **Schedule** on that Task.
3. Leave `onlyNew` on.

Add a webhook to push new filings into Slack, a database or an LLM summariser as they arrive.

The "already seen" list is keyed on the SEC **accession number**, which is globally unique, and lives in a named Key-Value Store **on your own account**. Up to 100,000 accession numbers are remembered.

***

### Pricing

| Event | Price | When it happens |
|---|---|---|
| **Filing** | **$0.002** | One filing returned to you |
| Actor start | $0.001 | Once per run |

**You are not charged for:**

- filings you were already sent in an earlier run (with `onlyNew` on)
- tickers or CIKs that do not resolve to an EDGAR company
- failed requests or retries
- duplicate companies — `AAPL` and `320193` are recognised as one company and fetched once
- anything after the maximum charge you set for the run

**Worked example.** A daily 8-K watch over 50 companies returning ~8 new filings a day costs about `(8 × $0.002) + $0.001 = $0.017` per run, roughly **$0.51/month**.

#### How this compares

| Actor | Price per filing | Per run | Change detection |
|---|---|---|---|
| **This Actor** | **$0.002** | $0.001 | yes |
| `scrapemint/sec-8k-event-tracker` | $0.025 | — | — |
| `constructive_calm/sec-edgar-scraper` | $0.0004 | $0.01 | — |
| `nexgendata/startup-funding-tracker` | $0.08 | $0.01 | — |
| `constant_quadruped/sec-edgar-filings-scraper` | free | — | — |

Competitors' list prices as published on Apify Store on 2026-08-17; check current figures before relying on this table.

**Note there is a free alternative in this category.** `constant_quadruped/sec-edgar-filings-scraper` charges nothing. If a one-off filing list is all you need, it may suit you. This Actor is built for the recurring case: new-only monitoring with persistent state, multi-company watchlists, ticker resolution and amendment-aware form matching. Choose on the feature set, not on price alone.

***

### Using the API

```bash
curl -X POST "https://api.apify.com/v2/acts/technicaldost~sec-edgar-filing-monitor/run-sync-get-dataset-items?token=<TOKEN>" \
  -H 'Content-Type: application/json' \
  -d '{ "companies": ["AAPL"], "formTypes": ["8-K"], "onlyNew": false }'
```

**JavaScript — alert on earnings 8-Ks:**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('technicaldost/sec-edgar-filing-monitor').call({
    companies: ['AAPL', 'MSFT', 'NVDA'],
    formTypes: ['8-K'],
    onlyNew: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const f of items.filter((x) => x.items.includes('2.02'))) {
    console.log(`${f.ticker} filed results: ${f.filingIndexUrl}`);
}
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("<TOKEN>")

run = client.actor("technicaldost/sec-edgar-filing-monitor").call(run_input={
    "companies": ["NVDA", "TSLA"],
    "formTypes": ["4"],
    "onlyNew": True,
})

for f in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f["companyName"], f["form"], f["filingDate"], f["documentUrl"])
```

***

### Limitations

- **Metadata and links, not filing text.** The Actor returns each filing's metadata and direct document URLs. It does not download or parse the filing body, and does not convert filings to Markdown. Fetch `documentUrl` yourself if you need the contents — this keeps every run fast and cheap rather than charging everyone for a transformation most runs do not need.
- **The most recent ~1,000 filings per company.** That is what SEC's `submissions` endpoint returns directly, and it covers several years for most companies. Older filings live in separate archive files that this Actor does not currently page into.
- **No full-text search.** Search by company, not by keyword across all of EDGAR.
- **No financial statement values.** XBRL flags are reported so you know structured data exists, but the numbers are not extracted.
- **US SEC registrants only.**
- Filings appear once EDGAR publishes them; SEC's own dissemination timing applies.

***

### Related Actors

- **[USPTO Trademark Status Monitor](https://apify.com/technicaldost/uspto-trademark-status-monitor)** — the same change-detection pattern for US trademarks.
- **[UK Companies House Scraper & Company Intelligence](https://apify.com/technicaldost/uk-companies-house-intelligence)** — UK company records, officers and beneficial ownership.
- **[RSS Feed Scraper](https://apify.com/technicaldost/rss-feed-scraper)** — pair filing alerts with company news feeds.

***

### Data source and responsible use

Data comes from the **official SEC EDGAR API** (`data.sec.gov`) and SEC's published ticker-to-CIK file. SEC filings are public records.

This Actor follows SEC's [Programmatic Access](https://www.sec.gov/os/webmaster-faq#developers) guidance: it identifies itself with a descriptive User-Agent and paces requests well under SEC's 10-requests-per-second guidance.

Not affiliated with or endorsed by the U.S. Securities and Exchange Commission. Nothing here is investment advice.

# Actor input Schema

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

Stock tickers (AAPL, MSFT, BRK.B) or SEC CIK numbers (320193, 0000320193). You can mix both. Tickers are resolved against SEC's official ticker-to-CIK file, and duplicates of the same company are skipped automatically.

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

SEC form types to include, for example 10-K, 10-Q, 8-K, 4, 13F-HR, S-1, DEF 14A. Amendments are included automatically, so 10-K also returns 10-K/A. Leave empty for every form type.

## `onlyNew` (type: `boolean`):

Recommended for scheduled runs. The actor remembers every accession number it has returned, so a daily schedule only returns genuinely new filings — and you are only charged for those.

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

Caps how many matching filings are taken from each company, newest first.

## `maxFilings` (type: `integer`):

Hard cap on how many filings this run returns and charges for.

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

Only include filings on or after this date.

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

Only include filings on or before this date.

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

Named Key-Value Store on your account holding the list of filings already returned. Use different names to keep separate watchlists independent.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT"
  ],
  "formTypes": [
    "8-K"
  ],
  "onlyNew": true,
  "maxFilingsPerCompany": 50,
  "maxFilings": 1000,
  "stateStoreName": "sec-edgar-state"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `links` (type: `string`):

No description

## `runSummary` (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",
        "MSFT"
    ],
    "formTypes": [
        "8-K"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("technicaldost/sec-edgar-filing-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"
  ],
  "formTypes": [
    "8-K"
  ]
}' |
apify call technicaldost/sec-edgar-filing-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,technicaldost/sec-edgar-filing-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/bnpscx78WnZ1KlTMx/builds/lLGee506l27U5wlI0/openapi.json