Two-sided accumulation · Capital recycling · Risk controls

How arbitrage bots work on Polymarket, end to end.

Almost everything a Polymarket arbitrage bot does collapses into one rule and a few guards around it. This guide walks that rule outward, through the data feeds, the decision engine, capital recycling, risk controls, the configuration profiles, and the validation ladder, roughly in the order they fire inside a live system. It explains the strategy in general and the features it can incorporate, not any single bot.

The invariant
Buy side S only when  price(S) ≤ C − avg(other side)

…and only to (a) build toward a hedged pair or (b) average down a side you already hold. Bound directional risk with a max-imbalance cap. Pace capital with a soft budget. Act on dips, not every tick.

9
stages explained
10
example configs
5
live data feeds
7
build phases
Start here · the one idea

Why two cheap halves beat one expensive whole

Before any code, the whole strategy fits in one idea. If you understand this section, every step after it is just plumbing around it. No prediction-market background assumed.

① A market is a $1 coin

Every binary Polymarket question splits into two tokens, YES and NO (here: side A and side B). At resolution exactly one is worth $1 and the other $0. You never need to know which.

② The two prices sum to ~$1

Because one side always pays $1, the market prices them so price(A) + price(B) ≈ $1. If A trades at $0.60, B trades near $0.40. They move as a seesaw.

③ Own both for < $1 = locked profit

If you hold one A and one B, resolution pays you exactly $1 no matter the outcome. So if the pair cost you less than $1 to assemble, the difference is risk-free profit, already locked.

The catch, and the whole trick. You can never buy both sides for under $1 at the same instant. At every moment the book offers askA + askB > $1 (if it dipped below, it would be free money and get taken in seconds). The edge does not live in the spread. It lives in time. Because A and B seesaw, their dips never line up: A bottoms out exactly when B peaks. So you buy A only during A's dips and B only during B's dips, at different moments. Each side's blended average reflects only its own cheap moments, and two bargain-hunted averages can add up to well under $1.
Trough-picking across one market
ask A ask B buy A (A is cheap) buy B (B is cheap)
The buy markers never stack on the same vertical line. Side A is bought near its lows, side B near its lows, and those lows fall at opposite times. Add the two bargain averages and the combined cost lands well under $1. The gap shown is generous for legibility; real markets cluster around $0.95 to $0.99.

The ratchet: each buy makes the next one easier

Buying a side cheaply pulls down its average, which raises the price you can still afford on the other side while staying under the ceiling. The two sides ratchet each other down. Start balanced at $0.50 / $0.50 (combined $1.00), buy B at $0.30 on a dip, then A at $0.30 when the seesaw flips, and the matched pair now costs $0.80. Keep repeating that the whole market long.

Worked example, in dollars

You already hold 100 of B at an average of $0.45. With ceiling C = 0.97, the most you may pay for A is C − avg(B) = 0.97 − 0.45 = 0.52. A's ask is $0.49, which clears, so you buy. The pair now costs 0.49 + 0.45 = $0.94 and locks $0.06 of profit per matched share.

violate it: force A at $0.80 in a blowout → pair $1.25 → −$0.25 locked loss
Key terms, one line each. Skim now, refer back later.
side A / B
the two tokens of one market. Together they pay exactly $1 at resolution.
pair
one A plus one B. Always worth $1 at resolution, so its locked profit is $1 − (cost of the pair).
combined avg / sumAvg
avg(A) + avg(B). The single number that decides everything: below $1 means every matched pair is profit.
C (combined ceiling)
the highest combined avg a bot will allow. Lower C means stricter, more profit per pair, fewer fills.
the gate
the one rule: buy side S only when price(S) ≤ C − avg(other side).
edge
how far below the ceiling a price is: cap − price. The locked profit that buy adds per pair.
clip
the base order size, in shares. Grows on deeper discounts, tapers as capital fills up.
entry
the price threshold for the very first buy, before any position exists.
patience
minimum wait before a non-bargain rebalancing buy. Stops a bot from chasing every tick.
imbalance cap (imb)
max allowed |qA − qB|. The hard bound on one-sided, directional risk.
average down
buying more of a side you already hold, but only when it has gotten cheaper than your average.
capture
buying the side you are light on, to complete a pair.
Merge
an on-chain call that converts matched pairs back to cash (pUSD) before resolution, freeing capital to redeploy.
Redeem
claiming the $1 payout on leftover positions after the market resolves.
VWAP
volume-weighted average price. Here, just your average cost across all fills on a side.
maker / taker
a resting limit order is a maker (free, may not fill); crossing the spread now is a taker (fast, pays fees).
neg_risk
a market flag that routes merges through a different contract. Does not change the economics.
Overview

