# SEC Filing Alerts — Watchlist 8-K Labels & Form 4 Digests (`kaz_kakyo/sec-filing-alerts`) Actor

Scheduled SEC EDGAR alert feed for a watchlist of tickers/CIKs. Classifies 8-K items to human labels and digests Form 4 insider trades (who, buy/sell, shares, price, $ value, post-holding) into clean JSON. Free official SEC data, no key.

- **URL**: https://apify.com/kaz\_kakyo/sec-filing-alerts.md
- **Developed by:** [Heim AI](https://apify.com/kaz_kakyo) (community)
- **Categories:** News, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 sec filing alerts — 8-k & form 4 watchlists

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Filing Alerts — Watchlist Feed with 8-K Classification & Form 4 Digests

**Point it at a watchlist of tickers, get a clean structured feed of every new SEC filing that matters — on a schedule.** 8-K material events come back with each item already classified to its plain-English label; Form 4 insider trades come back digested (who traded, buy or sell, how many shares, at what price, total dollar value, and shares held after). Straight from the free official SEC EDGAR API: no key, no scraping, no personal data — US public record.

### Who this is for

- **Investors & analysts** — one feed for a whole portfolio: earnings, leadership changes, insider buys and sells.
- **Fintech & AI agents** — typed JSON per filing, ready to drop into a model or database.
- **Journalists & researchers** — insider activity and material events across many companies at once.

### How to use it (zero setup)

1. Set your **watchlist** — stock tickers (`AAPL`, `TSLA`, `NVDA`) and/or SEC CIK numbers. Tickers are resolved automatically via the official SEC map.
2. Pick the **form types** to watch (default `8-K` + `4`). Add `13D`/`13G` for ownership stakes, `10-Q`/`10-K` for periodic reports.
3. Run it on a **schedule** with `sinceDays` matching the interval (default 7 = weekly).

A run has no memory of the previous run, so the look-back window *is* the dedup model: schedule at an interval no longer than `sinceDays`, and dedup downstream on `accessionNumber` (globally unique per filing).

### Example input

```json
{
    "watchlist": ["AAPL", "TSLA"],
    "formTypes": ["8-K", "4"],
    "sinceDays": 30,
    "maxItems": 100
}
````

### Example output — 8-K with classified items

```json
{
    "ticker": "TSLA",
    "cik": "0001318605",
    "companyName": "Tesla, Inc.",
    "formType": "8-K",
    "filingDate": "2026-07-02",
    "reportDate": "2026-07-02",
    "accessionNumber": "0001628280-26-046717",
    "filingUrl": "https://www.sec.gov/Archives/edgar/data/1318605/000162828026046717/0001628280-26-046717-index.htm",
    "itemsWithLabels": [
        { "code": "2.02", "label": "Results of Operations and Financial Condition" },
        { "code": "9.01", "label": "Financial Statements and Exhibits" }
    ],
    "insiderDigest": null
}
```

### Example output — Form 4 insider-trade digest

```json
{
    "ticker": "TSLA",
    "cik": "0001318605",
    "companyName": "Tesla, Inc.",
    "formType": "4",
    "filingDate": "2026-06-17",
    "accessionNumber": "0001104659-26-075213",
    "filingUrl": "https://www.sec.gov/Archives/edgar/data/1318605/000110465926075213/0001104659-26-075213-index.htm",
    "insiderDigest": {
        "insiderName": "Musk Elon",
        "roles": ["Director", "Officer", "10% Owner"],
        "officerTitle": "CEO",
        "transactions": [
            { "security": "Common Stock", "date": "2026-06-16", "code": "M", "action": "Acquired", "shares": 303960630, "pricePerShare": 23.34, "value": 7094441104, "sharesOwnedAfter": 727704534, "ownership": "Direct" },
            { "security": "Common Stock", "date": "2026-06-16", "code": "F", "action": "Disposed", "shares": 17531857, "pricePerShare": 404.66, "value": 7094441254, "sharesOwnedAfter": 710172677, "ownership": "Direct" }
        ],
        "summary": { "transactionCount": 2, "netShares": 286428773, "totalAcquiredValue": 7094441104, "totalDisposedValue": 7094441254, "codes": ["M", "F"] }
    }
}
```

If a Form 4's XML can't be fetched or parsed, that filing is **dropped and not charged** (the digest is the value over the free SEC feed). The run continues for the rest of the watchlist.

### Why not just use SEC's free RSS feeds?

SEC publishes a free per-company Atom feed (`browse-edgar?...&output=atom`) — fine for raw filing notifications. This actor adds what it doesn't:

- **Form 4 dollar digests.** The RSS entry is just a link to the filing; this actor fetches and parses the ownership XML into insider name, role, transaction code, shares, price, **dollar value**, and post-transaction holdings.
- **One call for a whole watchlist.** RSS is one feed per company — 20 names means 20 feeds you schedule and merge yourself. Here it's a single `watchlist` array in, one merged and deduped dataset out.
- **Structured JSON, not HTML.** The RSS `<summary>` spells out 8-K item labels, but as an HTML string you have to scrape. This actor returns `itemsWithLabels` as typed `{code, label}` pairs — built for databases and AI agents, not eyeballs.

In short: RSS notifies; this actor **classifies, digests, and merges**.

### Pricing

Pay per event: one `filing-alert` per filing delivered. `maxItems` caps the count, so you cap the spend. Unresolved watchlist entries (unknown ticker, missing CIK) and filings outside the window are never charged. No API key or subscription — the SEC source is free.

### Data source & fair use

[SEC EDGAR](https://www.sec.gov/edgar/sec-api-documentation) — the official US securities-filing system, public record by law. This actor uses the documented free JSON/XML endpoints with an identifying User-Agent and stays within SEC's 10 requests/second fair-access limit. It is not affiliated with or endorsed by the U.S. Securities and Exchange Commission. Filings are public data; anything you build on them is your responsibility.

***

*Found this useful? A review on the [actor page](https://apify.com/kaz_kakyo/sec-filing-alerts) helps other people find it — and tells me what to build next. Hit a problem? [Open an issue](https://apify.com/kaz_kakyo/sec-filing-alerts/issues) and I'll fix it fast.*

### Telemetry

Each run records one anonymous telemetry event to the developer's own storage: a salted hash of the caller account ID (never the raw ID), the run origin (e.g. web console vs API), and a timestamp. No inputs, results, or personal data are collected - this only measures adoption (distinct and returning users).

# Actor input Schema

## `watchlist` (type: `array`):

Companies to watch — stock tickers (e.g. `AAPL`, `TSLA`, `NVDA`) and/or SEC CIK numbers (e.g. `320193`). Tickers are resolved to CIKs via the official SEC map. Unknown entries are skipped and never charged.

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

Which SEC filing types to alert on. 8-K = material corporate events (item-classified); 4 = insider trades (digested with $ value); 13D/13G = ownership stakes; 10-Q/10-K = quarterly/annual reports. Amendments (…/A) are included.

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

Only include filings from the last N days. A run has no memory of the previous run, so this window is the dedup model — schedule the run at an interval <= this window, and dedup downstream on `accessionNumber` (unique per filing). Defaults to 7 (weekly schedule).

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

Maximum filings delivered per run (newest first). Keeps cost predictable — you are charged once per delivered filing.

## Actor input object example

```json
{
  "watchlist": [
    "AAPL",
    "TSLA",
    "NVDA"
  ],
  "formTypes": [
    "8-K",
    "4"
  ],
  "sinceDays": 7,
  "maxItems": 100
}
```

# Actor output Schema

## `alerts` (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 = {
    "watchlist": [
        "AAPL",
        "TSLA",
        "NVDA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kaz_kakyo/sec-filing-alerts").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 = { "watchlist": [
        "AAPL",
        "TSLA",
        "NVDA",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("kaz_kakyo/sec-filing-alerts").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "watchlist": [
    "AAPL",
    "TSLA",
    "NVDA"
  ]
}' |
apify call kaz_kakyo/sec-filing-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=kaz_kakyo/sec-filing-alerts",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Filing Alerts — Watchlist 8-K Labels & Form 4 Digests",
        "description": "Scheduled SEC EDGAR alert feed for a watchlist of tickers/CIKs. Classifies 8-K items to human labels and digests Form 4 insider trades (who, buy/sell, shares, price, $ value, post-holding) into clean JSON. Free official SEC data, no key.",
        "version": "0.0",
        "x-build-id": "vIeQK8GAwXLzYsthw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kaz_kakyo~sec-filing-alerts/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kaz_kakyo-sec-filing-alerts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/kaz_kakyo~sec-filing-alerts/runs": {
            "post": {
                "operationId": "runs-sync-kaz_kakyo-sec-filing-alerts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/kaz_kakyo~sec-filing-alerts/run-sync": {
            "post": {
                "operationId": "run-sync-kaz_kakyo-sec-filing-alerts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "watchlist"
                ],
                "properties": {
                    "watchlist": {
                        "title": "Watchlist (tickers or CIK numbers)",
                        "type": "array",
                        "description": "Companies to watch — stock tickers (e.g. `AAPL`, `TSLA`, `NVDA`) and/or SEC CIK numbers (e.g. `320193`). Tickers are resolved to CIKs via the official SEC map. Unknown entries are skipped and never charged.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "formTypes": {
                        "title": "Form types to watch",
                        "type": "array",
                        "description": "Which SEC filing types to alert on. 8-K = material corporate events (item-classified); 4 = insider trades (digested with $ value); 13D/13G = ownership stakes; 10-Q/10-K = quarterly/annual reports. Amendments (…/A) are included.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "8-K",
                                "4",
                                "13D",
                                "13G",
                                "10-Q",
                                "10-K"
                            ],
                            "enumTitles": [
                                "8-K — material events (item-classified)",
                                "4 — insider trades (digested)",
                                "13D — activist / >5% ownership",
                                "13G — passive >5% ownership",
                                "10-Q — quarterly report",
                                "10-K — annual report"
                            ]
                        },
                        "default": [
                            "8-K",
                            "4"
                        ]
                    },
                    "sinceDays": {
                        "title": "Look-back window (days)",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Only include filings from the last N days. A run has no memory of the previous run, so this window is the dedup model — schedule the run at an interval <= this window, and dedup downstream on `accessionNumber` (unique per filing). Defaults to 7 (weekly schedule).",
                        "default": 7
                    },
                    "maxItems": {
                        "title": "Max filings per run",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum filings delivered per run (newest first). Keeps cost predictable — you are charged once per delivered filing.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```