# Smart Money Alerts - Insider, 13D & Congress Trade Alerts (`smartmoney-data/smart-money-watchlist-alerts`) Actor

Schedule it and get only what's new since the last run: insider buys, discretionary insider sales, activist 13D stakes, large Form 144s and Congress trades for your watchlist or the whole market. Ready-made digest for Slack, Discord, Telegram or webhooks.

- **URL**: https://apify.com/smartmoney-data/smart-money-watchlist-alerts.md
- **Developed by:** [SmartMoney Data](https://apify.com/smartmoney-data) (community)
- **Categories:** Business, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 new alerts

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Smart Money Alerts - Insider, 13D & Congress Trade Alerts

**Schedule it once, get pinged only when something new happens: a CEO buys, an activist files a 13D, a Senator trades your stock.**

| | |
|---|---|
| **Data** | SEC Form 4, Schedule 13D/13G, Form 144 and Congress disclosures |
| **Price** | $10 per 1,000 alerts; runs with nothing new cost almost nothing, no subscription. Apify's free plan credit covers a first test. |
| **Freshness** | Every scheduled run, only what is new |
| **Try it** | The input is pre-filled with a working example: just click **Start**. |

**Example output**

| Alert | Ticker | Who | What |
|---|---|---|---|
| Insider buy | XYZ | J. Smith (CEO) | Bought $1.2M |
| Congress trade | ABC | Sen. A. Example | Purchase $15k-$50k |

*Illustrative rows; real runs return the full fields listed under Output.*

Every run checks SEC Form 4 insider trades, Schedule 13D/13G stakes, Form 144 planned sales and STOCK Act Congress trades, keeps the ones worth a notification, and returns **only what it hasn't reported before**. Each alert comes with a one-line headline and a link to the filing, plus a ready-made digest that it can post straight to Slack, Discord, Telegram or any webhook.

### What gets an alert (defaults)

| Source | Alerts on | Skipped by default |
|---|---|---|
| Form 4 | open-market buys ≥ $25K; discretionary sales ≥ $1M | 10b5-1 plan sales, grants, option exercises |
| Schedule 13D/13G | every activist 13D and 13D amendment | passive 13Gs (mostly index funds) |
| Form 144 | discretionary planned sales ≥ $1M | 10b5-1 plan sales |
| Congress | purchases and sales by Senators and Representatives | — |

Every threshold is an input, so you can loosen or tighten it.

### How to use it

1. Fill in your **watchlist** (or leave it empty to watch the whole market).
2. Optional: paste a **Slack or Discord webhook URL**, or a Telegram bot token and chat ID.
3. **Schedule** it in Apify (e.g. every 2 hours on weekdays). Each run reports only new alerts.

#### Watchlist, posted to Slack

```json
{ "tickers": ["NVDA", "AAPL", "TSLA"], "webhookUrl": "https://hooks.slack.com/services/…" }
```

#### Whole market, only big insider buys and activist stakes, start quiet

```json
{ "sources": ["insiders", "stakes"], "minInsiderBuyUsd": 250000, "baselineOnFirstRun": true, "monitorName": "big-buys" }
```

#### Congress purchases only

```json
{ "sources": ["congress"], "congressActions": ["buy"], "monitorName": "congress-buys" }
```

### Output

One row per new alert. Example (illustrative values):

```json
{
  "headline": "🟢 NVDA: Doe Jane (Chief Financial Officer) bought $115K — Form 4",
  "ticker": "NVDA",
  "issuerName": "NVIDIA CORP",
  "source": "insider",
  "action": "buy",
  "date": "2026-09-19",
  "who": "Doe Jane",
  "role": "Chief Financial Officer",
  "valueUsd": 115000,
  "isPlan": false,
  "url": "https://www.sec.gov/Archives/edgar/data/…-index.htm",
  "id": "3f9c0a1b2d4e5f60",
  "detectedAt": "2026-10-09T14:00:03.120Z",
  "monitorName": "default"
}
```

The key-value store also holds **`DIGEST`** (the same alerts as one message, ready to send anywhere) and **`SUMMARY`** (sources read, new vs remembered alerts, delivery errors).

### How "only new" works

Each alert gets a stable ID from its filing. A monitor (named by `monitorName`) remembers the IDs it delivered for 120 days, in a named key-value store in your account. Runs can overlap freely: anything already reported is skipped. If a run stops at your maximum cost, the alerts it didn't deliver are reported on the next run, not lost.

### Use it from code or an AI agent

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("smartmoney-data/smart-money-watchlist-alerts").call(run_input={"tickers": ["NVDA", "AAPL"]})
for a in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(a["headline"], a["url"])
```

**AI agents (Claude, ChatGPT, Cursor and other MCP clients):** connect the Apify MCP server with this Actor preloaded:

```text
https://mcp.apify.com/?tools=smartmoney-data/smart-money-watchlist-alerts
```

Add this URL as a remote MCP server or custom connector in your AI client, sign in with Apify (OAuth), then just ask, for example:

> Set up alerts for insider buys and Congress trades on AAPL, NVDA and TSLA.

> Part of the **SmartMoney Data** suite: [Insider Trades](https://apify.com/smartmoney-data/sec-insider-trades-tracker) · [Hedge Fund 13F Holdings](https://apify.com/smartmoney-data/sec-13f-hedge-fund-tracker) · [Congress Stock Trades](https://apify.com/smartmoney-data/congress-stock-trades-tracker) · [Form 144 Planned Sales](https://apify.com/smartmoney-data/sec-form-144-planned-insider-sales) · [13D/13G Activist Stakes](https://apify.com/smartmoney-data/sec-13d-13g-activist-stakes) · [8-K Material Events](https://apify.com/smartmoney-data/sec-8k-material-events) · [Smart Money Confluence](https://apify.com/smartmoney-data/smart-money-confluence-score) · [Short Squeeze Radar](https://apify.com/smartmoney-data/short-squeeze-radar) · [13F Consensus](https://apify.com/smartmoney-data/hedge-fund-13f-consensus)

### Pricing

**Pay per alert:** you're charged only for new alerts delivered. A run with nothing new costs only a little platform usage. See the **Pricing** tab for current rates.

### FAQ

**How often should I schedule it?**
For a watchlist, every 1–4 hours on weekdays is plenty. For the whole market, run it hourly: the market-wide EDGAR feeds show only the latest ~100 filings per form.

**I get a burst of alerts on the first run.**
That's everything from the lookback window. Set `baselineOnFirstRun: true` to start quiet instead.

**Can I run several watchlists?**
Yes. Give each schedule its own `monitorName`, and each keeps its own memory.

**Is this legal to use?**
Yes. All sources are public disclosures published by the SEC, the US Senate and the US House of Representatives.

### Related Actors

- 🧭 [Smart Money Confluence Score](https://apify.com/smartmoney-data/smart-money-confluence-score): the same sources rolled into one score per ticker.
- 👔 [SEC Insider Trades Tracker](https://apify.com/smartmoney-data/sec-insider-trades-tracker): full Form 4 history for research and backtests.
- 🏛️ [Congress Stock Trades Tracker](https://apify.com/smartmoney-data/congress-stock-trades-tracker): every disclosed trade, with reporting delay.

### Support

**Useful?** A short review on this page helps other people find it, and we read every one.

Found a bug or need a feature? Open an issue on the **Issues** tab or email **smartmoney-data@googlegroups.com**. We usually reply within a day.

*Data is provided for informational purposes only and is not investment advice.*

# Actor input Schema

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

US tickers to watch. Leave empty to watch the whole market (then schedule it hourly: the market-wide EDGAR feeds only show the latest ~100 filings per form).

## `monitorName` (type: `string`):

Each monitor remembers which alerts it already reported. Use a different name for each schedule or watchlist.

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

How far back each run looks. Anything already reported is skipped, so overlap between runs is fine; keep it longer than your schedule interval.

## `sources` (type: `array`):

Which disclosures to alert on.

## `minInsiderBuyUsd` (type: `integer`):

Alert on open-market insider purchases of at least this value.

## `minInsiderSellUsd` (type: `integer`):

Alert on open-market insider sales of at least this value.

## `minPlannedSaleUsd` (type: `integer`):

Alert on Form 144 notices of at least this value.

## `includePlanSales` (type: `boolean`):

Pre-scheduled plan sales are routine and skipped by default.

## `includePassiveStakes` (type: `boolean`):

13G filings are mostly index funds and other passive holders; only activist 13Ds alert by default.

## `congressActions` (type: `array`):

Alert on purchases, sales or both.

## `baselineOnFirstRun` (type: `boolean`):

On a monitor's first run, record what already exists without returning it, so you only ever get truly new alerts.

## `webhookUrl` (type: `string`):

POST the digest here after each run with new alerts. Works with Slack and Discord incoming webhooks and any JSON receiver (fields: text, content, alerts).

## `telegramBotToken` (type: `string`):

Send the digest to Telegram via your own bot.

## `telegramChatId` (type: `string`):

Chat or channel ID the bot posts to.

## `maxFilingsPerTicker` (type: `integer`):

Watchlist mode: upper bound on filings read per ticker for each SEC form.

## `latestFilingsCount` (type: `integer`):

Market-wide mode: how many of the most recent filings per form to read.

## `maxCongressReportsPerChamber` (type: `integer`):

Upper bound on Senate and House reports read in the lookback window.

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

The SEC asks automated clients to identify themselves as 'Company Name email@domain.com'. Put your own contact here for heavy use.

## Actor input object example

```json
{
  "tickers": [
    "NVDA",
    "AAPL",
    "TSLA",
    "MSFT",
    "AMZN"
  ],
  "monitorName": "default",
  "lookbackDays": 7,
  "sources": [
    "insiders",
    "stakes",
    "plannedSales",
    "congress"
  ],
  "minInsiderBuyUsd": 25000,
  "minInsiderSellUsd": 1000000,
  "minPlannedSaleUsd": 1000000,
  "includePlanSales": false,
  "includePassiveStakes": false,
  "congressActions": [
    "buy",
    "sell"
  ],
  "baselineOnFirstRun": false,
  "maxFilingsPerTicker": 40,
  "latestFilingsCount": 100,
  "maxCongressReportsPerChamber": 60,
  "secUserAgent": "SmartMoney Data Alerts smartmoney-data@googlegroups.com"
}
```

# Actor output Schema

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

No description

## `digest` (type: `string`):

No description

## `summary` (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 = {
    "tickers": [
        "NVDA",
        "AAPL",
        "TSLA",
        "MSFT",
        "AMZN"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("smartmoney-data/smart-money-watchlist-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 = { "tickers": [
        "NVDA",
        "AAPL",
        "TSLA",
        "MSFT",
        "AMZN",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("smartmoney-data/smart-money-watchlist-alerts").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 '{
  "tickers": [
    "NVDA",
    "AAPL",
    "TSLA",
    "MSFT",
    "AMZN"
  ]
}' |
apify call smartmoney-data/smart-money-watchlist-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,smartmoney-data/smart-money-watchlist-alerts"
        }
    }
}
```

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/XcjKvdEO4S0KqVec4/builds/KyQ3s1V2ySouOPbtU/openapi.json