Polymarket Tick Size

#Definition

Polymarket tick size is the minimum price increment at which traders can place orders on the platform's order book. On Polymarket, the standard tick size is $0.01 (one cent), which dynamically adjusts to$0.001 (one-tenth of a cent) when prices exceed $0.96 or fall below$0.04.

This variable tick system allows for appropriate price precision across the full probability spectrum. Each Polymarket share pays out $1.00 in [USDC](/wiki/usdc-usd-coin) if the predicted event occurs and$0.00 if it does not; meaning a share trading at $0.50 reflects roughly a 50% implied probability. The tick size defines the resolution at which these probability-based prices can move.

#Why It Matters in Prediction Markets

Tick size fundamentally shapes how efficiently a prediction market can discover and express probabilities. At a price of $0.50, a one-cent tick represents only 2$0.98, that same one-cent tick represents 50% of the remaining potential profit: the difference between $0.98 and$1.00.

This asymmetry creates pricing inefficiencies at extreme probabilities. Without finer tick sizes near the boundaries, traders cannot distinguish between a 98.0% and 98.5% probability, even when that distinction carries meaningful information about an impending event resolution. The minimum tick also establishes the floor for the bid-ask spread: no matter how liquid a market becomes, the spread cannot be tighter than one tick.

Polymarket's dynamic tick adjustment addresses boundary friction by automatically increasing precision when it matters most. The mechanism improves liquidity at price extremes by allowing market makers to quote tighter spreads, reducing trading costs for participants taking positions on near-certain or near-impossible outcomes.

#How It Works

Polymarket operates a Central Limit Order Book (CLOB) where users place buy and sell orders for outcome shares priced between $0.00 and$1.00. The tick size is set per market and dictates which prices orders can be posted at. The system enforces tick size constraints through validation; orders at non-conforming prices are rejected before reaching the matching engine.

1. Standard pricing range ($0.04–$0.96): Orders must be placed at prices divisible by $0.01. Valid prices include$0.45, $0.46, and$0.47. Invalid prices such as $0.455 or$0.4532 will be rejected.

2. Extreme pricing range (below $0.04 or above$0.96): The tick size automatically switches to $0.001. Valid prices include$0.971, $0.972, and$0.973. This allows orders to be placed in 0.1% probability increments instead of 1%.

3. Tick size queries: Traders can retrieve the current tick size for any market via the API. The platform also broadcasts tick_size_change events via WebSocket when a market transitions between tick regimes.

4. Complementary pricing: When Yes shares trade at $0.99 with a 0.001 tick, No shares will be around$0.01 and can also move in 0.001 steps. Both sides maintain price steps that keep the two outcomes' prices summing to approximately $1.00.

#Visualizing Dynamic Tick Size

The following chart illustrates how the tick size changes based on the price level:

#Comparison: Polymarket vs. Kalshi

While both platforms use a standard 1-cent tick, their handling of extreme probabilities differs significantly:

Polymarket's dynamic approach allows for more precise pricing when outcomes are near-certain or near-impossible, whereas Kalshi maintains a uniform grid throughout.

#Developer Guide: Rounding Prices

When using the API, you must round prices to the correct tick size to avoid order rejection. Here is a helper function to handle this:

/**
 * Rounds a price to the valid Polymarket tick size.
 * @param {number} price - The desired price (0.00 to 1.00)
 * @returns {number} - The price rounded to the nearest valid tick
 */
function roundToValidTick(price) {
  // Determine tick size based on price level
  let tickSize = 0.01;
  if (price < 0.04 || price > 0.96) {
    tickSize = 0.001;
  }

  // Round to the nearest tick
  // Using Math.round(price / tick) * tick can have floating point errors
  // So we scale to integers first
  const scale = 1 / tickSize;
  return Math.round(price * scale) / scale;
}

// Examples
console.log(roundToValidTick(0.505)); // -> 0.51 (Standard range rounds to 0.01)
console.log(roundToValidTick(0.9712)); // -> 0.971 (Extreme range rounds to 0.001)

#Risks and Common Mistakes

Placing off-tick orders: A common mistake is attempting to place a limit order at a price that doesn't align with the tick size. Polymarket will reject such orders immediately. Traders who calculate desired entry points must remember to round to the nearest valid increment.

