The best Polymarket APIs in 2026, tested and priced per 1,000 market reads

Every Polymarket integration starts the same way. You've got a topic or a market in mind, you find the market, you read its price or its order book, maybe you look at who's been trading it, and you hand those rows to a dashboard or an agent. Polymarket splits that job across separate surfaces, and the part nobody writes down is which identifier moves from one surface to the next.

AnyAPI, which sells a normalized read-only Polymarket market endpoint by the request, is one of the six options here, and it's ours. I signed up for every hosted option that would give me a key, sent the same three searches - election, bitcoin, federal reserve - through each of them at 13 results a query, pulled one market's book, trades, and WebSocket snapshot through the official routes three times each.

The short version: for a Polymarket-only product the free official stack wins on coverage, speed, and price, and every paid option here sells packaging around data Polymarket gives away for free.

The best Polymarket API options

• Polymarket Gamma API for finding markets and their identifiers
• Polymarket CLOB API and WebSocket for prices, order books, and orders
• Polymarket Data API for trades, positions, and wallet activity
• Apify Polymarket Market Scraper for scheduled exports
• PMXT for cross-venue search, once its filters pass your test
• AnyAPI for normalized read-only rows inside a multi-source app

What makes a good Polymarket API?

I'm assuming you're a backend developer, not a trader. You need to find markets by keyword, read a price or a book, maybe inspect trades or a wallet's positions, and feed the result to code that runs without you watching it. Here's what I graded on.

• Identifiers that carry forward. A market row is only useful if the next request can use it. On Polymarket that means the condition ID and both outcome token IDs.
• Populated rows, not just present ones. A field that exists in the schema but is empty on half the rows is a bug you'll find in production.
• A price per thousand rows you can compute before the job runs. The official APIs charge nothing. For the paid options, every price is normalized to 1,000 market rows.
• Delivery that matches the job. A nightly export doesn't care about a five-second response. A "show me this market" endpoint does.
• A free tier you can actually test with. Enough calls to see the response shape across a real query list, without a card.

I didn't grade uptime, market accuracy, or order execution. The latency numbers come from three fixed searches per option and three repeats per official read, all from one machine on 2026-09-03.

The best Polymarket API options at a glance

Median response time for the three 13-row keyword searches, in milliseconds. PMXT is plotted for its speed, but the rows it returned weren't the rows I asked for.

Polymarket Gamma API (best for finding markets and their identifiers)

Polymarket Gamma API pros:

• Every one of the 39 rows I scored carried its market ID, question, outcomes, prices, volume, end date, condition ID, and outcome token IDs
• Fastest search of the three keyword paths at about half a second, and a single-market lookup came back in well under a tenth of a second
• No key, no fee, no plan

Polymarket Gamma API cons:

• Liquidity was present on 19 of 39 rows, so check the field exists before you display it or divide by it
• No order-book depth, no account activity, no order placement

Gamma is where every Polymarket build starts, and the reason isn't the search. It's the identifiers. Each market row comes with a condition ID and a parsed array of outcome token IDs, and those are the keys the other two official APIs want. Keep both. The book call needs an outcome token ID, the trades call needs the condition ID, and neither accepts a market slug.

Public search returned events with nested market rows for all three queries. For topic search use the public-search route; for filtered lists use the markets and events routes. If you're walking the whole catalog, the keyset routes are the safer pagination path. Rate limits are generous for a discovery job: 350 public search calls and 300 markets calls per 10 seconds, with a general ceiling of 4,000.

If you'd rather not hand-roll the requests, the official polymarket-client package listed markets in under a fifth of a second in my run and exposes typed models with consistent pagination across the surfaces.

Polymarket Gamma API pricing: $0 API fee.

Polymarket CLOB API and WebSocket (best for prices, order books, and orders)

Polymarket CLOB API and WebSocket pros:

• The book call returned bids, asks, last-trade price, trading constraints, and a state hash
• The public market WebSocket sent a full book snapshot as its first message on all three connections
• The only route on this page to placing an order

Polymarket CLOB API and WebSocket cons:

• Reads take an outcome token ID, so you can't get here without Gamma first
• One of my three book reads took half a second
• Orders need wallet signatures and private authentication

This is the surface that answers "what's the price right now." The REST book and price calls take the outcome token ID from Gamma, and the WebSocket market channel takes the same asset IDs in a subscribe message. Hold on to the book hash if you care about whether state changed between reads.

Speed was fine and not thrilling. The book median was about a fifth of a second, with one read at half a second, and the first WebSocket snapshot landed in about half a second every time. I'd poll it and initialize from it without a second thought. I wouldn't build a latency-sensitive loop on three samples from a laptop. The book endpoint allows 1,500 calls per 10 seconds, the bulk books endpoint 500, and the general limit is 9,000.

One housekeeping note for Python projects: the old py-clob-client is archived and marked nonfunctional. If your code still imports it, move to polymarket-client before you write anything new.

Polymarket CLOB API and WebSocket pricing: $0 API fee for market reads; private operations need signed wallet credentials.

Polymarket Data API (best for trades, positions, and wallet activity)

Polymarket Data API pros:

• Trades filtered by condition ID returned 10 public trades on every repeat, with price and wallet fields populated each time
• About a tenth of a second per call, the fastest of the official reads after Gamma's single-market lookup
• No key for the documented public analytics reads

Polymarket Data API cons:

• No discovery catalog, no order-book depth, no order placement

The Data API does exactly what its page says and nothing else. Pass a condition ID to get public trades on a market, or a wallet address to get positions and activity, and treat it as the third leg of the official stack rather than a replacement for either of the others. Rate limits are the tightest of the three: 200 trades calls and 150 positions calls per 10 seconds, 1,000 general. I didn't touch the private account endpoints.

Polymarket Data API pricing: $0 API fee.

Apify Polymarket Market Scraper (best for scheduled exports)

Apify Polymarket Market Scraper pros:

• The trial token worked
• All three runs returned the requested rows with outcomes, prices, volume, liquidity, last trade, end date, and market URL
• Cloud schedules and JSON, CSV, or spreadsheet downloads without writing a worker

Apify Polymarket Market Scraper cons:

• 4.6 seconds median per keyword search, nearly ten times Gamma
• Best bid was missing on 6 of 39 rows

The actor's own description says the records come from public APIs, and that's the honest way to price it. You're not buying market data, because the market data is free. You're buying a hosted job with keyword, status, result cap, minimum volume, and sort inputs, one dataset row per market, a schedule, and a download button. For a weekly export that lands in a spreadsheet, that's worth $1.49 per 1,000 rows, and I'd pick it over writing a cron worker myself.

For anything a user is waiting on, the speed rules it out. Five seconds for 13 rows is a batch job's number.

Apify Polymarket Market Scraper pricing: $1.49 per 1,000 market rows. Ten thousand rows is $14.90; a hundred thousand is $149.

PMXT (best for cross-venue search, once its filters pass your test)

PMXT pros:

• The Free key worked with Bearer authentication and every response came back in about a third of a second
• All 39 rows carried market ID, event ID, title, venue, outcomes, prices, volume, liquidity, resolution date, and URL
• Offset pagination worked, and there's a self-hosted mode if you don't want the hosted catalog

PMXT cons:

• Election, bitcoin, and federal reserve all returned the same 13 titles
• Adding the Polymarket exchange filter still returned Kalshi, Opinion, and Probable rows, so 0 of 39 rows came from Polymarket
• Bid and ask appeared on 18 of 39 rows

PMXT is a different product from the rest of this list. It's a unified schema across venues with matching and a shared trading interface, and the rows it returns are fully formed. The request is a GET to /v0/markets with query, limit, offset, and an optional exchange, and the response carries the data plus a count, limit, and offset in meta. Offset 13 moved cleanly to the next page.

