# Smart Money Buzz: Insider Buying Plus Reddit and HN Chatter (`scrapemint/smart-money-buzz-pipeline`) Actor

For each ticker, joins insider open-market buying (SEC Form 4) with social chatter on Reddit and Hacker News, scores 0 to 100, and tiers tickers converging, insider\_only, buzz\_only, or watch. Insiders buying while the crowd starts talking is the signal. Pure public data, no API keys.

- **URL**: https://apify.com/scrapemint/smart-money-buzz-pipeline.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Smart Money Buzz: Insider Buying Plus Reddit and HN Chatter

For each ticker, this pipeline joins two independent signals: **insiders buying their own stock on the open market** (SEC Form 4) and **the crowd starting to talk about it** on Reddit and Hacker News. Either alone is weak. Insider buying is informed but quiet; social buzz is loud but often uninformed. The edge is the **overlap** — smart money accumulating right as retail attention turns.

Every data source is plain HTTP or a public JSON API (**SEC EDGAR**, **Reddit RSS**, **HN Algolia**), with no browser, no proxy, and no API keys, so runs are fast and cheap.

### What it does

1. **Insider buying.** Pulls Form 4 open-market buys and sells (transaction codes P and S) for your tickers over the lookback window.
2. **Social chatter.** Searches Reddit and Hacker News for each ticker by cashtag (`$TICKER`) and, when you supply it, by company name. A keyword filter keeps matches precise so generic-word tickers do not pull noise.
3. **Join and score.** Per ticker, combines the insider buying, the mention counts, and how fresh both signals are into a 0 to 100 convergence score, then tiers each ticker.

### Scoring

The convergence score (0 to 100) is the sum of:

- **Insider buying (up to 45).** Open-market buy dollar value and the number of distinct buys, with a bonus when buyers outnumber sellers and net buying is positive.
- **Buzz (up to 40).** Combined Reddit plus Hacker News mention count, weighted up by Hacker News points and comment volume.
- **Velocity (up to 15).** How recent the freshest signal is. Both legs being recent is the most tradable setup.

Tiers:

- **converging** — insiders buying on the open market AND social chatter above the threshold, at the same time. The premium signal.
- **insider_only** — insider buying with little or no social chatter.
- **buzz_only** — active Reddit/HN chatter with no insider buying.
- **watch** — weak on both legs.

### Output

One row per ticker:

```json
{
  "ticker": "GME",
  "company": "GameStop",
  "tier": "converging",
  "convergenceScore": 78,
  "scoreBreakdown": { "insider": 38, "buzz": 25, "velocity": 15 },
  "insider": {
    "lookbackDays": 30,
    "buyCount": 2,
    "sellCount": 0,
    "buyValueUsd": 1400000,
    "netValueUsd": 1400000,
    "netBuying": true,
    "lastBuyDate": "2026-06-05",
    "topBuys": [{ "insider": "Ryan Cohen", "role": "Chairman", "shares": 100000, "price": 14.0, "valueUsd": 1400000, "date": "2026-06-05" }]
  },
  "buzz": {
    "windowHours": 168,
    "mentions": 11,
    "redditCount": 8,
    "hnCount": 3,
    "hnPoints": 64,
    "hnComments": 22,
    "lastBuzzDate": "2026-06-07",
    "topPosts": [{ "source": "reddit", "title": "GME insider just bought 100k shares", "url": "https://reddit.com/...", "points": null, "date": "2026-06-07" }]
  },
  "scoredAt": "2026-06-07T10:00:00.000Z"
}
````

### Input

- `tickers` — the companies to scan (uses the `$TICKER` cashtag for social search).
- `companyNames` — optional map of ticker to company name, e.g. `{"GME": "GameStop"}`, to catch posts that never use the cashtag.
- `insiderLookbackDays` — how far back to pull Form 4 buys/sells (default 30).
- `buzzMaxAgeHours` — how recent a post must be to count as buzz (default 168 = 7 days).
- `minMentions` — combined posts needed to count as having buzz (default 2).
- `includeInsider`, `includeBuzz`, `maxPostsPerSource`, `minScore` — toggles and caps.

### Pricing and combined cost

This actor charges per scored ticker: **watch $0.03**, **single-signal $0.07** (insider\_only or buzz\_only), **converging $0.12**. The first converging ticker per run is free so you can validate output.

This is a pipeline: it runs three child actors, and **each child also bills you for its own per-item usage** (sec-form4-insider-tracker per transaction, reddit-lead-monitor per post, hn-lead-monitor per item). Your total for a run is the tier charges above **plus** those child charges. Because all three children are plain HTTP / public-API calls, the per-run compute is small.

### Notes

- Open-market buys (code P) are the conviction signal. Grants, tax withholding, and option exercises are deliberately excluded because they are not discretionary buys.
- Reddit posts pulled via RSS carry no vote or comment counts, so Reddit contributes mention count only; Hacker News supplies the engagement weight.
- Supplying `companyNames` materially improves buzz coverage for tickers people rarely write as a cashtag.

# Actor input Schema

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

Stock tickers to scan, e.g. \["GME", "NVDA", "PLTR"]. The buzz search uses the cashtag form ($TICKER) to keep social matches precise.

## `companyNames` (type: `object`):

Map of ticker to company name, e.g. {"GME": "GameStop", "SOFI": "SoFi"}. Adds a second social search by name so you also catch posts that never use the cashtag. Optional but improves buzz coverage.

## `insiderLookbackDays` (type: `integer`):

How far back to pull insider open-market buys and sells from SEC Form 4.

## `buzzMaxAgeHours` (type: `integer`):

Only count Reddit and Hacker News posts newer than this. 168 = 7 days. Social attention is short lived, so keep this tight.

## `minMentions` (type: `integer`):

A ticker needs at least this many combined Reddit plus Hacker News posts to count as having buzz. Below it, buzz is treated as absent.

## `includeInsider` (type: `boolean`):

Pull insider open-market buys and sells. Turn off to score on social buzz alone.

## `includeBuzz` (type: `boolean`):

Pull Reddit and Hacker News chatter. Turn off to score on insider buying alone.

## `maxPostsPerSource` (type: `integer`):

Per query cap passed to the Reddit and Hacker News children. Controls cost.

## `minScore` (type: `integer`):

Drop and never charge tickers scoring below this 0 to 100 threshold. 0 keeps every ticker with any signal.

## `proxyConfiguration` (type: `object`):

Optional. EDGAR, Reddit RSS, and the HN Algolia API do not need a proxy, so the default is no proxy.

## Actor input object example

```json
{
  "tickers": [
    "GME",
    "PLTR",
    "SOFI"
  ],
  "companyNames": {},
  "insiderLookbackDays": 30,
  "buzzMaxAgeHours": 168,
  "minMentions": 2,
  "includeInsider": true,
  "includeBuzz": true,
  "maxPostsPerSource": 80,
  "minScore": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "GME",
        "PLTR",
        "SOFI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/smart-money-buzz-pipeline").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": [
        "GME",
        "PLTR",
        "SOFI",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/smart-money-buzz-pipeline").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 '{
  "tickers": [
    "GME",
    "PLTR",
    "SOFI"
  ]
}' |
apify call scrapemint/smart-money-buzz-pipeline --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/smart-money-buzz-pipeline",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Smart Money Buzz: Insider Buying Plus Reddit and HN Chatter",
        "description": "For each ticker, joins insider open-market buying (SEC Form 4) with social chatter on Reddit and Hacker News, scores 0 to 100, and tiers tickers converging, insider_only, buzz_only, or watch. Insiders buying while the crowd starts talking is the signal. Pure public data, no API keys.",
        "version": "0.1",
        "x-build-id": "L1AeGYjPWjFtzwE9w"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~smart-money-buzz-pipeline/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-smart-money-buzz-pipeline",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapemint~smart-money-buzz-pipeline/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-smart-money-buzz-pipeline",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapemint~smart-money-buzz-pipeline/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-smart-money-buzz-pipeline",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "tickers": {
                        "title": "Tickers",
                        "type": "array",
                        "description": "Stock tickers to scan, e.g. [\"GME\", \"NVDA\", \"PLTR\"]. The buzz search uses the cashtag form ($TICKER) to keep social matches precise.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyNames": {
                        "title": "Company names (optional)",
                        "type": "object",
                        "description": "Map of ticker to company name, e.g. {\"GME\": \"GameStop\", \"SOFI\": \"SoFi\"}. Adds a second social search by name so you also catch posts that never use the cashtag. Optional but improves buzz coverage.",
                        "default": {}
                    },
                    "insiderLookbackDays": {
                        "title": "Insider lookback (days)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "How far back to pull insider open-market buys and sells from SEC Form 4.",
                        "default": 30
                    },
                    "buzzMaxAgeHours": {
                        "title": "Buzz window (hours)",
                        "minimum": 1,
                        "maximum": 4320,
                        "type": "integer",
                        "description": "Only count Reddit and Hacker News posts newer than this. 168 = 7 days. Social attention is short lived, so keep this tight.",
                        "default": 168
                    },
                    "minMentions": {
                        "title": "Minimum mentions for buzz",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "A ticker needs at least this many combined Reddit plus Hacker News posts to count as having buzz. Below it, buzz is treated as absent.",
                        "default": 2
                    },
                    "includeInsider": {
                        "title": "Include insider buying",
                        "type": "boolean",
                        "description": "Pull insider open-market buys and sells. Turn off to score on social buzz alone.",
                        "default": true
                    },
                    "includeBuzz": {
                        "title": "Include social buzz",
                        "type": "boolean",
                        "description": "Pull Reddit and Hacker News chatter. Turn off to score on insider buying alone.",
                        "default": true
                    },
                    "maxPostsPerSource": {
                        "title": "Max posts per social search",
                        "minimum": 10,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Per query cap passed to the Reddit and Hacker News children. Controls cost.",
                        "default": 80
                    },
                    "minScore": {
                        "title": "Minimum convergence score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Drop and never charge tickers scoring below this 0 to 100 threshold. 0 keeps every ticker with any signal.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. EDGAR, Reddit RSS, and the HN Algolia API do not need a proxy, so the default is no proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```