# Smart Money Confluence - Insiders, Activists & Congress (`smartmoney-data/smart-money-confluence-score`) Actor

One smart money score per ticker from insider Form 4 trades, 13D/13G activist stakes, Form 144 planned sales and Congress stock trades. See where insiders, activists and politicians agree, with the filings as evidence. Pay per ticker.

- **URL**: https://apify.com/smartmoney-data/smart-money-confluence-score.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

$20.00 / 1,000 ticker signals

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 Confluence - Insiders, Activists & Congress

**When the CFO is buying, an activist just filed a 13D and a Senator bought too, you want to know. One score per ticker from four official disclosure sources, with the filings as evidence.**

| | |
|---|---|
| **Data** | SEC Form 4, Schedule 13D/13G, Form 144 and Congress STOCK Act disclosures |
| **Price** | $20 per 1,000 tickers, no subscription. Apify's free plan credit covers a first test. |
| **Freshness** | Latest filings on every run |
| **Try it** | The input is pre-filled with a working example: just click **Start**. |

**Example output**

| Ticker | Score | Signal | Evidence |
|---|---|---|---|
| XYZ | +64 | Bullish | CFO and 2 directors bought; activist 13D |
| ABC | -38 | Bearish | 3 Form 144 sales; CEO sold |

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

Each smart money source on its own is noisy. Insiders sell for taxes, politicians rebalance, 13Gs are often index funds. The signal is in **agreement**. This Actor reads SEC Form 4 insider trades, Schedule 13D/13G stakes, Form 144 planned sales and STOCK Act Congress trades, groups everything by ticker, and returns a score from -100 to +100 that shows where the different kinds of smart money line up.

### What you can do with it

- 🧭 **Watchlist check-up:** one row per stock you own: is smart money accumulating or heading for the exit?
- 🔎 **Discovery:** what did insiders, activists and politicians do in the last few hours and weeks, grouped by ticker, with confluence names first.
- 🚨 **Alerts:** schedule daily with `minSources: 2` and get only tickers where two or more sources agree.
- 🤖 **AI agents:** "What is smart money doing in NVDA?" answered with the score *and* the filings behind it.

### How the score works

Each source adds a capped component, so no single noisy source dominates:

| Component | Range | What moves it |
|---|---|---|
| Insider buying (Form 4 code P) | 0 to +35 | distinct buyers (1: 12, 2: 20, 3+: 25), +5 if a CEO/CFO/President/Chair buys, +5 if $1M+ in total |
| Insider selling (Form 4 code S) | 0 to -20 | dollar value, with Rule 10b5-1 plan sales at ¼ weight; -5 more for 3+ discretionary sellers |
| Planned sales (Form 144) | 0 to -10 | dollar value of notices, plan sales at ¼ weight |
| 13D / 13G stakes | 0 to +25 | new activist 13D +25, 13D amendment +10, new passive 13G +8, 13G amendment +3 |
| Congress (STOCK Act) | -20 to +20 | distinct members buying minus distinct members selling (1: 10, 2: 15, 3+: 20) |

Signal: **Strong bullish** ≥ 40, **Bullish** ≥ 15, **Neutral** between, **Bearish** ≤ -15, **Strong bearish** ≤ -40. Every row shows its `components`, `bullishSources`, `bearishSources` and up to 10 `evidence` filings with links.

### How to use it

#### Score your watchlist over the last 30 days

```json
{ "tickers": ["NVDA", "AAPL", "TSLA", "MSFT"], "lookbackDays": 30 }
```

#### Discovery: only tickers where 2+ sources agree, bullish

```json
{ "minSources": 2, "signalFilter": "bullish" }
```

#### SEC sources only (fast, no Congress)

```json
{ "tickers": ["META", "AMZN"], "sources": ["insiders", "stakes", "plannedSales"] }
```

### Output

One row per ticker. Example (illustrative values):

```json
{
  "ticker": "NVDA",
  "issuerName": "NVIDIA CORP",
  "score": 40,
  "signal": "Strong bullish",
  "activeSources": 5,
  "bullishSources": ["insider buying", "13D/13G stakes", "Congress"],
  "bearishSources": ["insider selling", "planned insider sales"],
  "components": { "insiderBuying": 17, "insiderSelling": -5, "plannedSales": -7, "activistStakes": 25, "congress": 10 },
  "insiderBuyers": 1,
  "insiderBuyValueUsd": 115000,
  "insiderSellValueUsd": 2315000,
  "insiderPlanSellValueUsd": 2315000,
  "plannedSaleNotices": 2,
  "plannedSaleValueUsd": 9490000,
  "activist13DFilings": 1,
  "maxStakePercent": 5.21,
  "congressBuyers": 1,
  "politicians": ["Alex Senator (Senate)"],
  "firstActivity": "2026-09-15",
  "lastActivity": "2026-10-09",
  "evidence": [
    { "source": "stake", "action": "stake", "date": "2026-09-28", "who": "Example Activist Partners LP", "role": "13D", "detail": "13D: 5.21% of Common Stock", "url": "https://www.sec.gov/Archives/edgar/data/…-index.htm" },
    { "source": "insider", "action": "buy", "date": "2026-09-19", "who": "Doe Jane", "role": "Chief Financial Officer", "valueUsd": 115000, "url": "…" }
  ]
}
```