Stale tick size caching: Algorithmic traders who cache tick sizes locally may submit invalid orders after a market transitions between tick regimes. Always verify the current tick size before placing orders, especially in fast-moving markets where prices cross the $0.96 or$0.04 thresholds.

Precision errors in order calculations: Computing order prices programmatically can introduce floating-point errors. A calculated price of $0.469999999 will be rejected. Use integer math or decimal libraries to ensure proper rounding to tick-valid prices.

Liquidity fragmentation: When tick size becomes very fine ($0.001), liquidity spreads out across ten times as many price levels. This can make the order book look "thin" at any single price point. A large market order might sweep through multiple levels, causing more slippage than expected compared to a standard 1-cent tick market where volume is concentrated.

Chasing negligible profits: Some traders see an outcome at 99% and think they can earn virtually risk-free gains by buying at $0.99 or even$0.999. This creates a heavily skewed risk/reward profile: risking $0.999 to potentially earn$0.001 per share. If the unlikely outcome occurs, nearly all capital is lost. The last few basis points of probability are often not worth chasing.

#Practical Tips for Traders

• Check the tick size before placing orders. Use the API or check the order book display to confirm the active tick size, especially for markets trading near the $0.04 or$0.96 boundaries.

• Round prices explicitly in code. When building trading algorithms, apply explicit rounding to the nearest valid tick. A utility function that scales to integer space, rounds, then scales back ensures orders comply with CLOB validation.

• Monitor tick size change events. Subscribe to WebSocket updates for markets where you hold positions. Tick transitions can create brief opportunities or invalidate pending orders. Active market makers should cancel and re-submit quotes on the new price grid when tick size changes.

• Factor tick size into spread analysis. A one-cent spread in a $0.01 tick market is tight; a one-cent spread in a$0.001 tick market (at price extremes) is relatively wide: 10 ticks instead of one.

• Use limit orders near transitions. When prices approach $0.96 or$0.04, consider placing limit orders rather than market orders to maintain control over execution price during potential tick regime changes.

• Don't overcommit for tiny percentage gains. While Polymarket enables fine adjustments at extreme prices, evaluate whether fighting over the last 0.1% edge is worthwhile given the skewed risk/reward and potential fees.

• Compare platforms carefully. When evaluating odds across platforms like Kalshi, factor in tick size differences. Polymarket might show a contract at 50.2% while another platform displays 50% due to tick resolution. Small apparent discrepancies may reflect tick constraints rather than true arbitrage opportunities.

#Related Terms

• Polymarket
• Tick Size
• Kalshi Tick Size
• Prediction Market
• Binary Market
• Order Book
• Liquidity
• Slippage
• Arbitrage

#FAQ

#What is the tick size on Polymarket?

The tick size on Polymarket is the minimum price increment allowed when trading shares. In most markets, the tick size is $0.01, meaning prices move in one-cent (1$0.001 (one-tenth of a cent, or 0.1% probability) when an outcome's price exceeds $0.96 or falls below$0.04. This dynamic mechanism enables more precise pricing as events approach certainty.

#Does Polymarket's tick size change during a market?

Yes. Polymarket's tick size can change during the life of a market if the odds become very one-sided. It starts at $0.01 increments for normal trading and shifts to$0.001 increments once the price crosses the 0.96 or 0.04 threshold. This change happens automatically and affects all new orders. The platform broadcasts tick size change notifications via its API and WebSocket feeds to alert connected traders.

#Is a smaller tick size always better for traders?

Not necessarily. While smaller ticks allow for more precise pricing and potentially tighter spreads, they can also fragment liquidity across many price levels. For small orders, tighter spreads are beneficial. For large orders, reduced depth at each price level may increase market impact costs as the order sweeps through multiple ticks. Polymarket's dynamic approach attempts to balance these trade-offs by applying finer ticks only where price precision is most valuable.

#What is the minimum trade size on Polymarket?

Polymarket allows very small trades with a minimum order size of 0.001 shares (one-thousandth of a full share). Since a full share pays $1.00 if it wins, 0.001 shares represent a potential$0.001 payout. This granularity is useful for experimentation and learning the platform, though extremely small trades are not practical for profit given the minimal returns involved.