The problem is what came back. Three unrelated queries produced identical rows, and asking for Polymarket produced three other exchanges. That took 12 calls and no money to establish. It was about seven tenths of Gamma's search time, but of the wrong rows, and speed on the wrong rows isn't speed.

If cross-venue is your job, PMXT is the only option here that does it, and the free tier is big enough to run a real test. Run that test before it goes near a request path.

PMXT pricing:

• Free: $0 a month for 25,000 REST calls
• Starter: $29.99 a month for 250,000 calls, about $0.12 per 1,000 at full use
• Pro: $99.99 a month for 1,000,000 calls, about $0.10 per 1,000

AnyAPI (best for normalized read-only rows inside a multi-source app)

AnyAPI pros:

• Same found and data.items envelope as every other AnyAPI endpoint, so it drops into code that already reads our other sources
• Rows carry question, outcomes, price, volume, liquidity, end time, and URL
• One prepaid USD wallet, price printed on the endpoint page before you call it

AnyAPI cons:

• Slowest search I ran at 6.7 seconds median, about 14 times Gamma
• No condition ID and no outcome token IDs, so the response can't continue into a book, a price history, or an order
• About 3.5 times Apify's listed price per row at full batches, and about 6.4 times at the batch I actually measured

For a Polymarket-only build I wouldn't pick ours. The official route is free, faster, and hands you the identifiers. Ours doesn't. The published contract stops at the market row, and if your next request is an order book you'll be back in Gamma looking up the same market to get the token ID.

Where it earns its place is an app that's already reading several data sources through one AnyAPI key and one wallet, and wants Polymarket markets in the same normalized shape beside them, with no separate account and no plan to size. You POST a query, a limit, a sort, and a status. Each of my 13-result calls cost about 12 cents, with the per-request cap at 13 cents, so the way to keep the per-row price down is to ask for the maximum 25 results every time. Even then it's a multiple of Apify's rate, and the speed is a batch job's speed.

AnyAPI pricing: $5.28 per 1,000 market rows at 25 rows per call, $9.58 per 1,000 at 13 rows per call, with each request capped at $0.132. My measured 13-row calls each billed $0.12458. Ten thousand rows is $52.80 at full batches.

Which Polymarket API should you use?

• You only need Polymarket, and you want discovery, prices, and books: the free official stack, Gamma into CLOB.
• You need trades, positions, or a wallet's activity: Polymarket Data API.
• You need to place an order: Polymarket CLOB API, with wallet signatures.
• You want a scheduled export to CSV or a spreadsheet without running a worker: Apify Polymarket Market Scraper.
• You're comparing Polymarket against Kalshi and other venues in one schema: PMXT, after your own filter test passes.
• You're already on AnyAPI for other sources and want Polymarket rows in the same shape and the same bill: AnyAPI.
• You're writing Python: polymarket-client, not py-clob-client.

The limits of this comparison

• Three searches per option at 13 results each, and three repeats of one market's book, trades, and WebSocket snapshot, all from one machine. That's a response-shape test, not an uptime or throughput benchmark.
• I didn't place an order, sign anything with a wallet, or call any private account endpoint, so the trading side of CLOB is documented, not measured.
• PMXT's identical rows across queries and its missing Polymarket rows may be specific to the Free tier or to this run. I couldn't tell.
• I found no recurring independent reports on the specific Apify actor or the AnyAPI endpoint, so those two sections rest on their current documentation and my own runs.
• Paid prices are per 1,000 market rows from a keyword search, one query, one status filter, no retries. Every official route is $0 API fee within its rate limits.
• Prices and docs checked on 2026-09-03.

The Polymarket markets endpoint page has the live request body, the normalized response fields, and the current per-request price.

Use data responsibly and follow AnyAPI's Acceptable Use Policy.