The **`SUMMARY`** record shows how many filings each source read, failures, any source that was down, and the 10 strongest bullish and bearish tickers.

### Use it from code or an AI agent

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("smartmoney-data/smart-money-confluence-score").call(run_input={"tickers": ["NVDA", "AAPL"]})
for t in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(t["ticker"], t["score"], t["signal"], t["bullishSources"])
```

**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-confluence-score
```

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:

> Which of my watchlist stocks have insiders, activists and Congress buying at the same time?

**No-code:** schedule it and send new bullish tickers to Google Sheets, Slack, Zapier or Make.

> 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) · [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 ticker:** you're charged for each ticker signal returned, however many filings went into it. See the **Pricing** tab for current rates. Set a *maximum cost per run* and the Actor stops cleanly when it's reached.

### FAQ

**What's the difference between watchlist and discovery mode?**
With `tickers`, every filing for those companies in the lookback window is read and every ticker is returned, quiet ones as Neutral. Without tickers, the Actor reads the latest filings on EDGAR (up to 100 per form) and Congress reports in the window, and returns the tickers that show up.

**Why does Congress take longer?**
House reports are PDFs. Reading 150 reports per chamber takes a few minutes. Lower `maxCongressReportsPerChamber` or drop `congress` from `sources` for faster runs.

**Why are 10b5-1 plan sales weighted less?**
They are scheduled months in advance and say little about an insider's current view. Discretionary sales do.

**Does a high score mean I should buy?**
No. It means several groups with an information edge are acting in the same direction. Use it as a research starting point.

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

### Related Actors

- 👔 [SEC Insider Trades Tracker](https://apify.com/smartmoney-data/sec-insider-trades-tracker): every Form 4 transaction, row by row.
- 🏛️ [Congress Stock Trades Tracker](https://apify.com/smartmoney-data/congress-stock-trades-tracker): every disclosed trade by Senators and Representatives.
- 🎯 [13D & 13G Activist Stakes](https://apify.com/smartmoney-data/sec-13d-13g-activist-stakes): stake size, voting power and stated purpose.
- 🧮 [Hedge Fund 13F Consensus](https://apify.com/smartmoney-data/hedge-fund-13f-consensus): what the top funds bought together last quarter.

### 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 score (e.g. NVDA, AAPL). Every ticker is returned, quiet ones as Neutral. Leave empty for discovery mode: the latest insider, 13D/13G and Form 144 filings on EDGAR plus recent Congress trades, grouped by ticker.

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

Window of filings to score (watchlist mode) and of Congress reports (both modes).

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

Which disclosures to include.

## `minSources` (type: `integer`):

Discovery mode: only return tickers with activity in at least this many score components. Set 2 or more to see only confluence.

## `signalFilter` (type: `string`):

Keep all tickers, or only bullish (score 15 or more) or bearish (-15 or less) ones.

## `maxResults` (type: `integer`):

Discovery mode: return at most this many tickers, strongest first.

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

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

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

Discovery mode: how many of the most recent Form 4, Schedule 13D, Schedule 13G and Form 144 filings on EDGAR to read.

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

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

## `evidencePerTicker` (type: `integer`):

How many of the underlying filings to attach to each ticker (stakes, then buys, then sells, largest first).

## `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"
  ],
  "lookbackDays": 30,
  "sources": [
    "insiders",
    "stakes",
    "plannedSales",
    "congress"
  ],
  "minSources": 1,
  "signalFilter": "all",
  "maxResults": 100,
  "maxFilingsPerTicker": 40,
  "latestFilingsCount": 100,
  "maxCongressReportsPerChamber": 150,
  "evidencePerTicker": 10,
  "secUserAgent": "SmartMoney Data Confluence smartmoney-data@googlegroups.com"
}
```

# Actor output Schema

## `results` (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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("smartmoney-data/smart-money-confluence-score").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",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("smartmoney-data/smart-money-confluence-score").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"
  ]
}' |
apify call smartmoney-data/smart-money-confluence-score --silent --output-dataset

```

## MCP server setup

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

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/4vdXgdZfcSo6djcly/builds/rssLPpeaqJWMwpeI5/openapi.json