How to Choose a Polymarket Data API

If you are shopping for historical Polymarket data, you have already hit the wall that sends everyone here: Polymarket's own API serves current state only. Request the order book for a resolved market and you get a 404; request its price history and you get 200 with an empty array. The history is not gated behind a plan — it is gone.

So you need a provider that recorded the book while markets were running. The problem is that every provider in this space markets the same headline number, and it is close to the least informative one available. This is what to check instead.

1. Snapshots per market per minute, not total snapshots

Total snapshot counts are the headline number everywhere, and they are nearly meaningless. A total is just capture rate × markets tracked × time collecting. A provider with a bigger number might have better resolution — or might simply have been collecting for longer, or be counting redundant rows on markets nobody trades.

What you actually need to know is: on the specific market I care about, how many snapshots per minute do I get? A 5-minute market sampled twice a minute gives you ten data points to model an entire market lifecycle. That is not enough to test anything.

# Pull the same market from each provider, then compare density.
snaps = fetch_snapshots(market_id)          # provider-specific call

span_s  = (snaps[-1]["timestamp"] - snaps[0]["timestamp"]) / 1000
per_min = len(snaps) / (span_s / 60)

print(f"{len(snaps)} snapshots over {span_s:.0f}s = {per_min:.1f}/min")

# Gaps matter more than the average. One 90-second hole in a 5-minute
# market means you cannot model the part where it was decided.
gaps = [
    (b["timestamp"] - a["timestamp"]) / 1000
    for a, b in zip(snaps, snaps[1:])
]
print(f"max gap: {max(gaps):.1f}s   median: {sorted(gaps)[len(gaps)//2]:.1f}s")

2. Real book depth, or just top-of-book?

This is the single biggest determinant of whether your backtest means anything, and it is where marketing language gets slipperiest. "Order book data" can mean anything from the full ladder to a single bid/ask pair.

If you plan to trade any meaningful size, you need the ladder. A 500-share order in a thin Up/Down market does not fill at the top level — it walks the book, and the difference between the top level and your true average fill is frequently larger than the edge you are testing for.

def simulate_fill(levels, qty):
    """Walk the ladder. This is what actually happens to your order."""
    filled = cost = 0.0
    for lvl in levels:
        take = min(lvl["size"], qty - filled)
        cost += take * lvl["price"]
        filled += take
        if filled >= qty:
            break
    if filled < qty:
        return None            # Not enough liquidity to fill at all.
    return cost / filled

book = snapshot["orderbook"]["asks"]
print("top of book:", book[0]["price"])
print("true fill  :", simulate_fill(book, 500))
# A gap of 2-3c here on a $1 binary is routine, and it is
# larger than most claimed edges.

3. Are resolved markets actually retained?

The entire reason to pay for this data is that Polymarket discards it. So verify that the provider genuinely keeps it, rather than proxying live endpoints with a cache.

The test takes a minute: find a market that resolved weeks ago, request its snapshots, and confirm you get a full price path with depth — not just a metadata record saying which side won. Knowing the outcome is not data; every strategy worth testing is about the path, not the answer.

4. History window versus history depth

Providers sell history in two different shapes and the distinction matters more than the raw day count:

• A rolling window — the most recent N days, with older data ageing out. Fine for tuning against current market conditions.
• A retained archive — everything since collection began. Necessary if you want to test across different volatility regimes.

Which you need depends honestly on your strategy. If you are trading 5-minute markets and re-tuning weekly, 30 days is plenty and paying for more is waste. If you want to know whether your edge survived last year's conditions, a rolling window cannot answer that at any price.

5. Throughput you can actually use

Rate limits sound like a detail until you run your first real backtest. Pulling every snapshot for a month of 5-minute markets across three coins is a lot of requests, and a 10 req/sec limit turns an afternoon of research into an overnight job.

Two numbers matter and providers often publish only one: sustained throughput (requests per minute) and burst capacity (requests per second). A high per-minute limit with a low burst still stalls a parallel fetch.

If you are pulling bulk history regularly, also ask whether there is a bulk export path. Paginating a million snapshots through a REST endpoint is possible but it is not the right tool.

6. Can you evaluate it before paying?

You cannot assess data quality from a marketing page. Any provider confident in their data will let you look at it, and a free tier that requires a credit card is a trial, not a free tier.

Be clear-eyed about what a free tier is for, though. Ours exists so you can check coverage, snapshot density and response shape before committing — order book depth is a paid feature, so it is an evaluation tool rather than a research tier. Whatever the provider, work out which parts are actually exercisable for free before drawing conclusions.

7. Can your tools read the documentation?

A newer consideration, and one worth checking because it is invisible until it bites. If you build with Cursor, Claude Code or Codex, your assistant's ability to write a correct integration depends on whether it can read the provider's docs.

Some data providers block AI crawlers in robots.txt — a legitimate choice about training data, but it means models cannot see their documentation and will improvise an API surface instead. You can check any provider in about five seconds:

curl -s https://<provider>/robots.txt | grep -iA1 "GPTBot\|ClaudeBot\|Google-Extended"

# "Disallow: /" under those agents means your AI assistant
# cannot read their docs and will guess at the API instead.

For reference, PolyTest allows those crawlers and publishes llms.txt, llms-full.txt and an OpenAPI spec. The practical test is simpler than reading policy files, though: ask your assistant to write an integration against each provider and see which one produces working code.

When you should not pay anyone

Worth saying plainly, since it applies to us as much as anyone. You do not need a paid data provider if:

• You only need live data. Polymarket's public API and WebSocket streams are free, unauthenticated for market data, and perfectly good. Historical providers exist for history, nothing else.
• You are testing infrastructure, not a strategy. Auth, parsing, reconnects and rate limit handling can all be exercised against free live endpoints.
• Your strategy does not depend on fills. If you are studying base rates or resolution frequencies, that information survives in public metadata.
• You are willing to record it yourself. Running a collector against the public WebSocket is genuinely viable. It costs a small server and the discipline to keep it running — the catch is that you start with zero history and cannot backfill, so it only helps if you start well before you need the data.

The case for paying is narrow and specific: you want history you did not record, starting today.

A test you can run this afternoon

1. Sign up for the free tier of every provider on your list.
2. Pick one market — same coin, same timeframe, same day — and pull it from each.
3. Compare snapshots per minute and maximum gap. Density and continuity beat every headline number.
4. Check book levels per snapshot. If it is not a ladder, you cannot model fills.
5. Request a market that resolved a month ago and confirm you get a full path, not just an outcome.
6. Run your heaviest realistic query pattern and see which provider throttles you first.
7. Ask your AI assistant to write an integration against each and see which docs it can actually read.

That sequence takes an afternoon and tells you more than any comparison table, including this one. If you want to start with ours, the free tier needs no card and the endpoint reference is open to read without signing up at all.