Forem: Alexander Schneider

How to Add a Sentiment Confirmation Layer to OpenAlgo with Python

Alexander Schneider — Wed, 18 Mar 2026 06:01:49 +0000

Most trading signals answer one question:

"Is there a setup?"

That is useful, but often incomplete.

A breakout can be technically valid and still fail because there is no real
attention behind it. A screener can return ten names that all look similar on
price, while only one of them is actually dominating discussion, news flow, or
prediction-market activity.

That is the gap I wanted to close with an OpenAlgo integration for the
Adanos Finance Sentiment API.

Adanos tracks stock-level attention and directional bias across:

Reddit
X.com
financial news
Polymarket

Instead of replacing OpenAlgo, the idea is to use Adanos as a
confirmation layer before execution.

Why this is useful for traders

OpenAlgo already gives you the execution and automation building blocks:

TradingView webhooks
ChartInk-driven workflows
Python strategies
broker routing and order execution

Adanos adds a second decision layer:

"Does this setup also have attention, bullish conviction, and multi-source support right now?"

That matters when you want to:

reject weak breakouts
rank multiple screener hits
avoid low-attention entries
combine technical setups with non-price signals

The integration model that makes sense

The cleanest way to integrate Adanos into OpenAlgo is not as a broker plugin.

It works much better as an external signal layer:

TradingView / ChartInk / Python strategy
        -> Adanos sentiment gate
        -> OpenAlgo order execution

That keeps responsibilities separate:

OpenAlgo stays the automation and execution engine
Adanos stays the sentiment intelligence layer

What data the gate uses

For each symbol, the gate pulls source-level detail from Adanos and computes a
small composite.

Useful fields:

buzz_score
bullish_pct
mentions or trade_count
trend

Useful derived metrics:

average_buzz
bullish_avg
conviction
source_alignment

That gives you trader-friendly filters like:

average_buzz >= 60
bullish_avg >= 55
block symbols where multiple sources are falling
prefer aligned sources over wide divergence

Architecture

Here is the basic flow for TradingView:

TradingView alert
  -> Python middleware
  -> Adanos API check
  -> OpenAlgo placeorder / placesmartorder

The same pattern works for ChartInk:

ChartInk screener
  -> Python filter
  -> Adanos ranking / sentiment check
  -> OpenAlgo order

And for native Python strategies:

strategy signal
  -> Adanos source fetch
  -> local composite decision
  -> OpenAlgo execution

A small Python sentiment gate

This example keeps the execution path untouched and only decides whether an
order should be sent:

signals = get_source_signals(symbol)
composite = build_composite(signals)

if composite["average_buzz"] < 60:
    return "BLOCK"

if composite["bullish_avg"] < 55:
    return "BLOCK"

if composite["falling_sources"] >= 2:
    return "BLOCK"

return "PASS"

The full working example I built for OpenAlgo does a bit more:

fetches Reddit, X.com, News, and Polymarket signals
handles nullable or partially missing source data safely
computes average_buzz, bullish_avg, conviction, and source_alignment
supports both placeorder and placesmartorder
defaults to dry-run mode

Important implementation details

There are a few things worth getting right if you build this seriously.

1. Do not point alerts directly at OpenAlgo if you want sentiment gating

If your TradingView or ChartInk webhook still points straight to:

/api/v1/placeorder
or /api/v1/placesmartorder

then you are bypassing the sentiment layer entirely.

The webhook must point to your middleware or filter endpoint first.

2. Protect the middleware

This is not optional.

If you expose a public order-forwarding endpoint, it needs inbound verification:

secret header
token check
signature check
or another equivalent mechanism

Otherwise anyone who can reach that endpoint can try to trigger trades.

3. Keep payload contracts explicit

Do not hand-wave the OpenAlgo schema.

If you forward to placeorder, keep the documented structure intact:

apikey
strategy
symbol
action
exchange
quantity
pricetype
product

If you forward to placesmartorder, include the additional smart-order fields
that endpoint expects, such as position_size.

4. Normalize symbol inputs

If your source system sends {stock} and OpenAlgo expects symbol, normalize
that explicitly in middleware.

A lot of integration bugs are just field-name mismatches.

Coverage matters

Sentiment data is not equally strong for every symbol.

Before automating anything live, validate the names you actually trade.

A good workflow is:

test a few target symbols manually
set minimum thresholds for buzz and bullish ratio
decide what happens on low or partial coverage

That last point matters more than most people think. A robust workflow should
not crash just because one source is unavailable.

Why I still think this is a good integration

I originally proposed this as an upstream OpenAlgo documentation/examples PR.
The maintainers decided not to merge it because third-party sentiment APIs are
outside their current roadmap.

That is a fair scope decision.

But the integration pattern itself is still strong.

For OpenAlgo users, this is useful because it adds something their chart,
screener, or broker connection does not already provide:

cross-source attention
bullish ratio
trend confirmation
signal prioritization

That is exactly the kind of external intelligence layer traders can benefit
from without changing their existing execution stack.

If you want to build this yourself

Useful links:

Adanos API docs: https://api.adanos.org/docs
Get an API key: https://adanos.org/reddit-stock-sentiment#api
OpenAlgo: https://github.com/marketcalls/openalgo

Start small:

run a dry-run middleware
log approved and rejected trades
compare the gated results vs. your raw signal stream
only then wire it into live order flow

That is the fastest way to see whether sentiment confirmation improves your own process.

adanos-cli: Stock & Crypto Sentiment Straight From Your Terminal

Alexander Schneider — Fri, 06 Mar 2026 08:04:05 +0000

Retail traders check sentiment by tab-switching between Reddit, X, and news sites. There is no single view. adanos-cli is that single view.

What is adanos-cli?

adanos-cli is a Python CLI that queries the Adanos Finance Sentiment API. It aggregates mention counts, buzz scores, and sentiment polarity from four sources:

Reddit — 50+ stock and crypto subreddits (r/wallstreetbets, r/stocks, r/cryptocurrency, etc.)
X / Twitter — FinTwit tweet and reply analysis
Polymarket — prediction market prices, liquidity, and trade volume
Financial News — RSS-sourced article sentiment

pip install adanos-cli
adanos onboard wizard
adanos stock TSLA --days 7

The Interactive Shell

Run adanos without arguments to enter an interactive shell. Plain text is interpreted as a query:

adanos-cli> How does TSLA look this week?

The CLI parses intent, routes to the right endpoints, and returns a formatted report. It handles English and German, $TICKER syntax, crypto pairs like BTC/ETH, and "vs" comparisons.

A lightweight NLP module classifies input into nine intent types (stock report, crypto compare, trending scan, briefing, watchlist report, search fallback, etc.) with zero external dependencies.

