BANGER
Product status: Banger’s public beta is paper-only. References to live execution are future-looking. Venue rules and legal claims can change; verify current primary sources for your jurisdiction.
2026-06-25 · 6 min read · facts as of 2026-06-25

Slippage and Liquidity in Prediction Markets: How to Read Depth and Size Without Moving the Book

The displayed price on a prediction market is the price of one share, maybe a handful. It is not the price of your order. If you send a market order for more contracts than sit at the top of the book, the rest fills at progressively worse levels, and the gap between the quote and your blended fill is slippage. On a thin contract that gap can swallow your entire edge before the event ever resolves.

This post is about reading depth, estimating slippage for a given size, and sizing into low-liquidity contracts without paying to move the market against yourself. It applies to both major venues, which matters because liquidity has become the deciding factor for active traders as volume scales.

Why prediction-market liquidity is structurally thin

Both Kalshi and Polymarket run a central limit order book, the same matching structure as the NYSE and Nasdaq. The difference is fragmentation.

On an exchange, Apple trades in one massive pool. A prediction market splits liquidity across thousands of separate questions. Every new contract is its own isolated order book with its own buyers and sellers, and every new book starts from zero. That is the core reason liquidity is one of the most important concepts in prediction markets.

Liquidity is also event-specific and time-dependent. Depth tends to concentrate around catalyst windows and round numbers, then evaporates after resolution. The same contract can be deep the day of a Fed decision and untradeable a week earlier.

Combined monthly trading volume on Kalshi and Polymarket rose from less than $5 billion in September 2025 to about $24 billion in April 2026, according to Pew Research Center's analysis of data from The Block. Note that the two platforms count volume differently: Kalshi uses face value per contract, while Polymarket uses taker notional, so the combined figure should be treated as directional rather than precisely comparable. Sports, politics, and crypto make up the overwhelming majority of activity on both platforms, leaving long-tail contracts genuinely thin.

Spread first: the cheapest liquidity signal

The spread is the gap between the highest bid and the lowest ask. It is the first and easiest indicator of liquidity, and it tells you the cost of the first share.

A practical rule: if the spread is wider than your expected edge, the trade probably is not worth it. If you think a contract is worth 60 cents, it is offered at 58, but the spread is 6 cents wide, your round-trip cost in and out can eat most of that 2-cent edge. As a rough threshold, spreads above 5 to 6 cents indicate thin liquidity where execution cost becomes a real factor in profitability. A wide spread also means the market's probability estimate is less precise than the displayed midpoint suggests.

Spreads are not constant. On Kalshi they can widen significantly during off-peak hours, overnight and weekends, when market makers pull quotes. Check the book at the moment you intend to trade, not when you opened the account. Liquidity snapshots are point-in-time.

Depth: estimating slippage for your actual size

The spread tells you the cost of the first share. Depth tells you the cost of all the shares you want. Depth is the quantity resting at each price level, and you have to walk the book to know your blended fill.

Consider an ask showing 55 cents, but only 50 shares sit there. The next 200 are at 57, the next 500 at 60. Buy 600 contracts as a market order and you do not pay 55. You pay a volume-weighted average that climbs as you consume each level. Working that out before you send the order is the whole game on thin contracts.

# Walk the ask side and compute the blended fill for a target size.
# asks: list of (price_cents, size) sorted best-first.

def blended_fill(asks, target):
    filled, cost = 0, 0.0
    for price, size in asks:
        take = min(size, target - filled)
        cost += take * price
        filled += take
        if filled >= target:
            break
    if filled < target:
        return None  # not enough depth for this size
    avg = cost / filled
    top = asks[0][0]
    slippage = avg - top
    return round(avg, 2), round(slippage, 2)

# Example book: 50 @ 55c, 200 @ 57c, 500 @ 60c
book = [(55, 50), (57, 200), (60, 500)]
print(blended_fill(book, 600))  # blended avg vs 55c top-of-book

If the function returns None, the book cannot fill your size without pushing past the levels shown. That is your signal to cut the order, not to send it and hope. Polymarket exposes an execution preview that shows the actual average price including slippage for your specific size before you confirm. Use it every time, and treat it as the ground truth over the headline quote.

Comparing across venues by your fill, not the quote

A contract at 55 cents on Kalshi and 55 cents on Polymarket is not the same price in practice. If one venue has 10,000 shares at 55 and the other has 100, the effective price for any real position size diverges immediately. When you compare venues, compare the price you would actually get for your intended size, not the displayed quote.

Liquidity also splits by category. Kalshi tends to lead on US sports and economic events; Polymarket tends to lead on global politics and crypto. Pick the venue where your specific contract is deep, not the one with the better brand-level reputation.

Sizing into thin markets without moving price

Once you can read depth, the tactics follow directly.

Test the execution logic before it touches real size

Slippage rules are easy to write and easy to get wrong under live conditions, when depth shifts between the quote you read and the order you send. The safe way to validate a sizing or order-routing rule is to run it against the live order book without committing capital.

That is the workflow Banger is built for. You write a strategy as Python, paper-trade it against the live book to see how your sizing and limit logic actually fill, then run it under a declarative risk envelope: per-trade cap, daily loss stop, max open positions, and a kill switch. Banger never custodies funds; you bring your own venue keys.

pip install bangertrades
banger run strategy.py --paper

Paper mode against the real book is where slippage assumptions get falsified cheaply. A sizing rule that looks clean against a static snapshot can behave very differently when the top level disappears just as your order arrives.

The short version

Read the spread to gauge cost and price precision. Walk the depth to compute your real blended fill before you commit. Compare venues by the fill you would get, not the quote. On thin contracts, rest limit orders, split size, wait out new markets, and treat slippage as a line item in your edge. The displayed price is an invitation, not a fill.

Liquidity and venue status move quickly here. Volume figures are as of April to May 2026 per Pew Research Center and The Block; re-check current depth on the contract you actually intend to trade before sizing in.

Sources

Keep reading

Run your first strategy free

Paper-trade on Polymarket and Kalshi market data without venue keys.

Start free