# Bot Strategies — Detailed Reference

Nine proven directions for Polymarket bots. Each entry covers: the source of edge, capital + skill requirements, realistic hit rate, the competition you'll be up against, and the failure modes that consistently kill builders trying that direction.

## Table of contents

1. [Copy-trading bot](#1-copy-trading-bot)
2. [Single-market rebalancing arbitrage](#2-single-market-rebalancing-arbitrage)
3. [NegRisk multi-condition arbitrage](#3-negrisk-multi-condition-arbitrage)
4. [Cross-platform arbitrage](#4-cross-platform-arbitrage)
5. [End-game sweep](#5-end-game-sweep)
6. [Market-making](#6-market-making)
7. [AI / LLM-driven discretionary](#7-ai--llm-driven-discretionary)
8. [Whale / insider tracker (alerts only)](#8-whale--insider-tracker-alerts-only)
9. [5-minute crypto Up/Down](#9-5-minute-crypto-updown)
10. [Strategy comparison matrix](#10-strategy-comparison-matrix)

---

## 1. Copy-trading bot

**What it is.** Watch one or more profitable wallets via Polymarket's Data API or a Polygon node, detect new trades in real time, mirror them on your own wallet at a configurable copy ratio.

**Source of edge.** None of your own — you're piggybacking on someone else's information edge. Works only if (a) the wallet you copy actually has edge, not just luck, (b) you mirror fast enough that the price hasn't moved against you, (c) the wallet's edge survives being followed.

**How to pick targets.** *Not* by overall PnL. The right filters are:
- Win rate within a **specific market category** (politics ≠ crypto ≠ sports — a wallet that's amazing at politics is often noise in sports)
- Sharpe ratio across many trades (consistency beats home runs)
- Average position size relative to market liquidity (if they move the market themselves, you'll get worse fills)
- Time to resolution (shorter markets free up your capital faster)
- Number of trades ≥ ~50 (under that, it's variance)

**Required pipeline.**
1. **Detect** — subscribe to the user channel WebSocket filtered by the target wallet, or poll `/data-api/activity?user=<wallet>` every 1–2s with transaction-hash dedup.
2. **Validate** — skip if market resolves in < N hours (default 24), if liquidity is below floor, if you're already in a correlated position, if size is below `MIN_TRADE_USD` (skip dust).
3. **Size** — `min(target_size * COPY_RATIO, MAX_TRADE_SIZE)` with hard daily cap.
4. **Execute** — FOK first, with a 3-phase retry: try at target price, then ±1.5%, then max slippage. Log the failure if all three miss.
5. **Track** — record original trade hash + your trade hash to one row in JSONL so you can compute slippage and lag at the end of each day.

**Realistic latency.** 1.5–2.5s end-to-end on healthy Polygon when using WebSockets. 4–14s if you poll. Slow enough that you should **not** copy wallets that themselves use HFT — you're competing on the same fills.

**Capital.** Works at any size. With $500 and 5% copy ratio you're mirroring trades up to $25 of theirs, which is realistic for politics/sports markets but trivial in crypto markets. Bullpen-CLI demos are typically $5/trade fixed sizing.

**Top failure modes.**
- Copying overall-leaderboard wallets without category filtering (the #1 wallet last month is often a YOLO that won)
- Copying wallets that themselves copy others (cascading lag)
- Copying *exits* but not entries (or vice versa) because you started watching after they entered — the bot must skip exits if it doesn't hold a position
- Mirroring on terminal markets (resolves before you can sell)

**Competitors.** Bullpen, PolyGun, PolyCop, Polydupe, TradeFox. They all charge fees. Building your own gets you zero fees and total control over filters; downside is you maintain it.

---

## 2. Single-market rebalancing arbitrage

**What it is.** YES + NO must sum to $1.00 at resolution. If at any moment YES ask + NO ask < $1.00, buying both legs is a guaranteed profit equal to (1 − sum) per matched share, minus the 2% Polymarket fee on profits and Polygon gas (~$0.01).

**Source of edge.** Order books are independent — the YES book and NO book have different makers and different latencies. Retail traders react to news on one side first. For a few hundred milliseconds the cross-book sum drops below $1.

**Realistic edge after costs.** You need spreads > 2.5–3% to clear fees + gas + slippage. Below 2.5% it's a losing game.

**Required pipeline.**
1. **Subscribe** to `wss://ws-subscriptions-clob.polymarket.com/ws/market` for both `assets_ids` (YES token id + NO token id) of every market you cover.
2. **Maintain a local order book** per token id. Apply REST snapshot from `/book` once at startup, then patch with `book` and `price_change` events. On any disconnect, refresh the snapshot before resuming.
3. **On every event**, compute `best_yes_ask + best_no_ask`. If `< 1 - threshold`, fire two FOK orders simultaneously.
4. **Sequence the legs.** Send both legs in parallel — Polymarket arbitrage is non-atomic, so one leg can fail while the other fills. If one leg fails, immediately market-sell the filled leg to flatten exposure rather than holding directional risk.
5. **Cap position** to a small fraction of the thinner book — taking 100% of the offer makes the price snap back before your second leg lands.

**Capital.** $1k–$10k is fine for a single-market bot. Multi-market parallel scanning needs $20k+ to make IRL latency advantages pay out.

**Competitors.** Tightly contested. The arxiv paper (Saguillo et al., 2025) found one trader extracted $2,009,632 from 4,049 trades — $496 average — but that's the top of the leaderboard. Lower tiers are running on 50–200 ms execution; if you're in Python from a residential connection you will not win the same opportunities.

**Where you can still win.**
- New markets that the big bots haven't whitelisted yet
- Markets at unusual hours / sleepy categories (entertainment, certain sports)
- Niche conditions (long-tail multi-outcome events)

**Top failure modes.**
- Stale local book — you fire on data that's already 800ms old, the arb is gone
- Forgetting the 2% fee in your edge calc (it applies to profits, not notional, but at small spreads it dominates)
- Running on REST instead of WS (you will never be fast enough)
- Both legs fail and you're left holding directional risk. Always have a flatten-on-error path.

---

## 3. NegRisk multi-condition arbitrage

**What it is.** Same as #2 but across an event with N ≥ 3 mutually exclusive options (e.g. "Who wins the election?" with 4 candidates, "How many Fed rate cuts in 2025?" with 9 buckets). If sum of the YES asks across all N options < $1, buying one share of each is a guaranteed $1 payout for less than $1 cost.

**Source of edge.** Liquidity fragments across many outcomes. Retail concentrates flow on the favorites; the long-tail outcomes trade thin and often stale. The complementary probability is mispriced more often than in two-sided markets.

**Why it's the biggest opportunity historically.** The IMDEA/arxiv study (Apr 2024 – Apr 2025) attributed **$29M of $39.59M total documented arbitrage to NegRisk rebalancing** — 73% of the profit despite being 8.6% of opportunities. About 29× more capital-efficient than binary single-market arb.

**Critical mental model — DO NOT confuse NegRisk arb with NegRisk markets.**

Polymarket has a "NegRisk" feature that lets you buy 1 share of each outcome for a fixed $1 collateral (instead of the sum of asks). This is a **capital efficiency** feature, not arbitrage. You still pay $1 to receive $1 — zero profit.

> True NegRisk arbitrage = buying via the **standard** interface when sum_of_asks < $1.
>
> Using the NegRisk collateral mechanism when sum_of_asks < $1 destroys your profit (you'd pay $1 for $1).

If sum_of_asks > $1: NegRisk gives you capital efficiency (lock $1 instead of e.g. $1.05). Still no profit.

If sum_of_asks < $1: **use standard markets only**. NegRisk would erase your edge.

**Required pipeline.** Same as #2 but the scanner walks every event with N ≥ 3 conditions, sums the asks, gates on (1 − sum) > threshold + fees, then submits N parallel FOK orders. Cap each leg by min(book_depth_share, MAX_PER_MARKET_NOTIONAL).

**Top failure modes.**
- Treating "use NegRisk" as the strategy. It isn't.
- Fail-to-fill on one of N legs and being underweight one outcome — same flatten-on-error rule as #2.
- Operating in events where the conditions aren't actually mutually exclusive (rare, but it happens with poorly-worded markets — verify on chain).

---

## 4. Cross-platform arbitrage

**What it is.** Same event on Polymarket and Kalshi (or Limitless, Opinion Labs, Manifold). Different prices because different audiences and different liquidity. Buy on the cheap side, sell on the expensive side.

**Source of edge.** Polymarket is crypto-native and global; Kalshi is US-regulated and KYC'd. They attract different traders and react to news at different speeds. The same FOMC decision often shows a 3–8 cent spread between the two for the first 10–60 seconds after announcement.

**The "leg risk" trap.** Make sure both venues resolve from the **same source**. If Polymarket resolves "Bitcoin closes above $100k Dec 31" using Coinbase and Kalshi resolves it using a different reference price, you have basis risk, not arbitrage. Confirm resolution sources before treating two markets as identical.

**Capital allocation formula.** To guarantee a $1 payout regardless of outcome:
```
investment_A / investment_B = price_A / price_B
```
Solve for sizes such that you end with the same $ payout on Yes-resolution and No-resolution.

**Required pipeline.** Two API clients running in parallel, one per venue. Per minute (or on event triggers), compute spread net of both venues' fees. Above threshold, fire both orders. Hedging on Kalshi requires its own API + approved KYC'd account.

**Top failure modes.**
- Assuming resolutions match without confirming the source contract / oracle
- Latency between legs — if Kalshi takes 4s to confirm and Polymarket takes 0.5s, you can be 2 cents underwater before the hedge fires. Use a max-leg-latency abort.
- KYC / withdrawal friction on Kalshi — capital can be stuck for days

---

## 5. End-game sweep

**What it is.** When an event has materially settled but the market hasn't been resolved yet (waiting for the UMA optimistic oracle's challenge period), the favored side trades at $0.95–$0.99. Buying at, say, $0.97 and waiting up to 48 hours for resolution gives a guaranteed ~3% return.

**Source of edge.** Patience and capital. You're trading time for certainty. UMA's challenge window is typically a few hours but can stretch; large markets can take 1–7 days to settle when contested.

**Quote from veteran trader "fish":**
> About 90% of large orders over $10,000 are executed at prices above 0.95. … Don't underestimate this 0.5%. If you invest $10,000, you earn $50 per trade. Do dozens of trades a day, and the annual return is amazing.

**Required pipeline.**
1. Scan for events tagged "resolved" in news (sports score finalized, election called by AP, court ruling published) but not yet settled on Polymarket.
2. Validate via a category-specific oracle (e.g. ESPN scores API for sports, AP/Reuters for politics, CoinGecko for crypto).
3. Buy at the best available price ≤ ceiling (default 0.99). Use limit orders, not market — you don't need to take instantly.
4. Hold until resolution. Capital is locked for hours-days.

**Capital.** Scales linearly. The strategy works equally at $1k and $1M; the absolute return is just bigger.

**Top failure modes.**
- **Black swan resolution** — UMA voters override the obvious answer (rare but documented; no refunds). Mitigate by skipping markets with active dispute history or where the oracle has a track record of strange resolutions.
- Buying too early — the "settled" event could have a recount, replay, etc.
- Locking too much capital in one market — diversify.

---

## 6. Market-making

**What it is.** Place limit orders on both sides of a market's book, near the midpoint. Earn the spread when both sides fill. On Polymarket, also earn explicit **maker rewards** on qualifying markets.

**Polymarket maker rewards** are a published incentive: certain markets pay rewards proportional to your share of resting orders within a defined band around the midpoint. The reward formula optimizes tighter quoting and bigger size; see Polymarket docs for the current schedule.

**Source of edge.** You're providing liquidity. Two profit components: (a) bid-ask spread when filled both sides, (b) explicit maker rewards. The cost is inventory risk — if news breaks and you're filled on only one side, you're stuck with directional exposure.

**Required pipeline.** This is the most complex of the nine.
1. **Whitelist markets** with sufficient depth, recent volume, and ideally maker rewards available.
2. **Maintain local books** for each via WebSocket.
3. **Quote** at midpoint ± half-spread, with size and offset functions of inventory and volatility. Re-quote on every meaningful book change (price move > tick, or your quote becomes stale).
4. **Inventory management** — if you've drifted long YES, widen your bid and tighten your ask until inventory rebalances; same in reverse for NO.
5. **Reward optimization** — if the market pays rewards, position your quotes inside the rewardable band. Expect competitors to do the same; the band fills up.
6. **Risk** — hard inventory caps per market, hard daily PnL stop.

**Reference implementations.**
- `Polymarket/poly-market-maker` (official, "Bands" or "AMM" strategy)
- `warproxxx/poly-maker` — adds Google Sheets parameter control, position merging via `poly_merger`, automatic market selection by reward
- `terrytrl100/polymarket-automated-mm` — fork with reduced order churn (1.5% / 25% cancellation thresholds vs 0.5% / 10%)

**Capital.** Realistically $5k+ to make rewards math work after gas. Below that, you spend more in re-quotes than you earn.

**Top failure modes.**
- Adverse selection — informed traders only hit you on stale quotes. If your fill rate is "I get hit before I can re-quote", widen your spread.
- Inventory blowup on news — set hard inventory caps.
- The Feb-2026 nonce-cancellation attack (see `risks-and-pitfalls.md`) specifically targets makers. Run "Nonce Guard" or equivalent.
- Quoting on resolving markets — once T-15min hits, quotes are dangerous, just stop.

---

## 7. AI / LLM-driven discretionary

**What it is.** The bot reads a market's question (e.g. "Will the EU ratify the AI Act by Q3?"), sends it to Claude (or another LLM) with web search enabled, and asks for a structured Yes/No + confidence. Trade only when confidence is High.

**Source of edge.** The LLM does fast, breadth-first research that humans don't have time for. Combined with the structured output, the bot can scan hundreds of markets per hour and only act on the few where the model is confident and the market price disagrees materially.

**Use Anthropic tool use for structured output.** Define a schema with `decision` (Yes/No), `confidence` (Low/Medium/High), and `reasoning` (≤200 chars). The model returns JSON, no parsing required. The reference Python implementation is ~180 lines.

**Trading logic.**
- Confidence = High and decision = Yes → buy YES if price < 0.55
- Confidence = High and decision = No → buy NO if price > 0.45
- Confidence = Medium → only trade if mispricing is extreme (>20% gap)
- Confidence = Low → never trade

**Required pipeline.**
1. Pull active markets from Gamma API filtered to the user's category whitelist.
2. For each, call `ask_claude(question, description)` with web search enabled. Cache by `condition_id` for 6h to control API spend.
3. Decide → place GTC limit order at a buy price that gives you ~5% expected edge after fees.
4. Manage exits — close on resolution (automatic), or earlier if the model's view changes meaningfully on a re-poll.

**Cost structure.** Claude API isn't free. A serious 24/7 setup is $3k–$10k/year in API tokens. Mitigations: cache aggressively, only re-evaluate on news triggers, use `claude-haiku-4-5-20251001` for first-pass filtering and Sonnet/Opus only for hot markets.

**Capital.** $1k–$5k is a sensible test size. Edge is per-decision; this is not high-frequency.

**Top failure modes.**
- Hallucinations on niche topics — the model confidently states something that's not true. Mitigate by requiring web search, requiring at least 2 corroborating sources in the reasoning.
- Recency bias when the market has already priced in the news the model is reading. Always check the `lastTradeTime` and price drift before trading.
- Spending more on API than the bot earns. Hard cap monthly API budget in the bot.
- Poorly-worded markets — markets resolve based on exact wording, not the spirit. The model needs to read the **resolution criteria**, not just the title.

---

## 8. Whale / insider tracker (alerts only)

**What it is.** Watch a list of flagged wallets (insiders, top traders, suspicious-pattern wallets), push a Discord/Telegram alert when they trade. **No auto-execution.** Lowest-risk first project, often the right starter.

**Source of value.** You read alerts, decide whether to act manually. Surfaces information you couldn't watch yourself; doesn't burn capital on bad signals.

**Required pipeline.** Trivial.
1. Poll `/data-api/activity?user=<wallet>` every 5–10s for each wallet, dedup by transaction hash.
2. Filter — min trade size, exclude resolved markets, exclude entries you've already seen.
3. Alert — POST to Discord webhook or Telegram bot API. Include: wallet alias, market title, side, size, price, link to the market, link to the wallet's profile.

**Capital.** Zero. You're not trading.

**This is also the perfect first pipeline for any other strategy.** Build the alerter first (1 day), watch alerts for a week to confirm signal quality, then upgrade to auto-execution.

**Top failure modes.** Almost none. Worst case: too many alerts, you turn off notifications. Solution: tier alerts (high/medium/low) and only sound a tone for high.

---

## 9. 5-minute crypto Up/Down

**What it is.** Polymarket runs continuous 5-minute markets on BTC/ETH/SOL/XRP — "will price be up or down vs the start of the window". The bot uses real-time Binance data + a simple TA model + Chainlink reference price to enter at T-10s.

**Source of edge.** Polymarket liquidity in these markets is thin ($5k–$50k per window). Odds lag behind real spot price. In the last 5–7 seconds before close, the outcome is much more deterministic than the price implies.

**Critical detail — the strike price.** Polymarket resolves these markets against Chainlink's BTC/USD (etc.) feed at the exact window-close timestamp. The "Price To Beat" is the first Chainlink price at/after the window-open boundary. **Subscribe to RTDS WebSocket** at `wss://ws-live-data.polymarket.com` with `crypto_prices_chainlink` filter — this gives you the same oracle Polymarket uses, with no lag.

**Required pipeline.** Markets follow deterministic slugs:
```python
window_ts = now - (now % 300)        # current window start
close_time = window_ts + 300         # window closes 5 min later
slug = f"btc-updown-5m-{window_ts}"  # Polymarket slug is deterministic
```
1. At T-10s, compute delta = (current Binance price − window-open Chainlink price) / window-open price.
2. Translate delta to a target token price (the side that's "winning" trades richer):
   - delta < 0.005% → ~$0.50 (coin flip)
   - delta ~ 0.02% → ~$0.55
   - delta ~ 0.05% → ~$0.65
   - delta ~ 0.10% → ~$0.80
   - delta ~ 0.15%+ → $0.92–0.97
3. Trade only if your model + delta agree and the Polymarket price is materially below your model price.
4. **Liquidity-fallback**: when the winning token has zero ask-side, post a GTC buy at $0.95 — you become the liquidity. Polymarket minimum is 5 shares, so minimum spend is $4.75.
5. Auto-claim on win — the bot uses Playwright to click "Redeem" in the UI if there's no API path; alternatively, on-chain `redeemPositions` call.

**Capital.** Tiny entries ($5–$50 per window). High volume — 288 windows per day per asset, 4 assets = 1,152 attempts/day. Even at low hit rate this compounds.

**Top failure modes.**
- Using Binance as the strike price source (it's not — it's Chainlink). You'll be off by a few cents constantly.
- Trading every window — you should have a "no edge, skip" branch. Most windows are coin flips.
- Slippage — at $4.75 minimum spend, fees are a large % of profit. Stay > $5k volume markets.
- Late entry — past T-5s, the price has already absorbed everyone else's late entries.

---

## 10. Strategy comparison matrix

| Strategy | Min capital | Skill level | Hit rate | Latency req | Capital lock | Competition |
|---|---|---|---|---|---|---|
| 1. Copy-trading | $200 | Low | depends on target | medium (1–3s) | until target exits | high (many tools) |
| 2. Single-market arb | $1k | Medium | very high | very high (<200ms) | seconds | very high (HFT) |
| 3. NegRisk arb | $5k | Medium-High | very high | very high | seconds | high |
| 4. Cross-platform arb | $5k+KYC | High | high | high | minutes | medium |
| 5. End-game sweep | $5k | Low | very high | low | hours-days | medium |
| 6. Market-making | $5k | High | n/a (continuous) | high | continuous | very high |
| 7. AI / LLM | $500 | Low | medium | low | hours-weeks | low (early days) |
| 8. Whale tracker | $0 | Low | n/a (alerts) | low | none | medium |
| 9. 5-min crypto | $200 | Medium | medium | high | 5 min | medium |

**Recommendation for first build:** if user is new → #8 (alert only) → #1 (copy trading) → upgrade. If user is experienced and capital-rich → #5 (end-game) is the most reliable income with the least operational complexity. For software-engineering-curious users → #7 (AI) is the most fun and gives the cleanest codebase.