Slash commands map directly to CLI features:

adanos-cli> /scan --asset stocks --style daytrader
adanos-cli> /trending --platform reddit-stocks --dimension sectors
adanos-cli> /briefing --profile investor --days 30

Morning Scan for Day Traders

adanos scan --asset stocks --style daytrader --limit 10

The scanner pulls trending data from all four platforms, merges by ticker, and computes a consensus buzz score, cross-platform sentiment, and confidence rating (0-99). Confidence weighs source diversity and mention volume.

Results carry a directional signal: bullish, bearish, neutral, or hot (high buzz, unclear direction). Drill into a ticker:

adanos stock NVDA --days 1

This returns a per-platform breakdown with Reddit mentions, X tweet volume, Polymarket contract prices, and news sentiment.

Crypto Portfolio Monitoring

Create a watchlist once, query it daily:

adanos watchlist add portfolio --asset crypto --symbols BTC,ETH,SOL,AVAX
adanos watchlist add portfolio --asset stocks --symbols MSTR,COIN
adanos watchlist report portfolio --asset all --days 7

Watchlists live in ~/.config/adanos-cli/watchlists.json and plug into the briefing command:

adanos briefing --from-watchlist portfolio --days 1

Briefings show top movers and sector heat, scoped to your assets. Seven profile presets (starter, daytrader, swing, investor, crypto, research, portfolio) control focus and depth.

Quick Comparisons

Side-by-side across platforms:

adanos compare --platform reddit-stocks TSLA,NVDA,AMD --days 7

Or natural language:

adanos ask "TSLA vs NVDA"
adanos ask "crypto BTC/ETH"

The parser detects vs and / patterns, resolves them to compare endpoints, and returns a unified table.

AI Agent Integration

Every command supports --output json. Errors go to stderr as structured JSON. stdout always contains parseable output.

adanos --output json capabilities
adanos --output json endpoint list
adanos --output json stock AAPL --days 7

Design choices for automation:

Exit codes: 0 success, 1 runtime error, 2 auth/usage error
31 endpoint IDs map 1:1 to the OpenAPI spec, callable via adanos endpoint call <id>
capabilities returns a self-describing JSON manifest (version, commands, auth setup, endpoint count)

Cron job piping the daily scan into Slack:

adanos --output json scan --asset stocks --style daytrader --limit 5 \
  | jq '{text: .rows[:3] | map(.ticker + " " + .signal) | join(", ")}' \
  | curl -X POST -H 'Content-Type: application/json' -d @- "$SLACK_WEBHOOK"

Research and Discovery

# Top stocks by Reddit mentions today
adanos trending --platform reddit-stocks --dimension main --days 1 --limit 20

# Sector-level sentiment
adanos trending --platform reddit-stocks --dimension sectors

# Country exposure
adanos trending --platform news-stocks --dimension countries

# Search across a platform
adanos search --platform x-stocks "Microsoft"

Check data freshness:

adanos health --platform all
adanos stats --platform reddit-stocks

Direct Endpoint Access

The CLI exposes all 31 API endpoints as callable IDs:

adanos endpoint list
adanos endpoint call reddit-stocks.trending --days 1 --limit 10
adanos endpoint call x-stocks.stock --ticker AAPL --days 7
adanos endpoint call polymarket-stocks.compare --tickers TSLA,NVDA

Every OpenAPI path is callable with no additional setup.

How the Sentiment Engine Works

The API runs a VADER + Twitter-RoBERTa ONNX ensemble:

VADER handles lexicon-based polarity with 55 custom finance terms (earnings language, momentum phrases, meme-stock slang)
Twitter-RoBERTa (quantized ONNX, 126 MB) covers informal social text that rule-based scoring misses

Scores blend at 40/60 VADER/RoBERTa weight with a ±0.14 neutral threshold.

The Buzz Score (0-100) rolls mention volume, sentiment strength, upvote quality, subreddit diversity, and trend direction into one number. A soft-cap function compresses the upper range so 85+ requires genuine multi-source attention.

Installation & Setup

pip install adanos-cli
# or
pipx install adanos-cli

# Guided setup
adanos onboard wizard

# Or set an existing key
adanos config set --api-key sk_live_xxx

Requires Python 3.10+. Config lives in ~/.config/adanos-cli/config.json. Environment variables (ADANOS_API_KEY, ADANOS_BASE_URL) and CLI flags override it.

Free tier: 250 requests/month.

Automate Accounting PDFs from Gmail to Google Drive (No Re-Imports, No Duplicates)

Alexander Schneider — Wed, 11 Feb 2026 12:53:02 +0000

If you do bookkeeping once a month, you’ve probably lived this loop:

invoices arrive via Gmail (sometimes forwarded, replied-to, or resent)
you download the PDFs
you store them in Drive
you file them during bookkeeping (move/delete/rename)
and then automation re-imports the same PDFs again 😩

This post shows a Google Apps Script setup that:

✅ scans your entire Gmail (excluding spam/trash)

✅ exports PDF attachments into Google Drive folders by month (YYYY-MM)

✅ detects duplicates by content hash (MD5)

✅ never re-imports the same email again—even if you move/delete files in Drive

✅ still labels threads in Gmail for visibility (but does not rely on labels for correctness)

The core idea

Relying on a Gmail thread label to skip work is tempting, but it breaks this common scenario:

A thread gets labeled “processed”… then later a new reply comes in with a new PDF attachment.

If you skip by label, you miss that PDF.

Instead, we do two things:

1) Message-ID tracking (stored in PropertiesService)

Every Gmail message is processed exactly once.
This is what prevents re-imports after you manually move/delete files.

2) MD5 de-duplication per month folder

Forwarded invoices and resent PDFs won’t create duplicates in Drive.

We still set a label (pdf-imported) for visibility, but the automation does not depend on it.

What you’ll get in Google Drive

A structure like this:

4_Gmail-Files/
  2026-02/
    2026-02-11__MESSAGEID__A0__Invoice_123.pdf
    2026-02-14__MESSAGEID__A0__Receipt.pdf
  2026-03/
    ...

You can do monthly bookkeeping and manually move/delete files however you like. The importer won’t recreate them.

Step 1: Create a Drive folder

Create a folder in Google Drive (e.g. 4_Gmail-Files) and copy its folder ID from the URL:

https://drive.google.com/drive/folders/<FOLDER_ID>

Step 2: Add the Apps Script

Go to script.google.com → New project → paste this code into Code.gs.

Replace ROOT_FOLDER_ID with your own folder ID.

