# SEC 8-K Event Monitor - CEO Exits, M\&A & Cyber Alerts (`datadeltas/sec-8k-monitor`) Actor

Item-filtered feed of NEW SEC 8-K filings straight from EDGAR — officer departures (5.02), completed M\&A (2.01), material agreements (1.01), auditor changes (4.01), bankruptcy (1.03), cyber incidents (1.05) and more.

- **URL**: https://apify.com/datadeltas/sec-8k-monitor.md
- **Developed by:** [Daniel Matthee](https://apify.com/datadeltas) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 new matching 8-k filing detecteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 8-K Event Monitor — CEO Exits, M\&A, Bankruptcy & Cyber Alerts

One clean feed of **new SEC 8-K filings, filtered by the material event you
actually care about** — pulled straight from EDGAR, the SEC's own system.
Pick your items (5.02 officer departures, 2.01 completed M\&A, 1.01 material
agreements, 4.01 auditor changes, 1.03 bankruptcy, 1.05 cyber incidents…),
schedule the actor, and every run emits **only filings you have not seen
before**. No duplicate rows, no re-reading yesterday's news.

Built for:

- **Traders & event-driven funds** — a CEO exit, a completed acquisition or a
  1.05 cyber disclosure is a tradeable event; get it as structured data
  minutes after it lands on EDGAR instead of waiting for a headline.
- **M\&A and credit analysts** — 2.01 completions, 1.01 material agreements,
  1.03 bankruptcies and 4.02 restatements across the whole US market, or
  narrowed to the names you cover.
- **Journalists & researchers** — auditor changes (4.01) and non-reliance
  restatements (4.02) are the classic early-warning pair, and this is the
  cheapest way to watch every filer for them at once.
- **Sales & GTM intelligence** — 5.02 filings name new officers the day they
  are appointed: new decision-maker, new budget, warm outreach.
- **Compliance & risk teams** — monitor your counterparties' CIKs for
  bankruptcy, delisting (3.01) and control changes (5.01).

### Why this one

- **The item filter is the product.** Every 8-K carries official item codes;
  this actor filters on them *before* you pay for a row, and ships the human
  label alongside each code so `5.02` reads as *"Departure/Election of
  Directors; Appointment/Compensation of Officers"*.
- **Real diff semantics.** State is the set of accession numbers already
  emitted — EDGAR's own permanent filing identity. A second run over the same
  window emits exactly zero rows, and a filing that was filtered out is never
  resurrected by later widening your item list.
- **Whole market or a watch-list, and a watch-list is cheap.** Tickers/CIKs
  are pushed into EDGAR's query itself, so watching 20 companies costs one
  small request — not a scan of every 8-K filed that week.
- **No API key.** EDGAR is open; the actor identifies itself with the
  `userAgent` you set, per the SEC's fair-access policy.

### Example output

```json
{
  "accessionNumber": "0001971213-26-000041",
  "cik": "0001971213",
  "ticker": "SBGI",
  "companyName": "Sinclair, Inc.",
  "formType": "8-K",
  "items": ["5.02", "9.01"],
  "itemLabels": [
    "Departure/Election of Directors; Appointment/Compensation of Officers",
    "Financial Statements and Exhibits"
  ],
  "filedAt": "2026-08-28",
  "periodOfReport": "2026-08-24",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1971213/000197121326000041/sbgi-20260824.htm",
  "indexUrl": "https://www.sec.gov/Archives/edgar/data/1971213/000197121326000041/0001971213-26-000041-index.htm",
  "detectedAt": "2026-08-31T09:48:55Z"
}
```

- `accessionNumber` is EDGAR's permanent id for the filing — use it to dedupe
  downstream and to join against any other EDGAR dataset.
- `items` are the official codes as filed; `itemLabels` are the matching human
  labels, in the same order.
- `filedAt` is when the filing hit EDGAR; `periodOfReport` is the date of the
  event being reported (often a few days earlier).
- `filingUrl` opens the 8-K document itself, `indexUrl` the filing index page.
- `ticker` is `null` for filers with no listed ticker — trusts, ABS shells and
  non-traded funds file plenty of 8-Ks. It is never guessed.

### Input options

| Option | Default | What it does |
|---|---|---|
| `items` | 1.01, 1.03, 1.05, 2.01, 4.01, 4.02, 5.01, 5.02 | Which item codes count as a match. Full official 1.01–9.01 enum with labels in the run form. Empty list = every item |
| `tickers` | none | Watch-list of tickers (e.g. `AAPL`). Resolved against SEC's official ticker file; multi-class tickers like `GOOG` and `BRK-B` resolve correctly |
| `ciks` | none | Watch-list of CIK numbers, any zero-padding. Combined with `tickers` |
| `formTypes` | `["8-K"]` | Add `8-K/A` to include amendments |
| `sinceDays` | 3 | Days of filings to scan by filing date. First run = your backfill |
| `maxItems` | 500 | Cap per run; anything over the cap emits on the next run |
| `userAgent` | placeholder | **Please set this.** SEC fair access requires a User-Agent identifying you, e.g. `acme-research ops@acme.com` |

Leave `tickers` and `ciks` empty to monitor the entire US market.

### How to use it

Schedule the actor and read each run's dataset:

1. Create an Apify Schedule — **hourly** on business days if you want events
   fast, **daily** if a morning digest is enough.
2. Pull `GET /v2/acts/{actorId}/runs/last/dataset/items?status=SUCCEEDED`
   after each run, or attach a webhook.

The first run backfills the `sinceDays` window. Every later run emits only
never-seen filings, so you can run it as often as you like without paying for
the same filing twice. `sinceDays=3` gives you a comfortable safety margin:
even if a scheduled run is skipped or fails, the next one still catches
everything.

Honest notes:

- **EDGAR only publishes on US business days.** Weekends, US market holidays
  and the hours before ~06:00 ET legitimately return zero new filings. A
  zero-row run is a successful run, not a failure.
- **Item codes come from EDGAR's index, not from reading the document.** They
  are exactly what the filer tagged. An event mentioned only in the narrative
  of an 8.01 "Other Events" filing will not appear under a specific item —
  that is the filer's choice, and no monitor can invent it.
- **A single window is capped at 10,000 filings** (EDGAR's own search limit).
  A 30-day whole-market backfill measured ~5,900 8-Ks, so it fits; if you ever
  see a warning about the window being too large, narrow `sinceDays` or use a
  watch-list.
- **Amendments are opt-in.** `8-K/A` filings are excluded unless you add them
  to `formTypes`, so a re-filed 8-K does not look like a fresh event.

Searches this actor answers: *SEC 8-K monitor*, *8-K item 5.02 alerts*,
*CEO departure feed*, *M\&A completion tracker*, *auditor change monitor*,
*EDGAR 8-K API*, *material event alerts*.

### Reliability

- A rejected User-Agent fails the run with a message naming the exact input to
  fix — it never silently reports a quiet market.
- If EDGAR changes a field in its search index, the affected filing is skipped
  with one clear schema-drift warning and the rest of the run continues.
- If a watch-list cannot be resolved because SEC's ticker file is unavailable,
  the run fails rather than emitting zero and looking like a quiet day.
- Requests are paced well under the SEC's published rate limit, with
  exponential backoff on throttling and server errors.
- Schema verified against live EDGAR responses; item enum tracked against the
  SEC's official 8-K item list.

### Pricing notes

You pay per **new matching filing**, plus a small per-company charge for the
filers scanned in the window and a flat per-run start fee. Two consequences
worth knowing:

- A quiet or fully-deduped run costs almost nothing — no matches, no
  per-filing charge.
- A **watch-list run only scans your watch-list**, so the per-company charge
  is a handful of companies rather than the whole market. Watching 20 tickers
  daily is a fraction of a cent in company checks.

### Changelog

- **0.1** — initial release: full official 8-K item enum with human labels,
  item + watch-list filtering, server-side CIK filtering, ticker resolution
  (incl. multi-class tickers), seen-accession diff feed, `8-K/A` opt-in.

# Actor input Schema

## `items` (type: `array`):

Which 8-K item codes count as a match. Default: the high-signal material events. Empty list = every item.

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

Optional watch-list of stock tickers (e.g. AAPL). Resolved to CIKs via SEC's official company\_tickers.json, then filtered inside EDGAR itself — so a watch-list run is fast and cheap. Multi-class tickers (GOOG, BRK-B) resolve correctly; unresolvable tickers log a warning and are skipped. Empty = whole market.

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

Optional watch-list of SEC CIK numbers (any zero-padding). Combined with tickers, and the right choice for filers with no listed ticker. Empty = whole market.

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

Which form types to monitor. 8-K/A amendments are opt-in.

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

How many days of filings to scan by filing date. On the first run this is your backfill; on later runs only never-seen filings are emitted. EDGAR publishes only on US business days, so weekends and holidays legitimately return zero.

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

Cap on new filings emitted in a single run (cost control). Filings over the cap are picked up on the next run.

## `userAgent` (type: `string`):

SEC's fair-access policy requires a User-Agent identifying who you are, e.g. 'my-company research you@example.com'. Please set your own contact here.

## Actor input object example

```json
{
  "items": [
    "1.01",
    "1.03",
    "1.05",
    "2.01",
    "4.01",
    "4.02",
    "5.01",
    "5.02"
  ],
  "formTypes": [
    "8-K"
  ],
  "sinceDays": 3,
  "maxItems": 500,
  "userAgent": "apify-actor-sec-8k-monitor daniel@apexwebstudio.co.nz"
}
```

# Actor output Schema

## `records` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("datadeltas/sec-8k-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("datadeltas/sec-8k-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 '{}' |
apify call datadeltas/sec-8k-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datadeltas/sec-8k-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/EMj5Sehqlm5Ch4oQG/builds/dkTLszLGvsgCrcs7a/openapi.json