# SEC Insider & Corporate Catalyst Radar (`herazur/sec-corporate-catalyst-insider-radar`) Actor

Monitor SEC EDGAR for Form 4 insider transactions, 8-K corporate events, 13D/13G ownership changes, executive changes, financings, acquisitions, and other evidence-backed corporate signals.

- **URL**: https://apify.com/herazur/sec-corporate-catalyst-insider-radar.md
- **Developed by:** [Furkan Toluç](https://apify.com/herazur) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 sec signal delivereds

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/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 Corporate Catalyst & Insider Signal Radar

Turn new SEC filings into monitor-ready corporate event signals—without market-data subscriptions, external AI APIs, cookies, or private credentials.

In the production benchmark, the radar monitored **60 companies**, discovered **2,128 supported filings** in a 120-day window, sampled and parsed **330 filings with 100% parse success**, produced **463 deterministic signals**, and suppressed **100% of 2,128 duplicate candidates** on the repeated scan.

### What you get

The Actor follows a focused pipeline:

```text
Ticker / CIK watchlist
→ official SEC EDGAR sources
→ accession-number deduplication
→ structured filing parser
→ deterministic event classification
→ prior-state comparison
→ evidence-backed signal
```

Use it as an SEC Filing Monitor, Form 4 Insider Trading tracker, SEC 8-K Monitor, 13D 13G Tracker, Insider Buying Monitor, Corporate Catalyst Monitor, or source for SEC Filing Alerts. It produces corporate-event intelligence, not investment advice.

### Supported filing types

| Filing | What is extracted |
|---|---|
| Form 4 / 4-A | Owners, roles, transaction code/date/security, shares, price, gross value, post-transaction ownership, direct/indirect ownership |
| 8-K | Explicit item numbers plus narrow text evidence for agreements, acquisitions/dispositions, bankruptcy, delisting, financing, and executive changes |
| Schedule 13D / 13D-A | Reporting persons, issuer, beneficial shares and percent; factual ownership deltas with stronger control-intent context |
| Schedule 13G / 13G-A | Reporting persons, issuer, beneficial shares and percent; passive major-holder entries/exits and changes |

The Actor accepts the familiar `SC 13D/G` input names and normalizes the SEC's newer `SCHEDULE 13D/G` structured filings to the stable output form names.

### Modes

#### `SNAPSHOT`

Returns supported filings within `lookbackDays` and their parsed signals. It uses temporary comparison state during the run but never changes monitoring history.

#### `MONITOR`

Loads persistent state, identifies unseen accession numbers, emits only new evidence, and saves state safely. The first run establishes a non-billable baseline and intentionally emits no signals or filing records. Schedule it after that baseline run for incremental alerts.

### Example input

```json
{
  "companies": [
    { "inputId": "aapl", "ticker": "AAPL" },
    { "inputId": "tsla", "cik": "0001318605" }
  ],
  "monitorId": "executive-watchlist",
  "forms": ["8-K", "4", "SC 13D", "SC 13D/A", "SC 13G", "SC 13G/A"],
  "mode": "MONITOR",
  "lookbackDays": 7,
  "userAgent": "Your Company SEC Radar sec-contact@example.com"
}
```

`inputId` is preserved in every output record. Tickers are resolved with the SEC's official company ticker file. CIKs are normalized to ten digits.

`monitorId` partitions persistent history in a named key-value store. Actor Tasks use their task ID automatically when `monitorId` is empty; set an explicit stable value for independent watchlists started directly through the API.

### Signal taxonomy

- Insider activity: `INSIDER_BUY`, `INSIDER_SELL`, `INSIDER_OPTION_EXERCISE`, `INSIDER_GIFT`, `INSIDER_CLUSTER_BUYING`, `INSIDER_CLUSTER_SELLING`
- Ownership: `ACTIVIST_STAKE_NEW`, `ACTIVIST_STAKE_INCREASE`, `ACTIVIST_STAKE_DECREASE`, `MAJOR_HOLDER_ENTRY`, `MAJOR_HOLDER_EXIT`
- Leadership: `CEO_CHANGE`, `CFO_CHANGE`, `OTHER_EXECUTIVE_CHANGE`
- Corporate events: `ACQUISITION`, `ASSET_SALE`, `MATERIAL_AGREEMENT`, `CREDIT_AGREEMENT`, `DEBT_FINANCING`, `EQUITY_FINANCING`, `BANKRUPTCY_SIGNAL`, `DELISTING_RISK`, `OTHER_MATERIAL_8K_EVENT`

No output contains `BUY`, `SELL`, `LONG`, `SHORT`, a target price, price prediction, or portfolio recommendation.

### Form 4 transaction rules

The parser reads official ownership XML and preserves SEC transaction-code evidence:

| Code | Interpretation | Signal treatment |
|---|---|---|
| `P` | Open-market purchase | `INSIDER_BUY`; eligible for buying clusters |
| `S` | Open-market sale | `INSIDER_SELL`; eligible for selling clusters |
| `A` | Grant/award | Parsed, but not mislabeled as an open-market buy and not emitted in the MVP taxonomy |
| `M` | Exercise/conversion | `INSIDER_OPTION_EXERCISE`; excluded from open-market clusters |
| `G` | Gift | `INSIDER_GIFT`; excluded from open-market clusters |

`grossValue` is calculated only when both shares and price are valid. Missing facts remain `null`.

### Insider clusters

A cluster requires at least **3 distinct insiders** with qualifying `P` purchases—or qualifying `S` sales—within a **7-calendar-day** window at the same issuer. Exact transaction fingerprints, repeated owners, grants, gifts, exercises, and duplicate amendments do not inflate the count.

Cluster output includes distinct insiders, transaction count, shares, known gross value, and window boundaries. Thresholds are centralized in `src/cluster.ts` for controlled future tuning.

### Schedule 13D / 13G monitoring

The Actor uses the official SEC EDGAR full-text index to discover filings where the watched company is the filing subject, including filings submitted under an outside holder's CIK. It parses both legacy HTML and current structured Schedule 13 XML.

In `MONITOR`, the latest percentage or share count is stored by issuer/reporting-person key. Amendments emit only when comparable factual values change. A 13D is treated as stronger control-intent evidence than a 13G; a 13G is never relabeled as activism solely because its percentage is large.

### 8-K detection

Explicit 8-K item numbers are the primary classifier:

| Item | Deterministic category |
|---|---|
| 1.01 | Material agreement; narrow cues distinguish credit or equity agreements |
| 1.03 | Bankruptcy/receivership |
| 2.01 | Acquisition or asset disposition, distinguished with narrow completion cues |
| 2.03 | Debt financing |
| 3.01 | Delisting/noncompliance risk |
| 3.02 | Unregistered equity financing |
| 5.02 | CEO, CFO, or other executive/director change |

The Actor does not perform sentiment analysis. Concise matched text is retained only as secondary evidence.

### Severity

Severity describes the operational materiality of the event category, not expected stock performance.

- `CRITICAL`: bankruptcy/receivership
- `HIGH`: delisting risk, control/major-holder changes, acquisitions or asset sales, CEO/CFO changes, financings, insider clusters, or an individual open-market transaction of at least $1 million
- `MEDIUM`: material agreements, other executive changes, or an individual open-market transaction of at least $100,000
- `LOW`: smaller insider transactions, gifts/exercises, and minor informational classifications

Rules are deterministic in `src/severity.ts`.

### Output

The default Dataset contains three record types:

- `SIGNAL` — primary value; charged only after successful Dataset delivery
- `FILING` — minimal traceability metadata for a newly processed filing; never custom-charged
- `ERROR` — structured, company-scoped failure; never charged

Every signal has `schemaVersion: "1.0"`, a stable `signalId`, an amendment-safe `economicEventId`, accession number, SEC URL, filing date, source form, deterministic severity, `changeTypes`, and evidence. Optional objects are consistently `null`; evidence lists are consistently arrays.

The `OUTPUT` key-value record contains summary counters designed for filters in n8n, Make, Zapier, or custom schedulers.

### API usage

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/herazur~sec-corporate-catalyst-insider-radar/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companies": [{"inputId":"aapl","ticker":"AAPL"}],
    "mode":"MONITOR",
    "lookbackDays":7
  }'