/**
 * Gmail → PDF attachments → Google Drive monthly folders (YYYY-MM)
 *
 * ✅ scans ALL mail (in:anywhere), excluding spam/trash
 * ✅ catches new replies in old threads via LOOKBACK window
 * ✅ stores PDFs in <ROOT>/<YYYY-MM>/
 * ✅ prevents duplicates:
 *    - message-id tracking (each Gmail message processed once)
 *    - MD5 content de-dupe (identical PDFs per month folder stored once)
 * ✅ Gmail thread label for visibility (not used for skipping)
 */

const ROOT_FOLDER_ID = "PASTE_YOUR_FOLDER_ID_HERE";

// Lookback window: must be large enough to catch “old thread, new reply”
const LOOKBACK_DAYS = 365;

const GMAIL_QUERY =
  `in:anywhere -in:spam -in:trash newer_than:${LOOKBACK_DAYS}d has:attachment filename:pdf`;

// Label threads where we actually saved at least one PDF (visibility only)
const THREAD_LABEL = "pdf-imported";

// Mark thread as read after saving something?
const MARK_THREAD_AS_READ = false;

// How many threads to process per run
const MAX_THREADS_PER_RUN = 50;

// Tracker sizing: large enough so you don’t “forget” processed messages
const MAX_TRACKED_MESSAGES = 30000;

// Must be >= LOOKBACK_DAYS (recommend bigger)
const KEEP_MESSAGE_IDS_DAYS = 900;

function run() {
  const root = DriveApp.getFolderById(ROOT_FOLDER_ID);
  const labelObj = THREAD_LABEL ? getOrCreateGmailLabel_(THREAD_LABEL) : null;

  const tracker = loadMessageTracker_();
  pruneMessageTracker_(tracker);

  const threads = GmailApp.search(GMAIL_QUERY, 0, MAX_THREADS_PER_RUN);
  if (!threads.length) {
    saveMessageTracker_(tracker);
    return;
  }

  // monthKey -> { monthFolder, md5Set }
  const monthCache = new Map();

  for (const thread of threads) {
    const messages = thread.getMessages();
    let savedAnyInThread = false;

    for (const msg of messages) {
      const messageId = msg.getId();

      // Prevent re-imports even if files are moved/deleted in Drive
      if (tracker.ids[messageId]) continue;

      const msgDate = msg.getDate();
      const monthKey = formatMonthKey_(msgDate);
      const { monthFolder, md5Set } = getMonthContext_(root, monthKey, monthCache);

      const attachments = msg.getAttachments({ includeInlineImages: false });

      for (let i = 0; i < attachments.length; i++) {
        const att = attachments[i];

        const originalName = att.getName() || `attachment_${i}.pdf`;
        const isPdf =
          att.getContentType() === "application/pdf" ||
          originalName.toLowerCase().endsWith(".pdf");
        if (!isPdf) continue;

        const blob = att.copyBlob();
        const md5 = md5Hex_(blob);

        // Content de-dupe in the month folder
        if (md5Set.has(md5)) continue;

        const safeName = sanitizeFilename_(originalName);
        const datePrefix = Utilities.formatDate(
          msgDate,
          Session.getScriptTimeZone(),
          "yyyy-MM-dd"
        );

        const uniqueDriveName = `${datePrefix}__${messageId}__A${i}__${safeName}`;

        monthFolder.createFile(blob).setName(uniqueDriveName);
        md5Set.add(md5);

        savedAnyInThread = true;
      }

      // Mark this Gmail message as processed (even if it had no PDFs)
      tracker.ids[messageId] = Date.now();
      tracker.order.push(messageId);
    }

    if (savedAnyInThread) {
      if (labelObj) thread.addLabel(labelObj);
      if (MARK_THREAD_AS_READ) thread.markRead();
    }
  }

  saveMessageTracker_(tracker);
}

// ===== Tracker (PropertiesService) =====

function loadMessageTracker_() {
  const props = PropertiesService.getUserProperties();
  const raw = props.getProperty("PDF_TRACKER_V1");
  if (!raw) return { ids: {}, order: [] };

  try {
    const obj = JSON.parse(raw);
    if (!obj.ids) obj.ids = {};
    if (!obj.order) obj.order = [];
    return obj;
  } catch (e) {
    return { ids: {}, order: [] };
  }
}

function saveMessageTracker_(tracker) {
  pruneMessageTracker_(tracker);
  PropertiesService.getUserProperties().setProperty("PDF_TRACKER_V1", JSON.stringify(tracker));
}

function pruneMessageTracker_(tracker) {
  const cutoff = Date.now() - KEEP_MESSAGE_IDS_DAYS * 24 * 60 * 60 * 1000;

  const newOrder = [];
  for (const id of tracker.order) {
    const ts = tracker.ids[id];
    if (!ts) continue;
    if (ts >= cutoff) newOrder.push(id);
    else delete tracker.ids[id];
  }
  tracker.order = newOrder;

  if (tracker.order.length > MAX_TRACKED_MESSAGES) {
    const removeCount = tracker.order.length - MAX_TRACKED_MESSAGES;
    for (let i = 0; i < removeCount; i++) {
      const id = tracker.order[i];
      delete tracker.ids[id];
    }
    tracker.order = tracker.order.slice(removeCount);
  }
}

// ===== Month context + MD5 =====

function getMonthContext_(rootFolder, monthKey, monthCache) {
  if (monthCache.has(monthKey)) return monthCache.get(monthKey);

  const monthFolder = getOrCreateSubfolder_(rootFolder, monthKey);

  const md5Set = new Set();
  const files = monthFolder.getFiles();
  while (files.hasNext()) {
    const f = files.next();
    const md5 = f.getMd5Checksum();
    if (md5) md5Set.add(String(md5).toLowerCase());
  }

  const ctx = { monthFolder, md5Set };
  monthCache.set(monthKey, ctx);
  return ctx;
}

function md5Hex_(blob) {
  const bytes = blob.getBytes();
  const digest = Utilities.computeDigest(Utilities.DigestAlgorithm.MD5, bytes);
  return digest
    .map(b => {
      const v = (b < 0 ? b + 256 : b);
      return (v < 16 ? "0" : "") + v.toString(16);
    })
    .join("");
}

// ===== Helpers =====

function formatMonthKey_(dateObj) {
  return Utilities.formatDate(dateObj, Session.getScriptTimeZone(), "yyyy-MM");
}

function getOrCreateSubfolder_(parentFolder, name) {
  const it = parentFolder.getFoldersByName(name);
  if (it.hasNext()) return it.next();
  return parentFolder.createFolder(name);
}

