Polymarket Arbitrage Bots: How They Work and What They Actually Earn.

01What sum-to-one means.

Arbitrage on Polymarket is the trade where YES + NO costs less than $1.00. Every binary market resolves to exactly one of YES at $1.00 or NO at $1.00. So if at some instant you can buy YES at $0.49 and NO at $0.49 on the same market, you've spent $0.98 to be guaranteed $1.00 - a 2¢ riskless profit (before fees). Technically: this is called sum-to-one arbitrage, and it's a direct consequence of how Polymarket's Conditional Token Framework prices complementary outcomes.

The price discrepancy happens because YES and NO are quoted as separate orderbooks. Different traders, different reasons, different time horizons. When a large seller hits the NO book without a matching buyer on the YES side, the two prices drift apart - and momentarily, the sum is < $1.00. The bot's job is to be there in that moment.

The bot doesn't predict outcomes. It exploits a momentary mis-quote between two orderbooks that must sum to one dollar by resolution.

02The 2¢ economics - and why they're harder than they look.

2¢ on $0.98 is roughly 2.04% gross return per cycle. If a bot can do this five times a day across thirty markets, the headline math is impressive - easily 10-15% monthly return. The bar napkin draws itself.

Then reality arrives. Each side of the trade pays a maker/taker fee. Polygon gas costs ~$0.001-$0.005 per leg. Slippage between the moment you see the quote and the moment your order lands eats another 5-20bps. And the depth of the orderbook at the arb price is usually tiny - you might be able to fill $200 of size at $0.98 but not $20,000.

Here's what 2.04% gross typically becomes:

• Fees: ~30bps per round trip (two legs, maker discount when available)
• Gas: 5-25bps depending on Polygon congestion and order count
• Slippage: 5-60bps depending on book depth and your latency budget
• Failed legs: the cost of getting filled on one side while the other side vanishes - and now you're holding directional risk you didn't sign up for

Net realized return per opportunity, in our running production data: 0.4% to 1.1%. Still good - but at $200 size, that's $0.80 to $2.20 per fire. You need volume and reliability, not heroics.

03What the stack actually looks like.

An arbitrage bot lives or dies on three things: how fast it sees the mis-quote, how reliably it fires both legs, and how cleanly it handles the case where only one leg fills. The architecture below is the one we ship for almost every client at this scale.

async def arb_loop(client, markets, min_edge=0.012):
    while True:
        # 1. Read books in parallel
        books = await asyncio.gather(*[
            client.get_orderbook(m.yes_token, m.no_token)
            for m in markets
        ])

        for mkt, (yes, no) in zip(markets, books):
            edge = 1.0 − (yes.best_ask + no.best_ask)
            if edge < min_edge: continue

            size = min(yes.best_ask_size, no.best_ask_size,
                       risk.max_size(mkt))

            # 2. Fire both legs simultaneously, atomic-ish
            yes_order, no_order = await asyncio.gather(
                client.place_limit(mkt.yes_token, yes.best_ask, size),
                client.place_limit(mkt.no_token,  no.best_ask,  size),
            )

            # 3. Reconcile - if only one filled, unwind at market
            await reconciler.resolve(yes_order, no_order)

Three details that aren't obvious from the snippet but matter under load:

• The get_orderbook call is rate-limited to 100 requests per minute on Polymarket's public endpoint. If you're watching 50 markets, you can't poll each every second - you batch via the multi-market endpoint or you use the WebSocket subscription.
• The "atomic-ish" gather is a lie. Both orders go out near-simultaneously, but they are two separate transactions, on two separate orderbooks. Roughly 3-7% of the time only one leg fills, and you now need an unwind path.
• The reconciler is the part most DIY bots get wrong. Naive "market sell the orphan leg" works in calm markets and bankrupts you in volatile ones.

04Why the edge decays - and what that means for you.

This is the part of the conversation most agencies skip, so we'll lead with it. Sum-to-one opportunities > 2% have been declining steadily on Polymarket since mid-2024. The reason isn't mysterious: every new bot operator narrows the gap. Whatever edge you find at launch will be smaller in three months, and smaller again in six.

Looking at our internal data on the BTC and politics market clusters, 2¢-or-better opportunities went from ~480 per week in Q3 2024 to ~120 per week in Q1 2026. The drop is more visible on high-volume markets and less visible on long-tail markets - which is precisely where the depth is also shallowest.

The honest framing: a pure sum-to-one arb bot is a viable strategy in 2026, but it has a half-life. Most operators we ship for treat it as one component of a portfolio - combined with copy trading, market making, or directional event bets - rather than the whole bankroll.

05What you should realistically expect.

If you wire $50k into a single-strategy arbitrage bot today and ask us what to expect, our honest answer:

• Best case: 6-11% net annualized return, scaling slowly with bankroll up to maybe $250k. Beyond that, book depth caps you out.
• Median case: 3-6% net annualized - enough to pay for the bot inside 12-18 months if the spec was $15k-$25k.
• Bad case: A reconciler bug, a Polymarket API change you didn't catch, or a structural decay in opportunity count drops you to roughly break-even net of fees and gas.

Anyone telling you 10% monthly is selling you something. Frequently, themselves.

06Build it yourself, or hire us?

If you can write async Python, manage your own Polygon RPC, and have time to babysit the bot through three or four API revisions a year - you can build this yourself. There are public repos that get you 60% of the way. The remaining 40%, which is monitoring + reconciler + rate-limit choreography + the boring operations work, is the part that decides whether you stay break-even or net-positive.

If you'd rather hand someone a spec and get a tested, documented bot back in six weeks, that's exactly what we do. Either way, the most important advice we have is: start small, run paper for two weeks before live, and don't let the bot trade size your bankroll can't survive a bad day on.