Polymarket Market Price API

• Current book: GET a market returns today's bid, ask, last, volume, and open interest — free and keyless for public markets.
• Price history: query historical prices per market over interval and time ranges on the official data API.
• Books via POST: the batch book endpoint returns many markets' ladders in one call, useful for screening the whole site.
• The official feed is the source of truth for the exchange; the archive is a deeper, timestamped copy of the same universe.

• The archive serves the same three datasets (books, prices, metrics) at 250ms with start/end windows — history, not just current state.
• Free Starter reads 3 days of 250ms history per market; paid tiers extend windows to 30–120 days for crypto and 30 for sports.
• Batch queries return windows spanning many markets in one call, which is how cross-market studies (the recorded 26-second family collapse) become one query.
• Every response row carries the exact timestamp grid, so point-in-time reconstructions are exact, not sampled.

The canonical integration is a scheduled pull from the archive into your store, with the official API as the live fallback; the two sources share field names, so switching costs zero.

Pricing every app the same way — one client, one schema — is the design; spread, mid-vs-floor, and VWAP pages all read the same rows.

• Send one keyless GET for a market today: parse bid, ask, last, volume, and open interest into a normalized row with your best timestamp.
• Next, GET the same market's price history over the last interval and confirm the returned cadence matches the documentation.
• Then call the batch books POST for a handful of slugs and verify each responds with the same ladder shape the archive page documents.
• Write the three sources to one table (slug, source, ts, mid, last, floor, volume, oi); the merge is your single price API.

The price API is intentionally generous at the free tier because the exchange's public state is exactly that — public; what is paid is depth and history, not accessibility.

The archive is the same API with the precision turned up: start/end windows, 250ms frames, and the monotonic sequences that make replays exact.

One schema across official and archive is the design; your client code should not know or care which source answered a query.

Scheduled archive pulls feed the store; the official API covers the live slice; apps read one interface backed by both — the canonical integration this page recommends.

Batch queries are how cross-market work (the recorded 26-second family collapse) ships as one API call instead of N loops.

Free price endpoints cover today; the archive extends the same schema to 250ms and deep history.

The distinction to keep is state versus record: official is the current state, archive is the record that proves it.

Build your integration against the shared field names and the upgrade to paid depth changes nothing in your code.

A useful habit: whenever you integrate a price API, write the response to your store exactly as received and stamp your own ingested-at time — the archive's ts plus your ingest ts is the two-clock view that finds drift early.

Then exercise the batch path on the same markets and compare totals to the single-market pulls; any divergence localizes a pagination or window bug before it reaches a dashboard.

The takeaway is that the API is free at the state level, deep at the record level, and one schema at both — and the verification practice above is what actually keeps it trustworthy.

The verification habit that pays for itself is rerunning the batch-vs-single comparison after every schedule change, because window and pagination bugs surface there before they reach any chart.

• api data
• order book data
• websocket data