function sanitizeFilename_(name) {
  return String(name)
    .replace(/[\/\:*?"<>|]/g, "_")
    .replace(/\s+/g, " ")
    .trim();
}

function getOrCreateGmailLabel_(labelName) {
  let label = GmailApp.getUserLabelByName(labelName);
  if (!label) label = GmailApp.createLabel(labelName);
  return label;
}

Step 3: Authorize the script

In Apps Script:

1) Select function run

2) Click Run

3) Accept permissions (Gmail read + Drive access)

Step 4: Set a trigger (every 6 hours)

1) Click the clock icon (“Triggers”)

2) Add Trigger:

Function: run
Event source: Time-driven
Type: Hour timer
Interval: Every 6 hours

Why this works for monthly bookkeeping

When you do bookkeeping, you’ll usually move/delete/rename PDFs inside the month folder.

This automation doesn’t care what happens in Drive afterward.

It remembers processed Gmail message IDs.
So the same email is never imported again, even if you remove the stored PDF.
And it still catches new PDFs posted later in an old thread.

Tuning tips

If you get invoices as replies to very old threads, increase LOOKBACK_DAYS.
Always keep KEEP_MESSAGE_IDS_DAYS >= LOOKBACK_DAYS (recommended: much bigger).
If you have high email volume, increase MAX_THREADS_PER_RUN (and keep an eye on Apps Script quotas).

Happy automating 👋

We Built Free Embeddable Stock Sentiment Widgets — Here's How to Use Them

Alexander Schneider — Mon, 09 Feb 2026 10:51:22 +0000

We just shipped something we're really excited about: three embeddable stock sentiment widgets that any developer can drop into their site with a single <script> tag.

No API key. No framework dependency. No build step. Just HTML.

Why We Built This

We run the Reddit Stock Sentiment API — it tracks what retail investors are talking about on Reddit and X/Twitter in real-time, scoring stocks by buzz, sentiment, and trend direction.

The API is great for developers building dashboards and trading tools. But we kept hearing the same request: "Can I just embed a widget on my blog?"

So we built exactly that.

The Three Widgets

1. Ticker Tape

A scrolling horizontal bar showing trending stocks with sentiment indicators. Think Bloomberg terminal vibes for your website header.

<script src="https://adanos.org/embed/adanos-widgets.js"></script>
<adanos-ticker-tape theme="dark" source="reddit" limit="15" speed="normal"></adanos-ticker-tape>

Each ticker item shows the stock logo, symbol, buzz score, a colored sentiment dot (green = bullish, red = bearish), and trend direction.

Attributes:
| Attribute | Options | Default |
|-----------|---------|---------|
| theme | light, dark | light |
| source | reddit, x | reddit |
| limit | 5, 10, 15, 20 | 10 |
| speed | slow, normal, fast | normal |

2. Top Movers

A ranked leaderboard of the hottest stocks. Shows buzz score, bullish percentage, trend direction, and a 7-day sparkline chart.

<script src="https://adanos.org/embed/adanos-widgets.js"></script>
<adanos-top-movers theme="light" source="reddit" limit="10" period="1" show-logos="true"></adanos-top-movers>

The table is fully responsive — company names hide on tablets, sparklines hide on phones.

Attributes:
| Attribute | Options | Default |
|-----------|---------|---------|
| theme | light, dark | light |
| source | reddit, x | reddit |
| limit | 5, 10, 15 | 10 |
| period | 1, 3, 7, 14, 21, 30 (days) | 1 |
| show-logos | true, false | true |

3. Stock Sentiment Card

A deep-dive card for a single stock. Shows buzz score, bullish percentage, mention count, trend, a 7-day sparkline, and an optional AI-generated explanation of why the stock is trending.

<script src="https://adanos.org/embed/adanos-widgets.js"></script>
<adanos-stock-sentiment ticker="TSLA" theme="light" source="reddit" show-explanation="true"></adanos-stock-sentiment>

Perfect for embedding in stock analysis articles.

Attributes:
| Attribute | Options | Default |
|-----------|---------|---------|
| theme | light, dark | light |
| source | reddit, x | reddit |
| ticker | Any stock symbol | (required) |
| show-explanation | true, false | true |

Technical Decisions

A few things we think fellow devs will appreciate:

Standard Web Components

No React. No Vue. No Angular. Just customElements.define() and Shadow DOM. The widgets work everywhere — static sites, WordPress, Next.js, whatever. If the browser supports Web Components (all modern ones do), it works.

Shadow DOM Encapsulation

Every widget uses Shadow DOM, so our styles never leak into your page and your styles never break our widgets. You get clean isolation out of the box.

No API Key Required

The widgets call our proxy endpoint which handles authentication server-side. You don't need to sign up, manage keys, or worry about exposing credentials in your frontend code.

Built-in Caching

Every widget has an in-memory cache with a 5-minute TTL and request deduplication. Drop five widgets on a page — they share cached responses. No redundant API calls.

Zero External Dependencies

The entire widget library is a single vanilla JS file. No npm packages, no bundler required, no polyfills. The font loading (Space Grotesk + JetBrains Mono) is handled internally and only triggers once per page.

Real-World Examples

Financial news site header:

<adanos-ticker-tape theme="dark" source="reddit" limit="20" speed="fast"></adanos-ticker-tape>

Weekly stock roundup blog post:

<adanos-top-movers period="7" limit="10" show-logos="true"></adanos-top-movers>

Single stock analysis article:

<adanos-stock-sentiment ticker="NVDA" show-explanation="true"></adanos-stock-sentiment>

Dark-themed trading dashboard:

<adanos-ticker-tape theme="dark" source="x"></adanos-ticker-tape>
<adanos-top-movers theme="dark" source="x" period="1"></adanos-top-movers>
<adanos-stock-sentiment ticker="AAPL" theme="dark" source="x"></adanos-stock-sentiment>

Try the Live Configurator

We built an interactive configurator where you can tweak every attribute, see a live preview, and copy the embed code:

adanos.org/widgets

Change the theme, data source, number of tickers, time period — the preview updates instantly and the embed code regenerates automatically.

What's Next

We're working on:

Custom color theming via CSS custom properties
Webhook-triggered updates for real-time push data
More data sources beyond Reddit and X

If you have ideas or feature requests, drop a comment below or reach out at adanos.org/contact.

Built by Adanos Software — we build trading intelligence tools for retail investors.

I built a Python script that alerts me when Reddit is hyping a stock

Alexander Schneider — Fri, 06 Feb 2026 10:14:11 +0000

GameStop went from $20 to $480. AMC from $2 to $72. Palantir doubled in a week.

Every single one started the same way: a handful of Reddit posts in r/wallstreetbets that snowballed into thousands of mentions within hours. By the time CNBC reported on it, the move was already happening.

The pattern is always the same:

