# SEC 8-K Material-Event Watch (`nexgenwatch/sec-8k-event-watch`) Actor

Turns newly filed SEC Form 8-K / 8-K/A material-event filings on your issuers into a typed material-event feed.

- **URL**: https://apify.com/nexgenwatch/sec-8k-event-watch.md
- **Developed by:** [NexGen Watch](https://apify.com/nexgenwatch) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 8-k material-event alerts

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/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 8-K Material-Event Watch — New Filings on Watched Issuers

Turn newly filed **SEC Form 8-K / 8-K/A** material-event filings on the issuers you
watch into a **seed-zero, deterministic delta feed** — with the official 8-K item
codes preserved and a per-issuer source receipt on every run. First run seeds a
private baseline and emits **zero** alerts; later runs emit one delta per newly
filed 8-K. No historical dump, no inferred event beyond the issuer-reported item
codes.

### Who buys this

- **Event-driven analysts** — catch 8-K item 2.02 (results), 1.01 (material
  agreements), 5.02 (officer/director changes), 1.05 (cyber incidents) as they file.
- **IR / comms monitoring** — watch a peer set and get every new material event.

### What you get

- **`material_event_delta`** (watch mode) — one per newly filed 8-K/8-K/A:
  `delta_type` (`MATERIAL_EVENT` / `MATERIAL_EVENT_AMENDMENT`), `accession_number`
  (= `composite_key`), `cik`, `issuer_name`, `tickers`, `filed_date`, `report_date`,
  `item_codes` + `items` (code → official SEC item title), `primary_doc_url`.
- **`issuer_8k_filing`** (snapshot mode, `watchMode=false`) — the same record shape
  without baseline diffing.
- **`source_receipt`** — per-issuer terminal (`NORMAL` / `GENUINE_EMPTY` / `PARTIAL`
  / `BLOCKED`), request counters, canary status. Always pushed, never billed.

### Input

```json
{
  "watchedIssuers": ["AAPL", "MSFT", "TSLA", "JPM", "GS"],
  "itemCodes": ["1.01", "2.02", "5.02"],
  "includeAmendments": true,
  "lookbackDays": 30,
  "watchMode": true
}
```

Issuers are given as **CIK** (`320193` / `CIK0000320193`) or **ticker** (`AAPL`);
tickers are resolved against SEC's public `company_tickers.json`.

### Sample output (delta)

```json
{
  "record_type": "material_event_delta",
  "delta_type": "MATERIAL_EVENT",
  "accession_number": "0000320193-26-000011",
  "composite_key": "0000320193-26-000011",
  "cik": "320193", "issuer_name": "Apple Inc.", "tickers": ["AAPL"],
  "filed_date": "2026-04-30", "report_date": "2026-04-30",
  "item_codes": ["2.02", "9.01"],
  "items": [{"item_code": "2.02", "item_title": "Results of Operations and Financial Condition"}],
  "source_url": "https://data.sec.gov/submissions/CIK0000320193.json"
}
```

### Use with

`SEC 8-K Material-Event Watch` → your alerting / IR dashboard → an LLM summarizer.
Pairs with **SEC Form D Funding Leads Watch** and **SEC Form ADV Adviser Watch**.

### Pricing (pay-per-event)

- `material_event_alert` — per new 8-K delta (or snapshot record).
- `issuer_check` — per completed issuer surface check.
- `apify-actor-start` — reserved platform start event.
  Receipts are never billed. Seed rows, retries, duplicates, and blocked issuers are
  never billed.

### Limits & compliance

- Source: SEC EDGAR **public, logged-out** JSON (`data.sec.gov/submissions`,
  `www.sec.gov/files/company_tickers.json`). No key, no login, no CAPTCHA.
- SEC fair-access: a descriptive **User-Agent with a contact is required**
  (`secUserAgent`), self-throttled well below SEC's rate ceiling.
- 8-K filings are records, not investment advice. Item codes are preserved
  verbatim; an unknown code keeps a null title rather than a guess. A blocked or
  partial issuer never advances the baseline and never implies an absence.

### Pricing

| Event | FREE | BRONZE | SILVER | GOLD+ |
|---|---|---|---|---|
| Actor Start (`apify-actor-start`) | $0.02 | $0.02 | $0.02 | $0.02 |
| 8-K material-event alert (`material_event_alert`) | $0.05 | $0.045 | $0.04 | $0.0335 |
| Issuer surface check (`issuer_check`) | $0.10 | $0.09 | $0.08 | $0.067 |

Prices are the filed pay-per-event amounts per plan tier (PLATINUM/DIAMOND match GOLD). Blocked and refused runs do not intentionally charge value events.

# Actor input Schema

## `watchedIssuers` (type: `array`):

Issuers to monitor, each an SEC CIK (e.g. '320193' or 'CIK0000320193') or an exchange ticker (e.g. 'AAPL'). Tickers are resolved against SEC's public company\_tickers.json.

## `watchMode` (type: `boolean`):

When true, seed a private baseline and emit only post-baseline new 8-K deltas (first run emits zero). When false, emit snapshot issuer\_8k\_filing rows.

## `baselineKey` (type: `string`):

Named watch baseline (1-120 chars, \[A-Za-z0-9.\_:-]). Null derives a SHA-256 of the normalized filters.

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

Whether 8-K/A amendment filings qualify alongside 8-K.

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

Keep only 8-Ks reporting at least one of these official item codes (e.g. '1.01', '2.02', '5.02'). Empty keeps all. Filed item codes are always preserved.

## `sinceDate` (type: `string`):

Earliest 8-K filed date to include. Null uses lookbackDays from today.

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

When sinceDate is null, include 8-Ks filed within this many days of today.

## `emitDeltaTypes` (type: `array`):

Which watch-mode delta types to emit.

## `maxIssuers` (type: `integer`):

Maximum watched issuers to process this run.

## `maxFilingsPerIssuer` (type: `integer`):

Maximum matching 8-K/8-K/A filings to keep per issuer this run.

## `secUserAgent` (type: `string`):

Descriptive User-Agent with a real contact, e.g. 'NexGenData 8KWatch/1.0 you@example.org'. Required by SEC fair-access. Falls back to the SEC\_USER\_AGENT env var.

## Actor input object example

```json
{
  "watchedIssuers": [
    "AAPL",
    "MSFT",
    "TSLA",
    "JPM",
    "GS"
  ],
  "watchMode": true,
  "includeAmendments": true,
  "itemCodes": [],
  "lookbackDays": 30,
  "emitDeltaTypes": [
    "MATERIAL_EVENT",
    "MATERIAL_EVENT_AMENDMENT"
  ],
  "maxIssuers": 50,
  "maxFilingsPerIssuer": 100
}
```

# 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 = {
    "watchedIssuers": [
        "AAPL",
        "MSFT",
        "TSLA",
        "JPM",
        "GS"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgenwatch/sec-8k-event-watch").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 = { "watchedIssuers": [
        "AAPL",
        "MSFT",
        "TSLA",
        "JPM",
        "GS",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("nexgenwatch/sec-8k-event-watch").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 '{
  "watchedIssuers": [
    "AAPL",
    "MSFT",
    "TSLA",
    "JPM",
    "GS"
  ]
}' |
apify call nexgenwatch/sec-8k-event-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgenwatch/sec-8k-event-watch",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aZlw8qKyY0a4FoKcX/builds/EAr44TZ0PwHXHDl89/openapi.json