```

After the run, consume Dataset items with `recordType=SIGNAL`, or read `OUTPUT` first and continue only when `signalsGenerated > 0`. In n8n/Make/Zapier, schedule the Actor, wait for completion, read `OUTPUT`, then route signals by `signalType`, `severity`, `ticker`, or `inputId`.

### Scheduling recommendations

- Run the initial `MONITOR` once to establish the baseline.
- Schedule every 15–60 minutes for active watchlists, or daily for lower urgency.
- Keep the same `monitorId`, or leave it empty on a stable Actor Task so the task ID partitions monitoring history automatically.
- Use a stable `inputId` for downstream correlation.
- Provide a genuine SEC contact in `userAgent` or `SEC_USER_AGENT`.

### Official data and fair access

The Actor uses only public SEC infrastructure:

- `data.sec.gov/submissions/`
- `sec.gov/files/company_tickers.json`
- `efts.sec.gov/LATEST/search-index`
- `sec.gov/Archives/`

Requests use an identifiable User-Agent, a global default limit of five requests per second (hard-capped at eight), bounded processing, connection reuse from Node's `fetch`, exponential backoff with jitter, and explicit handling for 403/429/5xx responses. The SEC publishes a ceiling of no more than ten requests per second; see [SEC Developer Resources](https://www.sec.gov/about/developer-resources).

### Pricing

The single custom PPE event is `sec_signal_delivered`. It is triggered once per successfully delivered, unique structured signal with the stable signal ID as the billing idempotency key. Baselines, lookups, raw metadata, duplicates, unsupported forms, parse errors, `ERROR` records, and `FILING` records are not custom-charged.

Based on the measured benchmark cost, the launch recommendation is **$0.002 per signal ($2 per 1,000)** before tier discounts, with a review after representative hosted production runs. Price is configured in Apify Console and is intentionally not hard-coded in the Actor.

### Limitations

- This is deterministic event extraction, not legal, financial, or investment advice.
- 8-K classification covers the listed item categories only and does not attempt full-text semantic interpretation.
- Schedule 13 legacy HTML varies; missing percentages/shares produce no inferred change. Joint filers are represented as a stable semicolon-separated reporting-person group when structured XML supplies them.
- A holder name change between filings can prevent automatic comparison; the raw filing remains traceable.
- Schedule 13 discovery is bounded to the latest 100 matching EDGAR full-text results per watched CIK; exceptionally active issuers can require a shorter schedule interval.
- Form 4 code `A` grants are not emitted because the MVP taxonomy has no grant signal; they remain explicitly excluded from buying clusters.
- SEC availability, dissemination timing, corrected filings, and markup quality are outside the Actor's control.
- `lookbackDays` is capped at 365. This Actor is an event monitor, not a complete historical EDGAR bulk downloader.

### Responsible usage

Respect SEC fair access, identify your organization honestly, avoid redundant schedules, and independently review the linked filing before making legal, governance, employment, or investment decisions.

### Development

```bash
npm install
npm run validate
npm run benchmark
apify run --input-file examples/input.json
```

The repository includes 43 parser, state, amendment, schema, discovery, cluster, and billing tests; production Actor schemas; a Docker image; benchmark tooling; and Store listing copy.

# Actor input Schema

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

Companies to monitor. Each entry needs a stable inputId and either a ticker or CIK.

## `monitorId` (type: `string`):

Stable state partition for this watchlist. Actor Tasks automatically use their task ID when this is empty. Set this when running directly with multiple independent watchlists.

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

Supported event-driven SEC forms. Form 4/A is followed automatically when Form 4 is selected.

## `mode` (type: `string`):

SNAPSHOT emits recent results without changing history. MONITOR persists accession state and emits only newly observed results after its baseline run.

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

Recent calendar-day window to inspect (1–365).

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

Identifiable organization plus contact email or website, required by SEC fair-access policy. Can also be set with SEC\_USER\_AGENT.

## `maxRequestsPerSecond` (type: `integer`):

Global limit. The Actor caps this below the SEC's published ceiling.

## Actor input object example

```json
{
  "companies": [
    {
      "inputId": "aapl",
      "ticker": "AAPL"
    },
    {
      "inputId": "tsla",
      "cik": "0001318605"
    }
  ],
  "monitorId": "",
  "forms": [
    "8-K",
    "4",
    "SC 13D",
    "SC 13D/A",
    "SC 13G",
    "SC 13G/A"
  ],
  "mode": "MONITOR",
  "lookbackDays": 7,
  "userAgent": "Herazur SEC Catalyst Radar contact@herazur.com",
  "maxRequestsPerSecond": 5
}
```

# Actor output Schema

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

Dataset items. Filter recordType=SIGNAL for billable corporate-event intelligence.

## `summary` (type: `string`):

Counts suitable for automation filtering.

# 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("herazur/sec-corporate-catalyst-insider-radar").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("herazur/sec-corporate-catalyst-insider-radar").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 herazur/sec-corporate-catalyst-insider-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,herazur/sec-corporate-catalyst-insider-radar"
        }
    }
}

```

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/Y1PvSoznBNuk8TcOg/builds/k6cVhX6Q5lrYIIuQd/openapi.json