A high-perforomance automated trading bot for Polymarket's ultra-short crypto prediction markets - 5-minute and 15-minute Up/Down markets on XRP, BNB, ETH, SOL, BTC, and DOGE. Built around a crowd-momentum confirmation strategy rather than news prediction, latency arbitrage, or pure arbitrage.

please check live link https://polymarket.com/@adelan

• What this bot does
• Markets traded
• How Up/Down markets work
• The strategy
• The math behind the edge
• Architecture
• Risks
• Installation
• Configuration
• Usage
• Track record
• Disclaimer

This is a Polymarket trading bot for automated, high-frequency trading on Polymarket's crypto "Up or Down" markets. It does not trade election markets, sports markets, or political event markets - every position is in a short-window, oracle-resolved binary crypto market.

The bot follows a single core idea: when one side of a 5-minute or 15-minute crypto market is priced at 70 cents or higher, the crowd has already formed a strong directional view. Rather than trying to predict price movement from scratch, the bot confirms that view against a live price feed and follows it - a crowd-momentum confirmation strategy, not a contrarian or arbitrage strategy.

If you're searching for a Polymarket bot, Polymarket API trading bot, crypto prediction market bot, or Polymarket CLOB automation, this README documents exactly how this one works, including the math, the architecture, and the risks - not just the marketing pitch.

The bot operates exclusively on three market types:

Coin pairs traded, by share of open positions: XRP (~44%), BNB (~19%), ETH (~12%), SOL (~12%), BTC (~6%), DOGE (~6%). XRP and BNB dominate because their 5- and 15-minute markets currently offer the most consistent volume and clearest momentum signals.

Each market follows the same mechanical structure:

1. At market open, a Chainlink oracle records the reference price for the asset (e.g. XRP/USD).
2. Up shares and Down shares trade on Polymarket's central limit order book (CLOB). Their prices always sum to roughly $1.00.
3. At market close, Chainlink records the settlement price.
4. If the settlement price is higher than the reference price, every Up share redeems for $1.00 and every Down share redeems for $0.00 - and vice versa. There is no draw; even a $0.0001 move decides the outcome.

The critical detail most strategies miss: resolution is based on the Chainlink oracle feed, not raw Binance or Coinbase spot price. Chainlink aggregates across multiple sources with a slight delay, which means the oracle price can diverge briefly from spot exchange price - a gap some bots try to exploit directly. This bot does not rely on that gap; it relies on crowd-confirmed momentum instead.

Four rules define the entire entry logic:

1. Only enter when one side is priced at 70¢ or above. Below 70¢, the market is close to a coin flip and carries no usable crowd signal. At 70¢+, the order book is expressing at least 70% implied confidence in one direction.

2. Buy with the dominant direction, never against it. This is a momentum-following strategy, not a contrarian one. If Up is priced at 75¢, the bot buys Up - it does not fade the crowd.

3. Keep position sizes small and diversified. Typical position sizes run from 0.2 to 1.0 shares per market (roughly $0.14–$0.83 at a 70¢ entry). Diversification across hundreds of small positions, rather than a few large bets, is the primary risk control.

4. Trade continuously, across all six pairs, around the clock. Crypto markets never close, so the bot doesn't either. Running dozens of trades a day across six pairs at all hours is only practical with automation - this isn't a strategy a human can execute manually at scale.

There is no active exit strategy under normal conditions. Because each market resolves automatically within minutes, positions are held to resolution rather than sold early. The only exception is a sharp, fast reversal mid-window that strongly invalidates the original signal - at which point selling early to recover partial capital can beat holding to a total loss, though at the position sizes this bot uses, that's rarely worth the operational complexity.

This is a thin-margin strategy, and the numbers only work if execution is disciplined.

The higher the entry price, the higher the win rate required just to break even - buying at 83¢ demands winning 83% of the time before any profit exists.

Across roughly 11,700 trades over five months at an average entry near 75¢, the strategy's expected value per trade works out to roughly $0.025 - consistent with an actual win rate around 77% against a 75% break-even line. That two-to-three-point gap between actual win rate and break-even win rate is the entire edge. If the win rate drifts down to the break-even line, the strategy stops being profitable, full stop.

