How to Read a Polymarket Order Book (And Stop Overpaying)

The ask side shows the price and quantity that market participants are willing to sell. If the ask is sitting at 69 cents per YES share, that's the cheapest price any seller is currently offering. The bid side works in reverse: it shows the highest price a buyer will currently pay, which is the ceiling you'll receive if you're selling into the market.

These two numbers, the best ask and the best bid, define the spread. The spread is a cost you pay on every round trip. Tighter spreads mean cheaper trading. Wider spreads, common in thin markets, mean you give up more edge just getting in and out.

Here's a concrete example. The ask is 69 cents and there are 4,000 shares available at that level. That means you can deploy up to $2,760 (4,000 x $0.69) and every share fills at exactly 69 cents. The moment you try to spend $3,000, you've exceeded the available depth and your order starts consuming the next price level.

The number to watch is the total shares available at each level, not just the price. Price tells you the cost per share. Volume tells you how many shares you can buy before that price disappears.

Each price level in the ask side holds a fixed number of shares. Once those shares are exhausted, your order moves to the next level at a higher price. Your final average cost is the volume-weighted mean across every level touched.

In a liquid market, the effect is small. Buying $3,000 worth of shares when only $2,998 is available at 69 cents pushes your average fill to 70 cents. In a thin market, the same dynamic compounds fast. Buying into a market with ask levels stacked at 3.1, 3.2, 3.3, and beyond means sweeping through each level in sequence until your order is filled, landing you at an average cost of 3.4 even though the best ask was 3.1.

# Simulate fill across order book levels
def simulate_fill(ask_levels, target_spend):
    total_cost = 0
    total_shares = 0
    for price, available_shares in ask_levels:  # sorted ascending by price
        if total_cost >= target_spend:
            break
        spend_here = min(available_shares * price, target_spend - total_cost)
        shares_here = spend_here / price
        total_cost += spend_here
        total_shares += shares_here
    avg_fill = total_cost / total_shares if total_shares > 0 else None
    return avg_fill, total_shares, total_cost

In a liquid market, 4,000 shares might sit at a single price level (69 cents), meaning you can deploy up to $2,998 and your average fill stays at 69 cents. Cross that threshold by even a dollar and your average ticks up to 70 cents. That's a one-cent slippage on a liquid market.

In a thin market, the same dynamic is far more punishing. A $200 order might walk the book through price levels at 3.1, 3.2, 3.3, and beyond, landing you at an average fill of 3.4. That's a 9.7% slippage cost on a single order. Any edge your model identified at 3.1 is gone.

Market orders are fast and certain. You get filled immediately. The cost is that in thin markets you sweep through multiple price levels and your average fill is worse than the best ask. In liquid markets where depth is deep, the slippage is negligible and market orders are fine.

Limit orders are slower but precise. You name your price and the order sits in the book until the market reaches it. You might not get filled at all if the market never reaches your level. But when you do get filled, you pay exactly what you specified, no slippage.

• Use market orders when the book is deep enough that your full order size fits within one or two price levels.
• Use limit orders when the book is thin, when you want to enter at a specific price below the current ask, or when you want to exit at a specific profit target above your entry.
• Before sending a market order, run the fill simulation from Step 03. If projected slippage exceeds 1-2 cents (or whatever threshold your strategy requires), switch to a limit order instead.

If the current ask is 2.7 and you want to enter at 2.5, set the limit at 2.5. The order sits dormant in the book until the ask drops to that level, then fires automatically. You don't have to watch the screen. You don't have to time the entry. The order book handles it.

This also protects against slippage in thin markets. Rather than sweeping multiple price levels and landing at an average you didn't intend, the limit order guarantees you pay no more than your specified price. The trade-off is that if the market never drops to 2.5, you don't get filled. That's a feature, not a bug, if 2.5 is the price where the trade makes sense.

The mechanics are straightforward. Buy shares at your entry price, then immediately submit a sell limit order at your target exit. If you want a 20-30% premium, calculate that price explicitly: buy at 0.50, set the sell limit at 0.60 to 0.65. The order sits in the book until the market reaches your price. If it does, you fill at exactly that level. If it doesn't, you still hold the position.

There's no slippage risk on the exit because you're the one setting the terms. You're the seller in the order book, not the buyer sweeping through levels. The only risk is that the market never reaches your target, in which case you need a separate rule for how long to hold or when to cut the position.

# After buy fill is confirmed
def place_exit_limit(entry_price, shares_filled, target_premium=0.20):
    exit_price = round(entry_price * (1 + target_premium), 4)
    order = {
        'side': 'sell',
        'type': 'limit',
        'price': exit_price,
        'size': shares_filled
    }
    return submit_order(order)  # submit via Polymarket API

Reading the totals and share counts before you submit tells you the maximum position size you can take without overpaying. If you want to buy 4,000 shares at 69 cents and there are exactly 4,000 shares offered at that level, your average fill is 69 cents and your total outlay is $2,760. Exceed that depth by even a dollar and your average cost ticks up.

In a thin market, slippage compounds fast. Buying into a market with only small clips available at each level can drag your average price from 3.1 to 3.2 to 3.3 and beyond, landing you at a blended cost of 3.4 when you expected 3.1. That's a 9.7% cost you didn't budget for.

observed Liquidity on thin markets shifts quickly. A book that showed 500 shares at the best ask when your bot started its cycle may show 50 shares by the time the order is submitted. Run the pre-trade check immediately before order submission, not at the start of the decision cycle.

# Pre-trade check: run immediately before every order submission
def pre_trade_check(ask_levels, target_spend, max_slippage_pct=0.02):
    best_ask = ask_levels[0][0]
    avg_fill, shares, cost = simulate_fill(ask_levels, target_spend)
    slippage = (avg_fill - best_ask) / best_ask
    if slippage > max_slippage_pct:
        return {'action': 'skip_or_reduce', 'projected_avg': avg_fill, 'slippage': slippage}
    return {'action': 'proceed', 'projected_avg': avg_fill, 'slippage': slippage}