Build a Polymarket Market Snapshot Before You Build a Trading Bot

A small Python tool can tell you more about a market than a simple price feed ever will.

A lot of Polymarket bot projects start with something like this:

if price < 0.40:
buy()

Technically, that is a bot.

It is also not much of a trading system.

The problem is not the "if" statement. The problem is everything it doesn't know.

What market is this?

How much liquidity is available?

What is the spread?

How has the price moved?

When does the market resolve?

Is the market even worth considering?

Before automating orders, build something that can answer those questions.

The idea: create a market snapshot

Polymarket currently exposes several public data sources. Gamma provides market and event metadata, while the CLOB provides order-book and pricing data. Polymarket's own developer material recommends using these sources for market-data workflows.

We can combine them into one simple Python object.

The goal is not to trade.

The goal is to turn this:

Market ID
Price

into something closer to:

Question
Outcome
Price
Liquidity
Volume
Best bid
Best ask
Spread
End date

That is a much better foundation.

Step 1: Find an active market

Start with Gamma.

import requests

url = "https://gamma-api.polymarket.com/markets"

params = {
"active": "true",
"closed": "false",
"limit": 20
}

response = requests.get(url, params=params)
response.raise_for_status()

markets = response.json()

for market in markets[:5]:
print(market["question"])

Gamma's market endpoint exposes fields such as the question, liquidity, volume, active status, end date, outcomes and CLOB token IDs.

Now you have a list of markets.

But you still don't know much about the actual trading conditions.

Step 2: Get the YES token

Polymarket markets expose CLOB token IDs that connect the market metadata to the order book.

import json

market = markets[0]

token_ids = market["clobTokenIds"]

if isinstance(token_ids, str):
token_ids = json.loads(token_ids)

yes_token = token_ids[0]

print("YES token:", yes_token)

This token ID is what we'll use to query the CLOB.

Step 3: Read the order book

Now we can inspect the actual market.

book_url = "https://clob.polymarket.com/book"

response = requests.get(
book_url,
params={"token_id": yes_token}
)

response.raise_for_status()

book = response.json()

print(book)

The CLOB exposes order-book data without authentication for read operations.

This is where the project becomes more interesting.

Instead of treating the displayed probability as the entire market, your program can inspect the available bids and asks.

For example:

bids = book.get("bids", [])
asks = book.get("asks", [])

best_bid = max(
float(order["price"]) for order in bids
) if bids else None

best_ask = min(
float(order["price"]) for order in asks
) if asks else None

print("Best bid:", best_bid)
print("Best ask:", best_ask)

Now your program knows something much more useful than a single price.

It knows what buyers and sellers are actually offering.

Step 4: Calculate the spread

Once you have the best bid and ask, calculate the difference.

if best_bid is not None and best_ask is not None:
spread = best_ask - best_bid

print("Spread:", round(spread, 4))

A market at 60¢ with a tiny spread is a very different environment from a market where buyers are at 55¢ and sellers are at 65¢.

Your bot should know that difference.

Step 5: Turn it into a snapshot

Now combine the information.

snapshot = {
"question": market["question"],
"liquidity": market.get("liquidity"),
"volume": market.get("volume"),
"end_date": market.get("endDate"),
"best_bid": best_bid,
"best_ask": best_ask,
"spread": spread if best_bid and best_ask else None
}

for key, value in snapshot.items():
print(f"{key}: {value}")

You have just created the beginning of a research layer.

No automated orders.

No private keys.

No complicated strategy.

Just better information.

Why build this first?

Because automation makes bad assumptions faster.

If your strategy says:

if price < 0.40:
buy()

the program doesn't know whether the market has enough liquidity.

It doesn't know whether the spread is wide.

It doesn't know whether the market resolves tomorrow or six months from now.

It doesn't know why the price is 40¢.

It simply sees a number and follows an instruction.

A useful trading system needs context before execution.

Where to take it next

Once the snapshot works, you can start adding actual research logic:

Active market
|
Liquidity filter
|
Price and spread
|
Order-book depth
|
Historical prices
|
Market rules
|
Strategy signal

The important part is that the strategy comes late.

You first build a reliable view of the market.

Then you decide what information is useful.

Only after that should you think seriously about automation.

Polymarket's current developer stack also provides historical price data through the CLOB, which means the same research layer can eventually compare current conditions with previous market behavior.

That is a much more interesting project than simply writing a bot that buys when a number crosses a threshold.

Your first Polymarket bot doesn't need to trade

It can observe.

It can collect.

It can compare.

It can tell you when a market deserves attention.

And after you understand what the data is actually telling you, you can decide whether automation makes sense.

Build the eyes before you build the hands.