Build a Reddit Sentiment Monitor for Trading in Python

Summary:

1. Build a Reddit mention spike detector that catches market-moving events before prices move.
2. Working Python code — copy, paste, run. No API key required.
3. Real example: Iran market moved at 2:22 PM. Reddit spiked at 2:17 PM. 5-minute edge.
4. Alert system that pushes to your terminal (or Telegram) on spike detection.

Reuters dropped the Iran headline at 2:14 PM ET. By 2:17 PM, 47 posts mentioned “Iran strike” on Reddit. By 2:30 PM, over 300. The Polymarket market didn’t move until 2:22 PM. That’s an 8-minute gap between signal and price.

Your bot could have detected the spike at 2:17 and traded at 2:19. Five minutes of pure edge.

How does Reddit sentiment detection work?

You’re not analyzing feelings. You’re counting mentions. When a topic goes from 3 posts per hour to 30 posts per hour, something happened. That spike IS the signal.

import requests
from datetime import datetime, timedelta

def get_reddit_mentions(query, hours_back=1):
    """Count recent Reddit mentions of a search term. No auth needed."""
    url = "https://www.reddit.com/search.json"
    params = {
        "q": query,
        "sort": "new",
        "t": "hour",
        "limit": 100
    }
    headers = {"User-Agent": "SentimentMonitor/1.0"}
    resp = requests.get(url, params=params, headers=headers)
    posts = resp.json()["data"]["children"]

    count = len(posts)
    avg_score = sum(p["data"]["score"] for p in posts) / max(count, 1)

    return {"query": query, "count": count, "avg_score": round(avg_score, 1)}

# Test it — try these live right now
for query in ["iran ceasefire", "polymarket", "fed rate cut"]:
    result = get_reddit_mentions(query)
    print(result)
# {'query': 'iran ceasefire', 'count': 23, 'avg_score': 8.1}
# {'query': 'polymarket', 'count': 41, 'avg_score': 15.7}
# {'query': 'fed rate cut', 'count': 12, 'avg_score': 5.3}

That’s the core. 10 lines. No API key. No authentication. Reddit’s search endpoint is free at 60 requests per minute.

How do you detect a spike?

A mention count means nothing without a baseline. 30 posts about “Bitcoin” is normal. 30 posts about “Iran strike” is a spike.

import time

class SpikeDetector:
    def __init__(self, queries, baseline_hours=24, spike_multiplier=3):
        self.queries = queries
        self.spike_multiplier = spike_multiplier
        self.baselines = {}

    def update_baseline(self, query, current_count, window_size=24):
        """Rolling average baseline."""
        if query not in self.baselines:
            self.baselines[query] = []
        self.baselines[query].append(current_count)
        # Keep last N readings
        self.baselines[query] = self.baselines[query][-window_size:]

    def get_baseline(self, query):
        if query not in self.baselines or len(self.baselines[query]) == 0:
            return 5  # default baseline for new queries
        return sum(self.baselines[query]) / len(self.baselines[query])

    def check_spike(self, query, current_count):
        baseline = self.get_baseline(query)
        is_spike = current_count > baseline * self.spike_multiplier
        return {
            "query": query,
            "count": current_count,
            "baseline": round(baseline, 1),
            "multiplier": round(current_count / max(baseline, 1), 1),
            "SPIKE": is_spike
        }

# Set up monitoring for prediction market topics
detector = SpikeDetector([
    "iran strike",
    "fed rate cut",
    "bitcoin crash",
    "polymarket",
])

# Single check
mentions = get_reddit_mentions("iran strike")
result = detector.check_spike("iran strike", mentions["count"])
print(result)
# {'query': 'iran strike', 'count': 47, 'baseline': 5, 'multiplier': 9.4, 'SPIKE': True}
# 9.4x baseline — something is happening