A stock goes from ~5 mentions/day to 50+ mentions in a few hours
Sentiment flips heavily bullish (70%+ positive)
It spreads from one subreddit to multiple communities
The buzz score explodes

What if you could detect step 1 automatically and get a Slack message before step 4 happens?

That's what we're building.

What we're building

A Python script that:

Checks Reddit sentiment data every hour
Detects stocks with unusual buzz spikes (momentum)
Filters for high bullish sentiment (not just noise)
Sends you a Slack/Discord/email alert

No machine learning. No complex setup. Just API calls and simple thresholds.

Setup

pip install requests

You'll need a free API key from the Reddit Stock Sentiment API (250 requests/month, takes 30 seconds to sign up).

The detector — 40 lines of Python

# reddit_hype_alert.py
import requests
import json
from datetime import datetime

API_KEY = "your_api_key_here"
BASE = "https://api.adanos.org/reddit/stocks/v1"
HEADERS = {"X-API-Key": API_KEY}

# --- Thresholds (tune these to your preference) ---
BUZZ_MIN = 40            # Minimum buzz score to consider
BULLISH_MIN = 55         # Minimum bullish percentage
TREND_FILTER = "rising"  # Only alert on rising stocks
SPREAD_MIN = 3           # Mentioned in at least N subreddits

def get_trending():
    """Fetch top 50 trending stocks from the last 24 hours."""
    r = requests.get(f"{BASE}/trending", headers=HEADERS,
                     params={"limit": 50, "days": 1})
    r.raise_for_status()
    return r.json()

def detect_hype(stocks):
    """Filter for stocks showing hype signals."""
    alerts = []
    for s in stocks:
        if (s["buzz_score"] >= BUZZ_MIN
            and s.get("bullish_pct", 0) >= BULLISH_MIN
            and s["trend"] == TREND_FILTER
            and s.get("subreddit_count", 0) >= SPREAD_MIN):
            alerts.append(s)
    return alerts

def format_alert(stock):
    """Format a single stock alert."""
    return (
        f"🚨 ${stock['ticker']} — {stock.get('company_name', 'Unknown')}\n"
        f"   Buzz: {stock['buzz_score']:.1f}/100 ↑ {stock['trend']}\n"
        f"   Mentions: {stock['mentions']} across {stock.get('subreddit_count', '?')} subreddits\n"
        f"   Sentiment: {stock.get('bullish_pct', '?')}% bullish\n"
    )

# --- Run ---
print(f"[{datetime.now():%H:%M}] Scanning Reddit trending stocks...")
stocks = get_trending()
hype_stocks = detect_hype(stocks)

if hype_stocks:
    print(f"\n🔥 {len(hype_stocks)} stocks showing hype signals:\n")
    for s in hype_stocks:
        print(format_alert(s))
else:
    print("No hype signals detected right now.")

Run it:

$ python reddit_hype_alert.py

[14:30] Scanning Reddit trending stocks...

🔥 3 stocks showing hype signals:

🚨 $NVDA — NVIDIA Corporation
   Buzz: 92.3/100 ↑ rising
   Mentions: 487 across 12 subreddits
   Sentiment: 72% bullish

🚨 $PLTR — Palantir Technologies Inc.
   Buzz: 78.1/100 ↑ rising
   Mentions: 198 across 8 subreddits
   Sentiment: 68% bullish

🚨 $RKLB — Rocket Lab USA, Inc.
   Buzz: 54.2/100 ↑ rising
   Mentions: 67 across 5 subreddits
   Sentiment: 81% bullish

That third one — $RKLB with 67 mentions but 81% bullish across 5 subreddits — that's exactly the kind of early signal you want to catch. It's not yet on CNBC, but Reddit is already talking.

Add Slack notifications

Turn it into a real alert system with one function:

import os

SLACK_WEBHOOK = os.environ.get("SLACK_WEBHOOK_URL")

def send_slack_alert(hype_stocks):
    """Send hype alerts to Slack."""
    if not SLACK_WEBHOOK:
        return

    blocks = [{"type": "header", "text": {
        "type": "plain_text",
        "text": f"🔥 {len(hype_stocks)} Reddit Hype Alert{'s' if len(hype_stocks) > 1 else ''}"
    }}]

    for s in hype_stocks[:5]:
        blocks.append({"type": "section", "text": {"type": "mrkdwn", "text":
            f"*${s['ticker']}* — {s.get('company_name', '')}\n"
            f"Buzz `{s['buzz_score']:.1f}` · {s['mentions']} mentions · "
            f"{s.get('bullish_pct', '?')}% bullish · {s.get('subreddit_count', '?')} subreddits"
        }})

    requests.post(SLACK_WEBHOOK, json={"blocks": blocks})

# Update the run section:
if hype_stocks:
    send_slack_alert(hype_stocks)

Want an AI explanation of WHY it's trending?

The API has an /explain endpoint that uses an LLM to summarize what Reddit is actually saying:

def get_explanation(ticker):
    """Get AI-generated explanation of why a stock is trending."""
    r = requests.get(f"{BASE}/stock/{ticker}/explain", headers=HEADERS)
    if r.status_code == 200:
        return r.json().get("explanation", "")
    return None

# Add to your alert:
for s in hype_stocks:
    explanation = get_explanation(s["ticker"])
    if explanation:
        print(f"   💡 Why: {explanation}")

Output:

🚨 $RKLB — Rocket Lab USA, Inc.
   Buzz: 54.2/100 ↑ rising
   Mentions: 67 across 5 subreddits
   Sentiment: 81% bullish
   💡 Why: Rocket Lab trending after successful Neutron rocket test and new
   NASA contract announcement. Retail investors bullish on space sector growth.

Now you're not just seeing that something is trending — you know why.

Run it every hour with cron

# Edit crontab
crontab -e

# Add this line (runs every hour during market hours, Mon-Fri)
0 9-16 * * 1-5 cd /path/to/script && python reddit_hype_alert.py >> alerts.log 2>&1

Or if you prefer GitHub Actions, Docker, or a cloud function — the script is stateless, so it runs anywhere.

Tuning the thresholds

The default thresholds are conservative. Here's how to adjust them:

Signal	Conservative	Aggressive	What it catches
`BUZZ_MIN`	40	20	Lower = more alerts, earlier signals
`BULLISH_MIN`	55	40	Lower = includes mixed-sentiment stocks
`SPREAD_MIN`	3	1	Lower = catches single-subreddit hype
`TREND_FILTER`	`"rising"`	Remove filter	Also catches `"stable"` momentum

Start conservative. If you're getting 0-1 alerts per day, lower the thresholds. If you're getting 10+, raise them.

