DEV Community

amirjmb1
amirjmb1

Posted on

Building a Real-Time Prediction Market Scanner in 50 Lines of Python (Zero Dependencies)

#python #web3 #datascience #programming

In financial markets and decentralized prediction platforms like Polymarket, the most profitable traders aren't guessing news headlines—they are monitoring order book microstructure and probability divergence.

In this tutorial, we will build a lightweight, production-ready market intelligence scanner in pure Python using only the standard library (urllib and json). No heavy dependencies, no API keys required.

The Core Concept: Finding Implied Odds Discrepancies

On binary prediction markets, every contract has outcomes that resolve to either $1.00 (win) or $0.00 (lose).

When high-volatility news breaks, automated market makers often lag by several seconds across fragmented liquidity books. A simple algorithmic scanner allows us to detect:

  1. Near-Settlement Sweeps: High-probability contracts (95¢–98¢) where the event has concluded but the oracle settlement window is still counting down.
  2. Spread Inefficiencies: Multi-outcome markets where the sum of best asks temporarily totals less than $1.00 (a pure Dutch book opportunity).

The 50-Line Python Script

Save this as market_scanner.py:

import urllib.request
import json
import datetime

def scan_live_markets(min_price=0.92, max_price=0.99):
    url = "https://gamma-api.polymarket.com/markets?limit=50&active=true&closed=false"
    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})

    print("[*] Querying decentralized order books...")
    with urllib.request.urlopen(req, timeout=10) as res:
        markets = json.loads(res.read().decode("utf-8"))

    print(f"[+] Loaded {len(markets)} active markets. Scanning for mispricings:\n")
    print(f"{'QUESTION':<45} | {'OUTCOME':<6} | {'PRICE':<6} | {'PROFIT':<7}")
    print("-" * 72)

    for m in markets:
        prices_raw = m.get("outcomePrices")
        outcomes_raw = m.get("outcomes")
        if not prices_raw or not outcomes_raw:
            continue

        try:
            prices = json.loads(prices_raw) if isinstance(prices_raw, str) else prices_raw
            outcomes = json.loads(outcomes_raw) if isinstance(outcomes_raw, str) else outcomes_raw

            for outcome, p_str in zip(outcomes, prices):
                p = float(p_str)
                if min_price <= p <= max_price:
                    profit = ((1.0 - p) / p) * 100.0
                    q = m.get('question', '')[:42] + ".." if len(m.get('question', '')) > 44 else m.get('question', '')
                    print(f"{q:<45} | {outcome:<6} | ${p:<5.3f} | +{profit:.2f}%")
        except Exception:
            continue

if __name__ == "__main__":
    scan_live_markets()
Enter fullscreen mode Exit fullscreen mode

How It Works Under the Hood

  1. Standard Library Transport: By avoiding third-party packages, the script has a startup latency of under 50 milliseconds.
  2. Dynamic JSON Parsing: Polymarket's Gamma API provides public read-only access to token prices, volume, and contract hashes without requiring wallet authentication.
  3. Yield Calculation: The formula ((1.0 - p) / p) * 100 calculates the exact deterministic ROI for holding a contract to resolution.

Key Takeaway for Developers

Trading APIs don't have to be complex or locked behind expensive enterprise SDKs. Understanding decentralized protocol APIs gives engineers a unique edge in quantitative analysis and automated monitoring.

Have you experimented with algorithmic prediction market bots? Let me know your thoughts in the comments below!

Top comments (0)