This is not a get-rich-quick system. It is a thin, repeatable statistical edge that depends entirely on execution discipline and fee management to stay positive.

The bot is structured around five components:

1. Market scanner - polls Polymarket's Gamma API on a short interval (30–60 seconds), pulling current prices across all active Up/Down markets and filtering for any market where one side is priced at 70¢ or higher.
2. Signal confirmation - cross-references the dominant Polymarket price against a live spot price feed (e.g. a Binance WebSocket) to confirm the order book's implied direction matches the live price trend before placing a trade.
3. Order execution - places limit orders (maker side, not taker) on Polymarket's CLOB via a funded Polygon wallet, to qualify for maker rebates instead of paying taker fees.
4. Position tracking - logs every open position; since resolution is automatic, this layer mainly watches for anomalies like stuck or unresolved positions rather than managing active exits.
5. Oracle awareness - tracks the relevant Chainlink price feed directly rather than relying solely on spot exchange data, since resolution depends on the oracle price, not spot price.

This approach is deliberately lower-complexity than latency arbitrage strategies, which require sub-100ms execution and dedicated low-latency RPC infrastructure, or news-sentiment strategies, which require NLP pipelines for longer-horizon political and event markets. Crowd-momentum confirmation on short-window crypto markets is accessible to a solo developer without either of those requirements.

Anyone running or adapting this strategy should understand these risks going in:

• Short-term crypto price movement is close to random. Academic research on sub-15-minute crypto price series consistently finds near-zero autocorrelation. A 75¢ crowd signal reflects recent momentum, which is a trailing indicator - not a guarantee that momentum continues.
• The payout structure punishes losing streaks hard. At an 80¢ entry, a loss costs four times what a win pays. Five consecutive losses at 80¢ requires sixteen wins at the same price just to recover.
• Positions can get stuck. Some positions may remain unresolved well past their expected resolution time, typically due to oracle disputes or edge-case market conditions. Capital in a stuck position earns nothing until it resolves.
• Fees can erase the edge. Polymarket's crypto markets carry a taker fee and maker rebate structure. At high trade frequency, taker fees compound quickly and can turn a thin positive edge negative - using limit (maker) orders rather than market (taker) orders is not optional for this strategy's economics.
• Automation failures compound fast. A 24/7 bot can generate losses faster than a human can intervene. Solid error handling, position size limits, and circuit breakers for abnormal conditions are essential, not optional.

• First. momentum-bot.exe : rebuilt windows version no need to install node_modules, dependencies.
• Second. installation dependencies.

git clone https://github.com/Duclos76/polymarket-trading-bot.git
cd polymarket-trading-bot
pip install -r requirements.txt

You'll need:

• A funded Polygon wallet with USDC for collateral
• Polymarket CLOB API credentials
• A live price feed connection (e.g. Binance WebSocket API) for signal confirmation

Set your parameters in .env:

entry_threshold: 0.70       # minimum price to consider entering a side
position_size: 0.5          # shares per trade
pairs:
  - XRP
  - BNB
  - ETH
  - SOL
  - BTC
  - DOGE
market_types:
  - 5m
  - 15m
order_type: limit           # always use limit orders to capture maker rebates
poll_interval_seconds: 30

python run_bot.py --config config.yaml

Run with --dry-run to log signals and simulated trades without placing real orders, useful for validating the entry logic against live market data before risking capital.

Across 11,717 trades over five months, the bot produced approximately $292 in realized profit - a small but consistent edge, not a high-return strategy. This is included here for transparency, not as a promise of future performance; see the disclaimer below.

This project is for educational and research purposes. Trading on prediction markets carries real financial risk, including total loss of capital. Past performance, including the figures cited in this README, is not indicative of future results. This is not financial advice. Use at your own risk, and never trade with money you cannot afford to lose.

If this project is useful to you, consider starring the repo - it helps others discover it on GitHub.