What I'd build next

Cross-platform validation: Check if the same stock is also trending on X/Twitter. Stocks hyped on both platforms have stronger signals.
Historical backtesting: Use the 90-day history (paid tier) to backtest which threshold combos would have caught past rallies.
Portfolio watchlist: Only alert on stocks you already own or are watching, using the /v1/stock/{ticker} endpoint.
Discord bot: Same logic, but posts to a Discord channel for your trading group.

Full code

The complete script is ~60 lines. It uses 2 API calls per run (trending + explain for each alert), so the free tier (250 requests/month) easily covers running it several times per day.

Reddit Stock Sentiment API — sign up for a free key
Full API docs
BuzzScore Whitepaper — how the 0-100 score works under the hood

Built by Adanos Software in Berlin. The API tracks 12,000+ tickers across 50+ subreddits, updated hourly.

How to Host Your Own n8n Automation Server on Hetzner Cloud for Less Than $6/Month

Alexander Schneider — Fri, 18 Jul 2025 07:00:17 +0000

If you're looking for a powerful automation platform that won't break the bank, self-hosting n8n on Hetzner Cloud might be the perfect solution. In this guide, I'll walk you through how we set up a production-ready n8n instance with enterprise-grade security for just ~$6.

Why Self-Host n8n?

n8n is an open-source workflow automation tool that rivals expensive solutions like Zapier or Make. By self-hosting, you get:

Complete data privacy and control
No workflow execution limits
Custom integrations and code
Full API access
Cost-effective scaling

The Setup: What We're Building

Here's what we'll deploy:

Server: Hetzner Cloud CX22 (2 vCPU, 4GB RAM)
Location: Falkenstein, Germany
Services: n8n (Docker), Caddy (reverse proxy with automatic SSL)
Security: UFW firewall, Fail2ban, audit logging, automated updates
Cost: ~$6 / month

Step 1: Creating the Hetzner Cloud Server

First, create a Hetzner Cloud account and set up a new server:

# Using Hetzner CLI (optional)
hcloud server create \
  --name n8n-server \
  --type cx22 \
  --image ubuntu-22.04 \
  --location fsn1 \
  --ssh-key ~/.ssh/id_rsa.pub

Pro tip: The CX22 instance type offers the best price-performance ratio for n8n. With 2 vCPUs and 4GB RAM, it can handle substantial workflows without issues.

Step 2: Initial Server Security Hardening

Security first! Here's our hardening checklist:

Create a non-root user

# As root
adduser admin
usermod -aG sudo admin
mkdir -p /home/admin/.ssh
cp ~/.ssh/authorized_keys /home/admin/.ssh/
chown -R admin:admin /home/admin/.ssh
chmod 700 /home/admin/.ssh
chmod 600 /home/admin/.ssh/authorized_keys

Disable root login and password authentication

# Edit SSH config
sed -i 's/PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
systemctl restart sshd

Set up UFW firewall

ufw default deny incoming
ufw default allow outgoing
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw --force enable

Install and configure Fail2ban

apt update && apt install -y fail2ban
cat > /etc/fail2ban/jail.local << 'EOF'
[DEFAULT]
bantime = 2h
maxretry = 3
findtime = 10m

[sshd]
enabled = true
port = ssh
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
EOF

systemctl restart fail2ban

Enable automatic security updates

apt install -y unattended-upgrades
dpkg-reconfigure -plow unattended-upgrades

Set up audit logging

apt install -y auditd
auditctl -w /etc/passwd -p wa -k passwd_changes
auditctl -w /etc/shadow -p wa -k shadow_changes
auditctl -w /var/log/auth.log -p wa -k auth_log
service auditd restart

Step 3: Installing Docker and Docker Compose

# Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

# Install Docker Compose
apt install -y docker-compose-plugin

# Verify installation
docker --version
docker compose version

Step 4: Setting Up n8n with Docker Compose

Create the n8n directory and docker-compose file:

mkdir -p /root/n8n
cd /root/n8n

Create a secure docker-compose.yml:

version: '3.8'

services:
  n8n:
    image: n8nio/n8n
    container_name: n8n
    restart: unless-stopped
    ports:
      - "127.0.0.1:5678:5678"  # Only accessible locally
    environment:
      - N8N_HOST=n8n.yourdomain.com
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.yourdomain.com/
      - GENERIC_TIMEZONE=Europe/Berlin
    volumes:
      - n8n_data:/home/node/.n8n
    security_opt:
      - no-new-privileges:true
    read_only: true
    tmpfs:
      - /tmp
      - /home/node/.n8n/cache

volumes:
  n8n_data:

Security insights:

Binding to 127.0.0.1 ensures n8n is only accessible through our reverse proxy
read_only: true prevents container filesystem modifications
no-new-privileges prevents privilege escalation
Using tmpfs for temporary files improves security and performance

Step 5: Setting Up Caddy as Reverse Proxy

Caddy provides automatic HTTPS certificates and is much simpler than nginx:

# Install Caddy
apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | tee /etc/apt/sources.list.d/caddy-stable.list
apt update && apt install -y caddy

Configure Caddy:

cat > /etc/caddy/Caddyfile << 'EOF'
n8n.yourdomain.com {
    reverse_proxy localhost:5678 {
        header_up X-Real-IP {remote}
        header_up X-Forwarded-For {remote}
        header_up X-Forwarded-Proto {scheme}
    }

    # Security headers
    header {
        X-Content-Type-Options nosniff
        X-Frame-Options DENY
        X-XSS-Protection "1; mode=block"
        Referrer-Policy strict-origin-when-cross-origin
        -Server
    }

    # Enable compression
    encode gzip
}
EOF

systemctl restart caddy

Step 6: Starting n8n

cd /root/n8n
docker compose up -d

Visit https://n8n.yourdomain.com and complete the initial setup!

Advanced Security Measures

1. Implement IP-based access control

If you have a static IP, limit access to n8n:

n8n.yourdomain.com {
    @allowed {
        remote_ip 1.2.3.4 192.168.0.0/16
    }
    handle @allowed {
        reverse_proxy localhost:5678
    }
    handle {
        respond "Access Denied" 403
    }
}

2. Set up Fail2ban for n8n

Create a custom filter for failed n8n login attempts:

cat > /etc/fail2ban/filter.d/n8n-auth.conf << 'EOF'
[Definition]
failregex = ^.* 401 .* "POST /rest/auth/login.*" .*$
ignoreregex =
EOF

# Add to jail.local
cat >> /etc/fail2ban/jail.local << 'EOF'

[n8n-auth]
enabled = true
port = http,https
filter = n8n-auth
logpath = /var/log/caddy/access.log
maxretry = 5
bantime = 1h
EOF