The system, at a glance

One stage feeds the next: data in, a decision out, the risk manager vets it, execution places it, and the fills loop back. Scroll any section below and its box lights up here.

inputs
Data feeds
  • CLOB market ws · live book, best ask
  • CLOB user ws · fills, position, avg
  • Gamma api · tick, neg_risk, ids
decide(book, pos, cfg)
Decision engine
  • gate · eligibility
  • triggers · sizing
  • pure · deterministic
guards
Risk manager
  • imbalance cap
  • budget · hard stop
  • kill switches
place orders
Execution
  • CLOB V2 client
  • marketable limit / FOK
  • rate-limit · heartbeat
Fills report back on the user channel, updating position and average cost, which re-enter the engine on the next book update. The book and the position are the only state the engine needs.
runs continuously · off the gate
Capital recycler

Reads the live position and calls the on-chain CTF contract: Merge matched pairs to pUSD before resolution to recycle capital, Redeem leftovers after. Freed cash flows back into the deployable budget.

one engine · three modes
Validation harness

The same pure engine runs against three data sources: replay on recorded books, shadow on the live feed with paper fills, then live. What you test is exactly what you run.

data & execution engine & capital path risk guards validation
1
Step 1 · what flows in

Required data inputs

Five sources feed the decision engine. Two WebSocket channels carry the live truth; REST and the on-chain contract handle metadata and capital. A sound engine reads both token order books directly. It never synthesizes one side's price from the other.

ws Market channel

In plain termsA live feed of who wants to buy and sell each side, and at what price, updating moment to moment.

It streams the order book over a WebSocket (a persistent connection that pushes updates instantly, with no repeated polling). The best ask is the lowest price someone will sell at, the bid is the highest someone will buy at, and the mid sits halfway between.

best_ask · ask_size · bid · mid

ws User channel

In plain termsWhat you actually own, based on trades that truly executed rather than what you hoped would happen.

A fill is an order that actually traded, in full or in part. Your position and average cost are rebuilt from real fills, never from assumptions, so the bot always knows its true exposure.

trade → qty · cost · avg

rest Gamma API

In plain termsA lookup service that hands you the basic facts about a market before you trade it.

It returns the token ids to subscribe to (each outcome is its own token), the tick (the smallest price step a market allows, for example one cent), and the neg_risk flag that selects the correct on-chain Merge path.

token1/2 · tick · neg_risk

rest Order lifecycle

In plain termsThe calls that place, cancel, and batch your orders, plus one easy-to-forget setup step.

