# Stock Edge — Signals With a Public Track Record (`shane_reich/stock-edge-signals`) Actor

BUY/SELL/HOLD technical signals for US stocks — the only signal actor that logs every call and publishes its own live accuracy stats, wins and losses alike.

- **URL**: https://apify.com/shane\_reich/stock-edge-signals.md
- **Developed by:** [Shane Reich](https://apify.com/shane_reich) (community)
- **Categories:** AI, Agents, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 signal results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Stock Edge — Signals With a Public Track Record

**The only signal actor that grades its own homework.**

Every BUY / SELL / HOLD signal this actor emits is written to a permanent ledger,
graded against subsequent prices, and published — wins **and** losses. Run the free
`performance` mode any time and see the complete, unedited record. No cherry-picking,
no backtested fantasy curves, no "94% win rate" screenshots. If our signals are
mediocre this week, the ledger will say so. That's the product: signals you can
audit, from a tool that tells you the truth.

### What you get per call

One structured verdict per symbol:

```json
{
  "symbol": "AAPL",
  "signal": "BUY",
  "confidence": 0.71,
  "signal_strength": 4,
  "price": 214.32,
  "indicators": {
    "rsi": 41.2, "ma20": 210.11, "ma50": 205.87, "trend": "UPTREND",
    "roc10_pct": 2.4, "atr_pct": 1.9, "volume_ratio": 1.4, "score": 0.42
  },
  "data_source": "finnhub"
}
```

- **Multi-provider failover** — Finnhub, Twelve Data, Alpha Vantage. One source down, you still get data.
- **Batch mode** — up to 10 symbols per run for portfolio monitoring.
- **Agent-ready** — clean JSON, deterministic fields, callable via API or MCP. Built for AI agents that need a structured market read without parsing prose.
- **Honest failure states** — if we can't get enough real data, you get `INSUFFICIENT_DATA` and you are **not charged**. You pay for verdicts, not apologies.

### Modes & pricing

| Mode | What it does | Cost |
|---|---|---|
| `signal` | BUY/SELL/HOLD + indicators for up to 10 symbols | **$0.015** per delivered signal ($15.00 / 1,000) |
| `performance` | The full public track record (accuracy %, by-signal breakdown) | **free, always** |
| `resolve` | Maintenance: grades pending signals (runs on our schedule) | n/a |

**What is never charged:** errors, `INSUFFICIENT_DATA` results, and the `performance`
mode. A 10-symbol portfolio scan costs $0.15. No subscription, no minimum.

### Connect via MCP

Listed in the [official MCP registry](https://registry.modelcontextprotocol.io) as
`io.github.sreichsbb-stack/reich-tools`. Add to any MCP client (Claude, Cursor, VS Code):

```json
{
  "mcpServers": {
    "reich-tools": {
      "url": "https://mcp.apify.com?tools=shane_reich/stock-edge-signals,shane_reich/name-clearance-verdict"
    }
  }
}
```

### How signals are computed

No black box. The score combines RSI(14), MA20/MA50 trend, 10-day rate of change,
and volume confirmation, with an ATR volatility penalty on confidence. These are
transparent technical indicators — the full weighting is documented, and the live
ledger tells you exactly how well they're performing.

### What this is not

Not financial advice, not a get-rich system, and not a promise of future returns.
Technical signals are one input among many. We publish our accuracy precisely so
you can decide how much weight they deserve.

### Agentic payments (x402)

AI agents can run this Actor autonomously — no Apify account or API key required.
Pay per signal in USDC via the x402 protocol using a prepaid token from
`https://agi.apify.com/protocols/x402/prepaid-tokens`.

One event, one price: `signal-result` at $0.015. Errors and INSUFFICIENT\_DATA are never charged.
Checking the public track record (`performance` mode) is free — always, for everyone.

```
# Free: audit the track record first (wins AND losses, permanent ledger)
curl -s -X POST \
  -H "Authorization: Bearer $PREPAID_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "performance", "symbols": ["AAPL"]}' \
  "https://api.apify.com/v2/actors/shane_reich~stock-edge-signals/run-sync-get-dataset-items"

# Paid: get a live signal ($0.015 each)
curl -s -X POST \
  -H "Authorization: Bearer $PREPAID_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "signal", "symbols": ["AAPL"]}' \
  "https://api.apify.com/v2/actors/shane_reich~stock-edge-signals/run-sync-get-dataset-items"
```

***

*Part of the Reich "tools that tell you the truth" line — see also
[Name Clearance Verdict](https://apify.com/shane_reich/name-clearance-verdict).*

# Actor input Schema

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

signal = compute signals for symbols (charged per symbol). performance = free public accuracy stats from the ledger. resolve = grade past signals against current prices (maintenance; run on a daily schedule).

## `symbols` (type: `array`):

US stock tickers, e.g. AAPL, MSFT. Max 10 per run in signal mode. In performance mode, optionally filter stats to these symbols.

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

resolve mode only: grade signals older than this many days.

## Actor input object example

```json
{
  "mode": "signal",
  "symbols": [
    "AAPL"
  ],
  "lookbackDays": 1
}
```

# Actor output Schema

## `signals` (type: `string`):

No description

## `trackRecord` (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 = {
    "symbols": [
        "AAPL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("shane_reich/stock-edge-signals").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 = { "symbols": ["AAPL"] }

# Run the Actor and wait for it to finish
run = client.actor("shane_reich/stock-edge-signals").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 '{
  "symbols": [
    "AAPL"
  ]
}' |
apify call shane_reich/stock-edge-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=shane_reich/stock-edge-signals",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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