3. Regular backups

Create a backup script:

#!/bin/bash
# /root/backup-n8n.sh
BACKUP_DIR="/root/backups"
mkdir -p $BACKUP_DIR
docker compose -f /root/n8n/docker-compose.yml down
docker run --rm -v n8n_data:/data -v $BACKUP_DIR:/backup alpine tar czf /backup/n8n-backup-$(date +%Y%m%d).tar.gz -C /data .
docker compose -f /root/n8n/docker-compose.yml up -d
# Keep only last 7 backups
find $BACKUP_DIR -name "n8n-backup-*.tar.gz" -mtime +7 -delete

Add to crontab:

0 3 * * * /root/backup-n8n.sh

Performance Optimization Tips

Enable Redis for scaling: Add a Redis container for better performance with multiple workers
Use external database: For production workloads, consider PostgreSQL instead of SQLite
Monitor resources: Install htop and set up monitoring with Prometheus/Grafana
Optimize workflows: Use webhook triggers instead of polling when possible

Cost Breakdown

Hetzner CX22 Server: ~$6/month
Domain (use a subdomain): ~$0/year
Total monthly cost: ~$6/month

Compare this to n8n Cloud's pricing starting at $20/month for just 2,500 workflow executions!

Lessons Learned

Start with security: It's easier to harden from the beginning than retrofit later
Docker adds complexity but worth it: Container isolation and easy updates outweigh the overhead
Caddy > Nginx for simple setups: Automatic HTTPS saves hours of configuration
Monitor everything: Set up alerts for disk space, CPU usage, and failed login attempts
Document everything: Future you will thank present you

Troubleshooting Common Issues

n8n won't start

# Check logs
docker logs n8n
# Common fix: permissions on data volume
docker volume rm n8n_data  # Warning: deletes data!

SSL certificate issues

# Caddy logs
journalctl -u caddy -f
# Force certificate renewal
caddy reload --config /etc/caddy/Caddyfile

High memory usage

# Add memory limits to docker-compose.yml
deploy:
  resources:
    limits:
      memory: 3g

Conclusion

For less than the price of a Netflix subscription, you can run your own powerful automation platform with complete control over your data. The setup takes about an hour, but the flexibility and cost savings make it worthwhile for anyone serious about automation.

Have you set up your own n8n instance? What challenges did you face? Let me know in the comments!

Resources:

Monitor Any Stock Price in Your App with 7 Lines of JavaScript

Alexander Schneider — Sun, 13 Jul 2025 07:35:55 +0000

Ever wanted to add stock price monitoring to your app? Maybe you're building a dashboard, a portfolio tracker, or just want to get notified when Tesla does something crazy again?

Here's how to add real-time stock monitoring to ANY JavaScript application using the StockAlert.pro API.

Installation

npm install @stockalert/sdk
# or
yarn add @stockalert/sdk

