Polymarket Market Making Guide: $200-800/Day Returns

Market makers on Polymarket earned an estimated $20+ million in 2024. One trader scaled from $200/day to $700-800/day on just $10K capital. This guide covers how market making works, the liquidity rewards program, and how to build your own automated market maker.

How Market Making Works on Polymarket

Unlike traditional AMMs where you deposit into pools, Polymarket uses a Central Limit Order Book (CLOB). Market makers profit by:

1. Spread capture: Place buy orders below mid-price, sell orders above
2. Liquidity rewards: Platform incentives for maintaining tight spreads
3. Holding rewards: 4% annualized on positions in eligible markets

The CLOB Architecture

• Off-chain matching with on-chain settlement (Polygon)
• EIP712-signed orders for cryptographic verification
• Atomic swaps between outcome tokens (YES/NO) and USDC
• Zero trading fees on international platform

Profitability Data

Case Study: @defiance_cr

Expected Returns

Rule of thumb: Expect ~0.2% of trading volume in profit. $1M monthly volume ≈ $2,000 profit per market.

Liquidity Rewards Program

Polymarket pays incentives to liquidity providers. Rewards scale by:

• Liquidity amount: More capital = more rewards
• Distance to mid-price: Closer orders earn more
• Two-sided depth: Both YES/NO orders get 3x boost
• Time in market: Longer duration = more rewards

How to Qualify

1. Place resting limit orders on the order book
2. Maintain orders near market mid-price
3. Provide two-sided liquidity (YES and NO)
4. Rewards distribute automatically at midnight UTC

Holding Rewards (4% APY)

Select markets offer 4% annualized holding rewards:

• 2028 US presidential election
• 2026 midterm elections
• International leadership markets
• Paid daily based on hourly position sampling

See What Whales Are Trading Right Now

Get instant alerts when top traders make moves. Track P&L, win rates, and copy winning strategies.

Free forever. No credit card required.

Spread Strategies

Bands Strategy

The official poly-market-maker uses a bands approach:

# Example bands.json config
{
  "buyBands": [
    {
      "minMargin": 0.005,   # 0.5% minimum offset
      "avgMargin": 0.01,    # 1% average offset
      "maxMargin": 0.02,    # 2% maximum offset
      "minAmount": 20,
      "avgAmount": 30,
      "maxAmount": 40
    }
  ],
  "sellBands": [
    {
      "minMargin": 0.005,
      "avgMargin": 0.01,
      "maxMargin": 0.02,
      "minAmount": 20,
      "avgAmount": 30,
      "maxAmount": 40
    }
  ]
}

At $0.50 mid-price with 1% avgMargin: buy at $0.495, sell at $0.505.

Spread Sizing by Market Type

Building a Market Making Bot

Architecture

# Market Making Bot Components

1. Data Collection
   - Pull historical prices (3h, 24h, 7d, 30d)
   - Calculate volatility metrics
   - Estimate rewards per market
   - Rank by risk-adjusted return

2. Trading Execution
   - Place orders based on bands config
   - Dynamic spread adjustment
   - Continuous order monitoring
   - Rebalance every 30-60 seconds

3. Position Management
   - Real-time position tracking
   - Position merging (YES+NO → free capital)
   - Inventory skew management

4. Risk Control
   - Per-market position limits
   - Total portfolio exposure caps
   - Stop-loss protection

Basic Implementation

from py_clob_client.client import ClobClient
from py_clob_client.clob_types import OrderArgs, OrderType
from py_clob_client.order_builder.constants import BUY, SELL

HOST = "https://clob.polymarket.com"
CHAIN_ID = 137

client = ClobClient(
    HOST,
    key="YOUR_PRIVATE_KEY",
    chain_id=CHAIN_ID,
    signature_type=1,
    funder="YOUR_FUNDER_ADDRESS"
)
client.set_api_creds(client.create_or_derive_api_creds())

def place_two_sided_orders(token_id, mid_price, spread=0.01, size=100):
    """Place buy and sell orders around mid-price."""

    # Buy order (below mid)
    buy_price = mid_price * (1 - spread)
    buy_order = OrderArgs(
        token_id=token_id,
        price=buy_price,
        size=size,
        side=BUY
    )
    buy_signed = client.create_order(buy_order)
    client.post_order(buy_signed, OrderType.GTC)

    # Sell order (above mid)
    sell_price = mid_price * (1 + spread)
    sell_order = OrderArgs(
        token_id=token_id,
        price=sell_price,
        size=size,
        side=SELL
    )
    sell_signed = client.create_order(sell_order)
    client.post_order(sell_signed, OrderType.GTC)

Rebalancing Loop

import time

def market_making_loop(token_id, spread=0.01, size=100):
    """Main market making loop - rebalance every 30s."""

    while True:
        # 1. Get current midpoint
        mid = client.get_midpoint(token_id)

        # 2. Cancel existing orders
        client.cancel_market_orders(token_id)

        # 3. Place new two-sided orders
        place_two_sided_orders(token_id, mid, spread, size)

        # 4. Log current positions
        positions = client.get_positions()
        print(f"Mid: {mid}, Positions: {positions}")

        # 5. Wait before next cycle
        time.sleep(30)

Inventory Management

Position Merging

When you hold both YES and NO tokens, merge them to free up capital:

# If you hold 100 YES + 100 NO = $100 locked
# Merge them to get $100 USDC back

# Built on Polymarket's poly_merger module
# On-chain execution to consolidate positions

Quote Skewing

• Long inventory: Widen ask spread to slow buying, tighten bid to attract sells
• Short inventory: Tighten ask to attract buys, widen bid to slow selling
• Goal: Return to neutral inventory position

Best Markets for MM

Ideal Characteristics

• Low volatility: Minimal price fluctuation risk
• High rewards: Disproportionate LP incentives
• Upcoming settlement: Preferably within hours/days
• Price stability: Trading near extremes (>0.997 or <0.003)

"Polymarket's reward system isn't perfectly calibrated to risk. Some markets barely move but offer huge rewards relative to their volatility. Finding these gems is where the profit lies."
— @defiance_cr

Risks

Adverse Selection

Informed traders with better information will trade against you systematically:

• Insider information cases documented (e.g., AlphaRaccoon)
• Domain experts exploit less-informed LPs
• Mitigation: Avoid markets with high insider potential, use wider spreads

Black Swan Events

• Max 1/10 portfolio per market
• Focus on near-settlement markets (hours away)
• Only >0.997 positions to minimize downside

Competition

• Jump Trading and other pros now active
• Polymarket building in-house trading team
• Spreads tightening as more MMs compete
• Only 3-4 serious automated providers in 2024

Infrastructure Requirements

Open Source Tools

• Polymarket/poly-market-maker: Official keeper with bands strategy
• warproxxx/poly-maker: Google Sheets config integration
• elielieli909/polymarket-marketmaking: Bands implementation
• miladhist/polymarket-market-maker: Advanced bot with risk controls

Getting Started Checklist

1. Set up py-clob-client with authenticated trading
2. Fund Polygon wallet with USDC
3. Clone poly-market-maker repo as starting point
4. Configure bands for 1-3 low-volatility markets
5. Run on VPS with monitoring
6. Start with $5,000-10,000 capital
7. Scale up as you validate profitability