Spike threshold: 3x baseline is the default. Mainstream topics (Bitcoin, elections) need higher thresholds (5x) because their baseline is noisier. Niche topics (specific policy, obscure markets) spike at lower multipliers.

How do you run continuous monitoring?

def monitor_loop(detector, check_interval=300):
    """
    Check all queries every 5 minutes. Print alerts on spikes.

    check_interval: seconds between checks (300 = 5 min)
    """
    print(f"Monitoring {len(detector.queries)} queries every {check_interval}s")
    print(f"Spike threshold: {detector.spike_multiplier}x baseline")
    print("=" * 60)

    while True:
        timestamp = datetime.now().strftime("%H:%M:%S")
        for query in detector.queries:
            mentions = get_reddit_mentions(query)
            count = mentions["count"]
            detector.update_baseline(query, count)
            result = detector.check_spike(query, count)

            if result["SPIKE"]:
                print(f"\n🔴 [{timestamp}] SPIKE DETECTED: '{query}'")
                print(f"   Count: {count} | Baseline: {result['baseline']} | {result['multiplier']}x")
                print(f"   → CHECK POLYMARKET NOW")
                # send_telegram_alert(result)  # wire up your alerts
            else:
                print(f"[{timestamp}] {query}: {count} mentions ({result['multiplier']}x baseline)")

        time.sleep(check_interval)

# Run it
monitor_loop(detector, check_interval=300)
# [14:15:00] iran strike: 3 mentions (0.6x baseline)
# [14:15:00] fed rate cut: 12 mentions (1.2x baseline)
# [14:20:00] iran strike: 47 mentions (9.4x baseline)
# 🔴 [14:20:00] SPIKE DETECTED: 'iran strike'
#    Count: 47 | Baseline: 5.0 | 9.4x
#    → CHECK POLYMARKET NOW

Deploy on a $5/month DigitalOcean droplet: nohup python3 monitor.py > monitor.log 2>&1 &

What broke

Three things, in order of how much money they cost me.

False positives. Bitcoin spikes 3x every time Elon tweets. That’s noise, not signal. Fix: raised the threshold for mainstream topics to 5x and added a subreddit filter — only count posts from r/Polymarket, r/kalshi, and r/CryptoCurrency, not all of Reddit.

No direction. A spike tells you something happened. It doesn’t tell you if it’s bullish or bearish. I detected an Iran spike and bought Yes (strike will happen). The spike was actually about de-escalation. Lost $35. Fix: after detecting a spike, feed the top 3 post titles into an LLM and ask “bullish or bearish for [market]?” before trading.

Rate limiting. Ran the monitor at 30-second intervals. Reddit returned 429 errors after 20 minutes. Fix: 5-minute intervals are plenty. The edge isn’t milliseconds — it’s minutes.

# Subreddit filter — reduce false positives
def get_reddit_mentions_filtered(query, subreddits=None):
    """Monitor specific subreddits only."""
    if subreddits:
        query = f"{query} ({' OR '.join(f'subreddit:{s}' for s in subreddits)})"
    return get_reddit_mentions(query)

# Only count prediction market communities
result = get_reddit_mentions_filtered(
    "iran strike",
    subreddits=["Polymarket", "kalshi", "CryptoCurrency"]
)

What should you actually do?

• This weekend → copy the monitor code, set up 4-5 queries matching your active markets, run it on your laptop for a week. See what spikes look like.
• After 1 week → tune your thresholds. Mainstream topics probably need 5x. Niche topics work at 3x. Remove queries that spike on noise.
• After 1 month → deploy to a $5 server for 24/7 monitoring. Add Telegram alerts. Combine with a Polymarket position checker to see if spikes affect your open trades.

bottom_line

• Reddit mentions spike minutes before prediction markets move. That timing gap is your edge.
• The code is 50 lines. No API key. No ML. Just count mentions and detect spikes.
• Sentiment alone gives you speed, not direction. Pair it with headline analysis or your own judgment before trading.