The 7-Line Version (I Wasn't Kidding)

import { StockAlertClient } from '@stockalert/sdk';

const client = new StockAlertClient({ apiKey: 'your-free-api-key' });

// Get notified when Apple hits $150
await client.alerts.create({
  symbol: 'AAPL',
  condition: 'price_above',
  threshold: 150
});

That's it. You'll get an email when Apple hits $150. But let's build something more useful...

Real-World Example: Portfolio Dashboard

Let's build a portfolio monitoring system that tracks multiple stocks and sends you notifications when it's time to take profits or cut losses.

import { StockAlertClient } from '@stockalert/sdk';

const client = new StockAlertClient({ apiKey: process.env.STOCKALERT_API_KEY });

// Your portfolio
const portfolio = [
  { symbol: 'AAPL', shares: 100, buyPrice: 145 },
  { symbol: 'GOOGL', shares: 50, buyPrice: 2800 },
  { symbol: 'MSFT', shares: 75, buyPrice: 380 }
];

// Set up price alerts for your portfolio
async function monitorPortfolio() {
  for (const position of portfolio) {
    // Alert when profit hits 10%
    await client.alerts.create({
      symbol: position.symbol,
      condition: 'price_change_up',
      threshold: 10  // 10% gain
    });

    // Alert when loss hits 5% (stop loss)
    await client.alerts.create({
      symbol: position.symbol,
      condition: 'price_change_down',
      threshold: 5  // 5% loss
    });

    console.log(`📊 Monitoring ${position.symbol}:`);
    console.log(`   Alert when up 10% from current price`);
    console.log(`   Alert when down 5% from current price`);
  }

  console.log('\n✅ All alerts created! You\'ll get emails when targets are hit.');
}

// Start monitoring
monitorPortfolio();

Working with Webhooks

Want to receive events in your app? Here's how to properly set up webhooks:

Pro tip: You can view and test all your webhooks at https://stockalert.pro/dashboard/settings

import crypto from 'crypto';

// Step 1: Register your webhook endpoint
const webhook = await client.webhooks.create({
  url: 'https://your-app.com/stockalert-webhook',
  events: ['alert.triggered']
});

console.log('Webhook secret:', webhook.secret); // Save this for verification!

// Step 2: Create alerts (they'll send emails/SMS by default)
const alert = await client.alerts.create({
  symbol: 'AAPL',
  condition: 'price_above',
  threshold: 150
});

// Step 3: Handle webhook events when alerts trigger
app.post('/stockalert-webhook', (req, res) => {
  const { event, timestamp, data } = req.body;

  // Verify webhook signature (recommended)
  const signature = req.headers['x-stockalert-signature'];
  const expectedSignature = crypto
    .createHmac('sha256', webhook.secret)
    .update(JSON.stringify(req.body))
    .digest('hex');

  if (signature !== expectedSignature) {
    return res.status(401).send('Invalid signature');
  }

  if (event === 'alert.triggered') {
    console.log(`🚨 Alert triggered at ${timestamp}`);
    console.log(`Symbol: ${data.symbol}`);
    console.log(`Condition: ${data.condition} (threshold: ${data.threshold})`);
    console.log(`Current value: $${data.current_value}`);

    // Your custom logic here: update database, send Slack message, etc.
  }

  res.json({ received: true });
});

Building a Price Monitoring Slack Bot

Here's a Slack bot that lets your team monitor stocks:

import { StockAlertClient } from '@stockalert/sdk';
import { WebClient } from '@slack/web-api';

const stockAlert = new StockAlertClient({ apiKey: process.env.STOCKALERT_API_KEY });
const slack = new WebClient(process.env.SLACK_TOKEN);

// Slack slash command: /watch AAPL above 150
app.post('/slack/commands', async (req, res) => {
  const { text, user_id, channel_id } = req.body;
  const [symbol, condition, value] = text.split(' ');

  // Create the alert
  const alert = await stockAlert.alerts.create({
    symbol: symbol.toUpperCase(),
    condition: `price_${condition}`,
    threshold: parseFloat(value)
  });

  // Store metadata in your database for webhook handling
  await saveAlertMetadata(alert.id, { channel_id, user_id });

  res.json({
    response_type: 'in_channel',
    text: `✅ Watching ${symbol.toUpperCase()} to go ${condition} $${value}`
  });
});

// Handle the alert
app.post('/slack-webhook', async (req, res) => {
  const { symbol, price, condition, metadata } = req.body;

  await slack.chat.postMessage({
    channel: metadata.channel_id,
    text: `🚨 Alert: ${symbol} is now at $${price}!`,
    blocks: [{
      type: 'section',
      text: {
        type: 'mrkdwn',
        text: `*${symbol}* hit your target price!\nCurrent: *$${price}*\nAlert by: <@${metadata.user_id}>`
      }
    }]
  });

  res.json({ received: true });
});

Email Digest for Your Users

Building a fintech app? Here's how to use daily reminders to keep users informed:

import { StockAlertClient } from '@stockalert/sdk';

const client = new StockAlertClient({ apiKey: process.env.STOCKALERT_API_KEY });

// Set up daily reminders for user's watchlist
async function setupDailyDigest(userEmail, watchlist) {
  for (const symbol of watchlist) {
    await client.alerts.create({
      symbol: symbol,
      condition: 'daily_reminder'
      // Sends every market day at open with current price
    });
  }
}

// Example: Set up for a user watching tech stocks
await setupDailyDigest('user@example.com', ['AAPL', 'GOOGL', 'MSFT']);

What the user receives every market day:

Subject: Daily Reminder for AAPL: +1.24%

Stock Alert: Daily Reminder for AAPL

Daily Reminder: Apple Inc.
Your daily market open summary for Apple Inc. (AAPL). Current price is $175.23.

Alert Details
Here is your daily update for Apple Inc. (AAPL), as of U.S. market open:

┌─────────────────────────┬──────────────┐
│ Current Price           │ $175.23      │
│ Previous Day's Close    │ $173.08      │
│ Change                  │ +1.24%       │
│ 52-Week High           │ $199.62      │
│ 52-Week Low            │ $164.08      │
│ Volume                  │ 52,341,200   │
└─────────────────────────┴──────────────┘

---
Sent by StockAlert.pro

Each stock gets its own email with:

Current price at market open
Previous day's closing price
Percentage change (color-coded: green/red)
52-week high and low
Trading volume
Proper currency formatting based on user location

Pro tip: For a consolidated digest, use webhooks to collect all alerts and send one combined email:

// Collect daily alerts via webhook
const dailyAlerts = new Map();

app.post('/webhook', async (req, res) => {
  const { event, data } = req.body;

  if (event === 'alert.triggered' && data.condition === 'daily_reminder') {
    // Group by user (you'd need to track this in your DB)
    const userId = await getUserIdByAlertId(data.alert_id);

    if (!dailyAlerts.has(userId)) {
      dailyAlerts.set(userId, []);
    }

    dailyAlerts.get(userId).push({
      symbol: data.symbol,
      price: data.current_value,
      timestamp: data.triggered_at
    });

    // Send digest after collecting all morning alerts
    setTimeout(() => sendConsolidatedDigest(userId), 30000);
  }

  res.json({ received: true });
});

Advanced: Technical Indicators

Monitor RSI, Moving Averages, and more:

// Get notified when a stock becomes oversold
await client.alerts.create({
  symbol: 'TSLA',
  condition: 'rsi_limit',
  threshold: 30,  // RSI below 30 = oversold
  parameters: {
    direction: 'below'  // 'below' or 'above'
  }
});

// Golden Cross alert (50-day MA crosses above 200-day MA)
await client.alerts.create({
  symbol: 'SPY',
  condition: 'ma_crossover_golden'
});

// Price touches moving average
await client.alerts.create({
  symbol: 'AAPL',
  condition: 'ma_touch_above',
  parameters: {
    period: 50  // 50-day or 200-day moving average
  }
});

Error Handling & Best Practices

class StockMonitor {
  constructor(apiKey) {
    this.client = new StockAlertClient({ apiKey });
    this.alerts = new Map();
  }

  async createAlert(config) {
    try {
      const alert = await this.client.alerts.create(config);
      this.alerts.set(alert.id, alert);
      console.log(`✅ Alert created: ${alert.id}`);
      return alert;
    } catch (error) {
      if (error.code === 'RATE_LIMIT') {
        console.error('Rate limit hit, retrying in 60s...');
        await sleep(60000);
        return this.createAlert(config);
      }

      if (error.code === 'INVALID_SYMBOL') {
        console.error(`Invalid symbol: ${config.symbol}`);
        return null;
      }

      throw error;
    }
  }

  async cleanup() {
    // Delete all alerts on shutdown
    for (const [id, alert] of this.alerts) {
      try {
        await this.client.alerts.delete(id);
      } catch (error) {
        console.error(`Failed to delete alert ${id}:`, error);
      }
    }
  }
}

// Graceful shutdown
process.on('SIGTERM', async () => {
  await monitor.cleanup();
  process.exit(0);
});

Testing Your Integration

// Mock webhook endpoint for testing
if (process.env.NODE_ENV === 'development') {
  app.post('/test-webhook', (req, res) => {
    console.log('Webhook received:', JSON.stringify(req.body, null, 2));
    res.json({ received: true });
  });

  // Create a test alert
  await client.alerts.create({
    symbol: 'AAPL',
    condition: 'price_above',
    threshold: 1 // Will trigger immediately
  });

  // For webhook testing, first create a webhook endpoint:
  // const webhook = await client.webhooks.create({
  //   url: 'http://localhost:3000/test-webhook',
  //   events: ['alert.triggered']
  // });
}

Pricing

Free Plan includes:

Monitor up to 50 stocks parallel
Unlimited email alerts
All 21 alert types
1 API key per user
100 API requests/hour

Premium Plan ($14.99/month or $149.99/year):

Unlimited stocks
50 SMS/WhatsApp messages per month
10,000 API requests/hour
Unlimited API keys
Unlimited alerts via API
Priority support

Perfect for testing with the free plan, then scale up when you need more power!

What Will You Build?

I've seen developers use this API to build:

Portfolio tracking apps
Discord/Slack bots
Personal dashboards
Trading journals
News aggregators that react to price movements
Chrome extensions for price monitoring

What are you planning to build? Drop a comment below!

Resources

Get your free API key at stockalert.pro - No credit card required