CLOB V2 (the exchange's order-matching system) needs a /balance-allowance/update call to sync on boot, and again after funding, before any order is accepted. Skipping it is the top cause of silent V2 failures.

/order · /balance-allowance/update

chain CTF contract

In plain termsThe on-chain tool that turns your matched shares back into spendable cash so you can keep trading.

On Polygon, you Merge a pair of opposite shares back into $1 to recycle capital early, and you Redeem after the market resolves to collect the winning side.

mergePositions · redeemPositions

opt Edge enhancers

In plain termsExtra information a bot can bolt on to trade smarter, though none of it is required for a first working build.

Examples include a live score or game-clock feed, or a reference book from another venue like Pinnacle or Binance to compare prices against.

score feed · external book
Critical. The simulator derives one side's ask from the other (askB ≈ 1 − askA). Live, each token has its own independent order book, and at every instant askA + askB > $1. Always read both books directly. Never synthesize one side's price from the other.
2
Step 2 · the heart of it

The decision engine & the gate

The engine is one pure function, decide(book, position, config) → Intent | null. It does no I/O and is fully deterministic, which is exactly what lets the same code run in simulation, offline replay, and live trading. Drag the sliders below to watch the gate accept or reject a buy in real time.

Load a preset's settings into the gate and the live demo:

Gate inputs

The gate accepts a buy only if its price keeps the combined cost of a hedged pair (one share of each side, worth exactly $1 at resolution) at or below the ceiling C. Buy both sides for less than C and the difference is locked-in profit.
Combined ceiling  C0.97
Your avg on the other side0.45
Best ask on the side you'd buy0.49
0.00price · cap · $1.001.00
ELIGIBLE

① Gate

In plain termsIt refuses any buy that would make a completed pair cost more than your target, so a finished pair always profits.

If price > C − avg(other) the buy is rejected, where avg(other) is what you have already paid per share on the opposite side.

② Eligibility

In plain termsEvery buy needs a real reason: either to even out a lopsided position, or to genuinely lower your average cost.

A buy must build toward balance (move the two sides closer to equal) or be a true average-down, priced below your current average by at least the edge you require. No reason means no buy.

③ Imbalance cap

In plain termsIt stops the bot from piling onto one side and quietly turning into a directional bet.

A buy that does not move toward balance is refused once |qA − qB| ≥ imb, where qA and qB are your share counts on each side and imb is the cap on how far apart they may drift.

3
Step 3 · when to act, and how much to buy

Triggers and sizing: turning a yes into a trade

The gate in Step 2 only decides whether a buy is allowed. It does not say a buy is a good idea right now. A trigger is the bot's reason to act this instant instead of waiting. If none of the three below is true, the bot does nothing, and that restraint is the whole point: it buys on real dips and genuine rebalancing needs, not on every flicker of the price. Any one trigger is enough to fire.

Buy the dip freshTrough

The price just set a new low for this side, the cheapest it has been since the last buy here. That signals a real dip rather than ordinary jitter, so the bot steps in while the discount is genuinely on the table, before the price ticks back up.

fires when: ask ≤ its running low + 0.003

Grab a bargain deep

The price has fallen so far below the ceiling that the profit this buy locks in, its edge, is unusually large: at least six cents per pair. A discount that big is worth taking right away, so this trigger overrides the usual patience and buys immediately.

fires when: edge ≥ 0.06 (six cents under the cap)

Rebalance on patience patient

No dramatic dip, but two things are true at once: enough time has passed since the last buy (the patience window), and the bot holds fewer shares of this side than the other. It tops up the lagging side to complete more pairs, rather than sitting idle waiting for a dip that may never come.

fires when: waited ≥ patience AND this side is behind

How much to buy

Once a buy fires, its size scales with the opportunity. The base order (the clip) grows up to five times larger as the discount deepens, so the best prices get the most capital. It can also jump to close a gap when one side has fallen behind. Then, as the capital already deployed in a market approaches its budget, every order tapers down, so the bot eases off the gas rather than going all in.

size = clip × (deeper discount, up to 5×) × taper

The one hard stop

Everything above is soft pacing: gentle nudges up or down. There is exactly one absolute refusal. Once the capital deployed in a single market reaches three times its budget, no new buys are allowed, period. It is the backstop that caps how much can ever be at risk in one market.

no new buys once deployed ≥ 3 × budget
Interlude · Steps 1 to 3, running live

Inspect every decision the engine makes

A reference implementation runs the exact gate, triggers, and sizing described above, tick by tick on a synthetic price path, using the Balanced config. It is not an animation to watch passively. Press Play, then pause and hover any dot to read the full reason that order fired: the gate math, the trigger, the eligibility, and the config behind it. The one number to watch is Combined avg in the ledger. As long as it stays at or below the ceiling C, every completed pair is locked profit.

How to read this
━ ◦ A price of side A, and a hollow dot for each arbitrage buy on A. Bigger dot means a bigger clip.
━ ◦ B price of side B, and its arbitrage buys. A and B seesaw around $0.50.
◆ trend a directional Trend Rider bet. This rides a runaway winner and is not a hedge (see below).
⊘ exit a Trend Rider bet that hit its trailing stop and was closed.
| Merge matched pairs cashed in early, locking their profit and freeing capital.
log + ledger every action with its reason, plus live shares, combined avg vs C, locked P&L, and capital deployed.
Choose a market scenario to run the engine against:
Lakers vs. Celtics · oscillating C 0.97 clip 30 budget $400 imb 300
pause, then hover a bet ●
0 / 0
Shares A / B
Combined avg (≤ C wins)
$0
Locked P&L
$0
Deployed
Relative, not a forecast. The price path is synthetic. Real dollar figures come only from deterministic replay against recorded books (Step 8). What transfers is the discipline: pairs lock profit, one-sided risk stays capped.

◆ Trend Rider: an optional feature

One feature some bots add. A rolling window watches each side's ask, and when one side trends cleanly in a single direction (a large net move with a high fraction of same-direction steps and little chop) the bot flags a stable one-way market. The arbitrage gate would keep rejecting the rising favorite, so trend mode can override it.

net move ≥ trendMove · same-direction ≥ trendConsist over trendWindow ticks

Riding the winner, and the risk

On detection a bot can buy the rising (winning) side directionally, riding it toward $1 at resolution. That is a momentum bet, not a hedge. It is no longer arbitrage: exposure is capped to a trend budget and it stops the moment the trend breaks. This is distinct from "forcing the second leg," which pairs the winner against held inventory and locks a loss.

buy rising side ≤ trendMaxPrice · exposure ≤ trendBudget · stop on reversal
4
Step 4 · freeing capital

Capital recycling

A matched pair (one A share plus one B share) is guaranteed to be worth exactly $1 when the market resolves. The key insight is that you do not have to wait for resolution to collect it. You can convert matched pairs back into cash immediately and redeploy that cash into the next dip. This recycling runs continuously, outside the gate, and it is what lets a small bankroll trade many times its own size.

Merge · before resolution

One A share plus one B share is a complete set, and a complete set is always worth exactly $1: whichever side wins pays $1, the other pays $0. The on-chain Merge operation (mergePositions) burns a complete set and returns $1 in collateral (pUSD) right away, with no need to wait for the market to resolve. The neg_risk flag only decides whether that Merge routes through the standard contract or the NegRiskAdapter.

How many pairs can you Merge? Exactly min(qA, qB), the smaller of your two share counts, where qA is the shares of A you hold and qB the shares of B. A pair needs one of each, so the number of complete pairs you own is simply whichever side you hold less of. Merging those pairs locks in their profit and frees the cash to redeploy, leaving only the surplus on the heavier side as open inventory. Bots batch their Merges so the Polygon gas cost stays small next to the capital freed.

Merge min(qA, qB) pairs → min(qA, qB) × $1 in pUSD

Redeem · after resolution

Whatever inventory is left when the market settles, the unmatched surplus on one side, is cashed out with the Redeem operation (redeemPositions). Once the oracle reports the result, Redeem pays $1 for each winning share and $0 for each losing share.

Capital stays locked inside a position until you Merge it or Redeem it: those are the only two ways to turn shares back into cash. Merge is the early exit for pairs you have already hedged, and Redeem is the final settlement for everything still open at the end.

Redeem after the oracle → $1 per winning share, $0 per losing share
5
Step 5 · the guards

Risk controls & kill switches

The guards that keep one bad market from becoming a bad day. The most important is a rule about what a bot must never do.

Imbalance cap

In plain termsIf you keep buying one side more than the other, you are quietly making a directional bet. This cap limits how lopsided your two stacks of shares can get, so you stay hedged instead of gambling on an outcome.

Stop adding to the heavy side once the gap hits the limit: |qA−qB| ≥ imb bounds directional exposure (the part of your position that wins or loses with the market).

Per-market capital

In plain termsA ceiling on how much you put into any single market, so one trade cannot sink you. The bot slows down as it nears the planned amount, and flatly refuses to go far past it.

Soft taper as you approach budget; hard refuse at 3 × budget.

Trend kill

In plain termsArbitrage assumes prices wobble around a fair value and come back. If the price just keeps marching one way, that assumption is broken and the bot should stop opening positions.

If signed flow (net buying pressure, with direction) stays beyond 2σ (two standard deviations, an unusually large move) with no reversion, stop initiating and Merge what exists.

Daily loss limit

In plain termsA hard stop for the day. Once total losses reach a set ceiling, the bot shuts off new trades so a bad day cannot become a disaster.

Global circuit breaker. Halt all new intents past the limit.

Fee-adjusted gate

In plain termsA trade that looks profitable before fees can be a loser after them, so the bot checks the after-fee number before committing.

Run C_effective (your ceiling after fees), never raw C, in taker mode (Step 6).

Heartbeat & resolution

In plain termsIf the bot loses its live connection it may be trading on stale prices, so it resyncs first. And once a market is closing out, it stops trading it.

Resync on a heartbeat lapse (a missed "still alive" ping); stop trading once a market enters settlement (the final payout phase).

Never force the second leg. Once you hold one side of a hedge, it is tempting to buy the other side at any price just to "complete" the pair. Do not. Forcing the expensive winning side to complete a hedge near full time pushes combined VWAP (your average price paid across both sides) over $1, a guaranteed loss, and it is the exact mechanism behind the large drawdowns documented in real arbitrage wallets. On a market that never swings back, the disciplined move is to accept small, capped, cheap one-sided inventory.
6
Step 6 · sim → reality

Live adjustments

Simulated configurations are usually tuned on a zero-fee, instant-fill model. Three realities have to be folded in before live capital, and they mostly tighten the gate.

Fees tighten C, but only for takers

In plain termsFees only hit you when you take an order already resting on the book, not when you post your own. So a patient, maker-style bot can pay nothing.

Fees are taker-only. Resting limit (maker) orders fill free, so a maker bot keeps C_effective = C. Takers pay fee = shares · feeRate · p(1−p), largest near 50¢ and smaller toward the wings. Worst case per pair runs ≈0.015 (sports) to ≈0.035 (crypto), so a taker C=0.99 drops to ~0.95 effective on crypto. Run C_effective = C − fee/pair in taker mode.

Latency

In plain termsBy the time your order reaches the exchange, the cheap price you saw may already be taken. Quote from the live book and cap the price you will accept, so you never chase a fill.

Use the WS book and marketable limits (an order that fills now, but with a price ceiling) with a small buffer. Sports has a multi-second taker delay. Patience, not speed.

Fills & partials

In plain termsYou rarely get your whole order at once. Often only part fills (a partial), so base every decision on what you actually got, not what you asked for.

Model fills against real book depth and re-evaluate on the actual filled quantity. The imbalance cap is enforced on realized shares.

7
Step 7 · the dial

Ten example configurations

Every configuration runs the exact same engine and differs only in seven tunable parameters (a setting you can dial up or down). To compare them fairly, each was run through one shared test: the same 20 synthetic markets the demo above draws from, a mix of oscillating, choppy, drifting, and blowout games. The numbers in each row are that test's output. They rank the configurations against one another and are not a forecast of live dollars. Press Run in demo on any row to watch that exact configuration trade a market.

Reward and risk grow together

Each row is one configuration, sorted from the smallest 20-game total at the top to the largest at the bottom. The green bar is its reward (total profit across the test), and the amber bar is its risk (the loss in its single worst game). Read top to bottom and watch both bars lengthen together. That is the whole lesson of this section: you cannot stretch the green bar without also stretching the amber one. Pick the row whose balance of the two you are comfortable with.
8
Step 8 · earning trust

The validation ladder

One engine, three data sources. The dollar figures above are only believed once rebuilt on real recorded books, then proven live in graduated, gated steps.

Stage A · Deterministic replay

Deterministic replay means feeding the same recorded data through the bot and getting the exact same result every time. Replay real order books (the live lists of buy and sell offers) into the same engine. This is the gold standard. Rebuild the configuration table with these real-data numbers.

Stage B · Shadow / paper

Shadow, or paper, trading runs on the live feed but only pretends to place orders, so no real money moves. It catches feed-handling, reconnection, clock, and rate-limit bugs that a replay cannot.

Stage C · Canary live

A canary is a tiny live test that warns you of trouble before you scale up. Trade just 1 to 2 markets in 5 to 10 share clips, compare your paper fills to your actual fills, and tune until paper is about equal to live.

Stage D · Graduated scale-up

Grow your size slowly, and only after Stages A through C agree with each other. Scale by no more than 2x per step, re-checking every gate as you go.

A go / no-go gate is a pass-or-fail check the bot must clear before you let it trade bigger. If any gate fails, you stop and fix it instead of scaling up.
Go / no-go gateThreshold
Realized combined VWAP your real average price paid≤ C on ≥90%
Fill ratio share of orders that filled≥ 60%
Slippage vs quote expected price vs price you gotin band ≥90%
Max imbalance how lopsided the two legs gotnever > imb
Capital cap most money at risk at once≤ budget × hard
Rejects / heartbeat failed orders, health ping0 / session
Single-market loss worst loss on any one market≤ modeled worst
9
Step 9 · the order of work

Build phases

A sound build sequences the work. Engine and harness first, so the same code runs in all three modes. Execution, risk, and scale follow. Maker mode is usually a later, separately validated track.

PHASE 0
Engine + harness

Build the core engine and a runner with all three modes, then get every unit test passing.

PHASE 1
Recorder + replay

Record 30 to 100 real markets and rebuild the configuration table on that real data.

PHASE 2
Execution + risk

Add the V2 trading client, a rate limiter, a heartbeat health check, and the Merge and Redeem operations.

PHASE 3
Shadow

Run on the live feed with pretend fills, to prove the bot behaves identically to replay.

PHASE 4
Canary

Trade tiny real size and confirm the bot passes every go/no-go gate.

PHASE 5
Scale

Grow size gradually, getting approval for each market category before expanding it.

PHASE 6
Maker + multi-leg

Optionally chase maker rebates and rewards, and hedge whole games across legs.

DONE
Per-category live

Sports behave differently from crypto, so approve each category on its own.

Field notes · grounding & honest caveats

How real bots do this, and where it gets hard

The logic above is clean. The market is not. This section grounds the strategy in what live bots actually do, and is honest about the failure modes, so you read the rest with the right expectations. In practice these bots sort into two archetypes, two distinct playbooks for earning the same spread: one crosses the spread actively, the other sits back and gets paid to wait.

Archetype 1 · temporal pair-cost accumulation

The approach this guide focuses on, run by bots like gabagool, Bonereaper, and the RN1 sports bot. As a taker (someone who takes an existing order off the book, paying for speed), cross the spread the instant the pair-cost math permits, accumulating each side on its own dips. The profit driver is the spread captured across time, hence temporal. One documented gabagool BTC cycle: ~1,267 YES at avg $0.517 and ~1,295 NO at avg $0.449, a pair cost near $0.966, about $58 profit on ~$1,237 deployed in 15 minutes.

Archetype 2 · passive market making

What the open-source poly-maker does. Post resting limit orders just inside the book on both sides and earn the spread plus maker rebates (small payments for adding orders to the book) and liquidity rewards (extra payouts for keeping orders posted near the mid). The profit driver is rebate and reward income, not the spread. Fills are slower and probabilistic, but makers pay zero fees, so the economics are gentler. It is the natural next step beyond the taker approach.

Be honest about the odds. The simple "buy both sides under $1 right now" arbitrage is essentially gone: the average window shrank to roughly 2.7 seconds and is taken by sub-100ms bots. Most retail temporal-arb bots lose money. Even RN1, the famous "$1K into millions" wallet, showed a true win rate near 42% and large unrealized losses in a forensic review of ~27,000 trades. You cannot win a market that never reverts. The realistic goal is to harvest the markets that do oscillate and to cap the bleed on the ones that do not.
the full sports lifecycle

Six stages, start to settlement

① Game selection

Filter for oscillation, meaning prices that swing back and forth rather than drifting one way: competitive matchups, liquid books, an active reward pool. Avoid blowout-prone games, where one side runs away early and the price never comes back. This is the biggest determinant of survival, and the step most homegrown bots skip.

② Pre-game accumulation

As a maker, rest bids just below the mid on both sides and build a hedged base near 50/50 at close to cost, paid for by rewards and rebates.

③ Tip-off

All resting sports orders auto-cancel at game start. The base inventory carries over, and the bot flips into reactive, in-game, taker-leaning mode.

④ In-game

Apply the gate on every book update. The latency window, the brief lag before everyone sees the same news, is the opening: official feeds update seconds after an event while livestreams lag far longer, leaving stale orders to pick off.

⑤ Recycle

Merge the matched pairs, min(qA, qB) of them, back to pUSD any time before resolution and redeploy. The same dollars round-trip many times, which is why these bots show huge volume relative to their balance.

⑥ Endgame

Prices go extreme, the back-and-forth dies, and any remaining imbalance is a naked directional bet (an unhedged wager on one outcome). Accept small, cheap, capped one-sided inventory. Never force the second leg.

Operational reality. Serious multi-market bots run on WebSockets, not polling. Budget for rate limits (roughly 60 orders/min per key, 10 REST requests/sec, 15-order batches), a heartbeat every ~5s or open orders are cancelled, and a multi-second placement delay on marketable sports orders that structurally favors maker flow.
Try it on the live market

Run the bot on the live BTC 5-minute market, in real time

Press Watch live market and the page connects to the current Bitcoin 5-minute up/down market on Polymarket and starts polling its real order book every couple of seconds. The same gate, triggers, sizing, merge, and Trend Rider logic from the demo above runs as a paper bot on each live tick, and every trade it would make is plotted on the chart as it happens. Tune the seven dials or flip Trend Rider at any time and the bot instantly recomputes over the live ticks so far. This is read-only paper trading. No wallet is connected, no orders are placed, and nothing here is financial advice. Every dollar is hypothetical.

read-only A paper sandbox on a live market. It reads the public order book for the current BTC 5-minute market and runs the engine over it as the price ticks. Your keys, funds, and real orders are never involved. It stops on its own when the market resolves. Figures are illustrative, not a track record and not advice.
Current market Bitcoin Up or Down, 5-minute window. The live market rolls over every 5 minutes.
Press Watch live market to connect to the current BTC 5-minute up/down market and watch the paper bot trade it in real time.
Engine configuration
Edit any dial to override the preset. While the bot is live, a change instantly recomputes what it would have done over the ticks watched so far, then keeps going. C is the pair-cost ceiling, entry the price to open near, patience the wait before a rebalance, edge how far under your average a top-up must be, clip the base order size, budget the capital per market, and imb the cap on how lopsided the two sides may get.
No market loaded C 0.97 clip 30 budget $400 imb 300 paper · no orders placed
live Up / Down book · ○ bot buy · ◆ trend bet · | merge · line grows left to right over the 5-minute window
0 / 0
Shares A / B
n/a
Combined avg (≤ C wins)
$0
Hypothetical P&L
$0
Peak deployed
Hypothetical only. Prices are read live from Polymarket's public order book, the dollars are simulator outputs for relative comparison, and the engine here cannot place an order. Treat it as a teaching aid for the strategy's discipline, not as a signal or a forecast. Nothing on this page is financial advice.
An evergreen, interactive explainer of how two-sided accumulation arbitrage bots work on Polymarket: the core rule, the data feeds, capital recycling, risk controls, and the features the strategy can incorporate. Written about the strategy in general, not any single product.
All dollar figures are simulator outputs shown for relative comparison, and would need rebuilding on real-data replay before trusting them for live capital. Nothing here is financial advice.
Join Discord