Noureddine RAMDI / Inside Polymarket's BTC 15-minute trading bot: multi-signal fusion with self-learning weights

Created Sat, 23 May 2026 20:41:14 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
895 Words
github-stars python trading-bot prediction-markets algorithmic-trading risk-management polymarket

aulekator/Polymarket-BTC-15-Minute-Trading-Bot

Trading prediction markets on Polymarket is a niche but fascinating challenge, especially with real money on the line. The Polymarket BTC 15-Minute Trading Bot by aulekator stands out because it combines a modular architecture with a sophisticated multi-signal fusion engine and a self-learning feedback loop. This combination is rare in open-source trading bots and offers a practical approach to trading BTC price prediction markets with controlled risk.

the architecture of a modular 7-phase trading bot

At its core, this bot is built in Python and designed around a 7-phase pipeline that cleanly separates the concerns of trading automation. These phases are:

  1. Data ingestion: The bot collects market data from Polymarket, focusing on the 15-minute BTC price prediction markets.

  2. Signal processing: It runs three distinct signal detection techniques:

    • Spike detection, which flags sudden price moves exceeding a 15% threshold.
    • Sentiment analysis, presumably analyzing crowd sentiment or market mood.
    • Price divergence detection, which identifies price gaps over a 5% threshold.

  3. Signal fusion: These three signals feed into a weighted voting fusion engine that combines them to produce a consolidated trading signal.

  4. Risk management: The bot applies strict risk controls, such as a hard $1 maximum per trade, a 30% stop-loss, and a 20% take-profit. This design makes it accessible for traders with small accounts, as little as $10–20.

  5. Execution: Trade orders are placed on Polymarket based on the fused signals and risk parameters.

  6. Monitoring: Prometheus and Grafana integration provide real-time monitoring and metrics visualization.

  7. Self-learning: A learning engine adjusts the weights of the signals dynamically by evaluating historical trade performance, aiming to improve future decisions.

Under the hood, this architecture promotes modularity and clear separation of duties, which improves maintainability and extensibility. The use of Redis for toggling between simulation and live modes without restarting the bot is a developer-friendly feature enhancing the developer experience.

multi-signal fusion and self-learning: what makes it tick

The standout feature here is the fusion of three distinct signals to make trade decisions. Each signal has its own threshold and method:

  • Spike detection: Detects rapid price jumps or drops beyond 15%, which can signal market overreactions or momentum.

  • Sentiment analysis: While the exact method isn’t detailed, sentiment analysis typically involves parsing social or market sentiment data to gauge crowd bias.

  • Price divergence: Looks for price discrepancies over 5%, likely leveraging mean-reversion or trend-following insights.

These signals are combined through a weighted voting system, meaning each signal’s influence on the final decision is proportional to its assigned weight. The self-learning engine adjusts these weights based on historical trade outcomes, effectively tuning the bot’s strategy over time without manual intervention.

The tradeoff here is complexity versus adaptability. Introducing multiple signals and a learning feedback loop increases system complexity and debugging difficulty but can yield better performance through dynamic adaptation.

Risk management is baked in with conservative parameters — $1 max per trade, 30% stop-loss, and 20% take-profit. This is crucial because prediction markets can be volatile, and limiting losses per trade keeps the overall risk in check, especially for small accounts.

The monitoring stack of Prometheus and Grafana is a solid choice for production-grade systems, providing observability into bot performance and system health.

quick start

The README provides clear prerequisites and setup instructions:

## Prerequisites
- Python 3.14+ (Download)

- Redis (Download) - for mode switching

- Polymarket Account with API credentials
- Git

This minimal setup reflects the bot’s focus on integrating with Polymarket’s API and controlling live vs. simulation modes via Redis keys.

verdict

This trading bot is a well-architected, production-grade system for automating trades on Polymarket’s 15-minute BTC price prediction markets. Its modular 7-phase pipeline and multi-signal fusion engine with self-learning weights are features you don’t often see combined in open-source bots.

It is particularly suitable for technically savvy traders or developers interested in algorithmic trading who want to experiment with multi-signal strategies and adaptive weighting. The risk-first design and small per-trade cap make it accessible for smaller accounts, which is often overlooked in trading bot projects.

Limitations include the complexity added by the learning engine, which may require a good understanding of the internal metrics and signal behaviors to tune effectively. Also, the reliance on Polymarket’s API and Redis introduces operational dependencies.

Overall, if you’re looking for a practical, extendable Python bot to experiment with multi-signal fusion trading strategies on prediction markets, this project is worth exploring. The codebase is surprisingly clean and thoughtfully separated, making it a good base to build on or learn from.

→ GitHub Repo: aulekator/Polymarket-BTC-15-Minute-Trading-Bot ⭐ 380 · Python