How I Built a Market Maker Bot on Polymarket (And What I Learned)

I've been trading on Polymarket for a while now, and at some point I got tired of manually placing orders. So I did what any developer would do - I automated it.

This post is about how I built a simple market maker bot on Polymarket, what went wrong, and what actually works.

What is Market Making Anyway?

Market making is simple. You place a buy order and a sell order at the same time. You buy at $0.45 and sell at $0.55. If both orders fill, you pocket the difference - the spread.

You're not betting on the outcome. You're just providing liquidity and collecting the spread over and over again.

On Polymarket, every market is a YES/NO token. So instead of price, you're working with probabilities. A YES token at 0.45 means the market thinks there's a 45% chance of YES.

Why Polymarket is Good for Market Making

A few reasons I chose Polymarket. They have a real order book (CLOB - Central Limit Order Book). You can place limit orders via API. Markets are liquid enough to actually get fills. The API is well documented and free to use.

Most prediction markets don't have a proper order book. Polymarket does. That's what makes bot trading possible.

How My Bot Works

It's not complicated. Here's the basic logic. Fetch the current best bid and ask from the order book. Place a buy order slightly below the best bid. Place a sell order slightly above the best ask. Wait for fills. Cancel and repost when the market moves.

That's it. The hard part is not the logic - it's the edge cases. Orders not filling. Markets resolving while you hold inventory. Gas fees eating your profit.

The Stack I Used

Node.js for the bot logic. Polymarket CLOB Client which is the official npm package. MongoDB to log all trades and track P&L. A VPS to keep the bot running 24/7. PM2 to auto-restart if it crashes.

Nothing fancy. You don't need a complex setup to get started.

Biggest Mistakes I Made

First, not cancelling orders fast enough. When the market moves, your old orders become bad orders. I learned to cancel aggressively and repost.

Second, ignoring inventory risk. If your buy orders keep filling but sell orders don't - you're stuck holding a position. That's not market making anymore, that's just buying.

Third, trading illiquid markets. Some markets on Polymarket have almost no volume. Your orders sit there forever and you get no fills. Stick to high volume markets.

Fourth, not logging everything. At first I had no idea if I was making or losing money. Log every order, every fill, every cancel. MongoDB made this easy for me.

Does It Actually Make Money?

Honestly - it depends on the market. Some days are green, some are flat. The edge is small and you need volume to make it worthwhile.

What I can say is that on active markets during big events - elections, sports, major news - the spreads widen and the bot performs well. That's when volume spikes and there are more opportunities.

What's Next

I'm working on better spread calculation based on volatility, auto market selection so the bot picks the best markets, and risk limits so it doesn't overexpose on one market.

If you're a developer and want to try this yourself, start with the official Polymarket CLOB API docs and the polymarket-clob-client npm package. It's easier to get started than you think.

Final Thoughts

Market making on prediction markets is still early. Not many people are doing it properly. If you're a developer, you have an edge just by being able to build the tools yourself.

Start simple. Get one market working. Then scale.

If you have questions or want to share what you're building, drop a comment below.
For more info about arbitrage in detail: https://github.com/casatrick/polymarket-arbitrage-bot

Comments

Post a Comment

Popular posts from this blog

How a Polymarket Arbitrage Bot Actually Works: 5 Strategies Explained

A Polymarket arbitrage bot scans prediction markets for pricing inefficiencies and executes trades to capture the resulting spread. That's the concept in one sentence, but arbitrage on Polymarket isn't one strategy, it's several distinct mechanisms, each exploiting a different kind of mispricing. Here's a breakdown of how each one works, based on an open-source implementation. Intra-market arbitrage is the core mechanic. In a binary Polymarket market, YES and NO token prices should always sum to $1.00. When combined pricing falls below that after fees, buying both outcomes locks in a profit that doesn't depend on which outcome actually happens. Buy YES and NO, merge the tokens into a complete set, redeem for $1.00 per share. This is the closest thing to genuinely risk-free arbitrage available in prediction markets. Combinatorial arbitrage extends the same logic to multi-outcome markets, like price-range or bracket-style markets with three or more possible outcomes...
Read more

Why Every Polymarket Trading Bot Needs to Adapt to TWAP

When building a Polymarket trading bot, it's easy to focus on prediction models, latency, and order execution. However, platform infrastructure changes can have an even greater impact on a trading system than a new strategy. With Polymarket introducing TWAP (Time-Weighted Average Price) settlement for crypto Up/Down markets, I spent the last few days reviewing how my bot behaves near market resolution. Supporting TWAP wasn't simply replacing one price calculation-it required rethinking assumptions around settlement, execution timing, and trade evaluation. This update reminded me that trading bots aren't static software. They're living systems that must evolve alongside the markets they interact with. Over the coming weeks, I'll share a detailed technical breakdown covering the architecture changes, implementation decisions, and lessons learned while updating my Polymarket trading bot for the new TWAP model.
Read more

Building a Polymarket Trading Bot: Order Book Monitoring, Slippage Handling, and Position Sizing

  Most first-attempt Polymarket bots place a market order and call it done. That works fine on liquid, high-volume markets, but Polymarket has thousands of long-tail markets with thin order books and wide bid-ask spreads, where a naive market order can fill at a price far from the quote seen just a moment earlier. Polymarket's API is split into two services. The Gamma API handles public, read-only market discovery. The CLOB API handles order books, prices, and actual trading. Reading market data requires no authentication, while placing orders does. A solid bot workflow starts by discovering a market and pulling its order book, then calculating edge by comparing a model's estimated probability against the market's implied probability. Position sizing should use a fractional-Kelly approach, capped by a hard maximum exposure per market, since that cap matters more for risk control than the Kelly fraction itself. Before filling an order, checking remaining order book depth ...
Read more