Discover/Polymarket API
live

Polymarket APIpolymarket.com

Access Polymarket events, order books, price history, leaderboards, and trade data via a structured API. 8 endpoints covering markets, odds, and traders.

Endpoint health
verified 7h ago
get_order_book
get_last_trade_prices
search_markets
get_trending_markets
get_top_markets
7/8 passing latest checkself-healing
Endpoints
8
Updated
21d ago

What is the Polymarket API?

This API exposes 8 endpoints for Polymarket prediction market data, covering everything from trending events and top markets to real-time order books and historical price series. The get_event_details endpoint returns full market metadata including CLOB token IDs, resolution criteria, volume, and liquidity — the identifiers you need to query order books and price history for any individual market outcome token.

Try it
Maximum number of results to return per type.
Search keyword to find prediction market events.
api.parse.bot/scraper/20b82f08-34e9-4c9e-91cd-eb4ff7b7814f/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/20b82f08-34e9-4c9e-91cd-eb4ff7b7814f/search_markets?limit=5&query=bitcoin' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

Typed, relational, agent-ready

A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.

  • Fully typed · autocompletes
  • Objects link to objects
  • Typed errors & pagination

Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:

uv add parse-sdk
uv run parse init
uv run parse add --marketplace polymarket-com-api

uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.

from parse_apis.polymarket_api import (
    Polymarket, EventSummary, Event, MarketOrder, PriceInterval,
    LeaderboardSort, LeaderboardTimeframe,
)

client = Polymarket()

# Search for Bitcoin prediction markets
for event in client.events.search(query="bitcoin", limit=5):
    print(event.title, event.slug, event.active)

# Get trending markets by 24h volume
for event in client.events.trending(limit=3):
    print(event.title, event.volume_24hr, event.liquidity)
    for market in event.markets:
        print(" ", market.question, market.outcome_prices)

# Get top markets sorted by volume, filtered to active
for event in client.events.top(order=MarketOrder.VOLUME_24HR, active="true", limit=5):
    print(event.title, event.slug)

# Fetch full event details from a summary
first_event = next(iter(client.events.search(query="bitcoin", limit=1)))
details = first_event.details()
print(details.title, details.volume, details.liquidity, details.markets_count)

# Access market-level CLOB token IDs from the detailed event
market = details.markets[0]
print(market.question, market.clob_token_ids, market.last_trade_price)

# Get order books for a token
token_id = market.clob_token_ids[0]
for book in client.orderbooks.list(token_ids=token_id):
    print(book.asset_id, book.last_trade_price, book.tick_size)
    for bid in book.bids:
        print("  bid:", bid.price, bid.size)

# Get price history
for point in client.pricepoints.history(token_id=token_id, interval=PriceInterval.ONE_WEEK, fidelity="1440"):
    print(point.t, point.p)

# Get last trade prices
for trade in client.trades.last(token_ids=token_id):
    print(trade.token_id, trade.price, trade.side)

# Get leaderboard
lb = client.leaderboards.fetch(sort=LeaderboardSort.PROFIT, timeframe=LeaderboardTimeframe.MONTHLY)
print(lb.traders_count, lb.biggest_wins_count)
for trader in lb.traders:
    print(trader.rank, trader.name, trader.profit_loss, trader.volume)
All endpoints · 8 totalmissing one? ·

Full-text search over prediction market events by keyword. Returns matching events with their associated markets, current prices, and status. has_more indicates additional results exist beyond the returned set.

Input
ParamTypeDescription
limitintegerMaximum number of results to return per type.
queryrequiredstringSearch keyword to find prediction market events.
Response
{
  "type": "object",
  "fields": {
    "query": "string — the search keyword used",
    "events": "array of event objects with nested markets, prices, and status",
    "has_more": "boolean — whether more results are available",
    "total_results": "integer — number of events returned"
  },
  "sample": {
    "data": {
      "query": "bitcoin",
      "events": [
        {
          "id": "555627",
          "slug": "bitcoin-above-on-june-10-2026",
          "image": "https://polymarket-upload.s3.us-east-2.amazonaws.com/BTC+fullsize.png",
          "title": "Bitcoin above ___ on June 10?",
          "active": true,
          "closed": false,
          "markets": [
            {
              "slug": "bitcoin-above-58k-on-june-10-2026",
              "active": true,
              "closed": false,
              "spread": 0.002,
              "best_ask": 0.98,
              "best_bid": 0.978,
              "outcomes": [
                "Yes",
                "No"
              ],
              "question": "Will the price of Bitcoin be above $58,000 on June 10?",
              "outcome_prices": [
                "0.979",
                "0.021"
              ],
              "group_item_title": "58,000",
              "last_trade_price": 0.979
            }
          ],
          "end_date": "2026-06-10T16:00:00Z",
          "neg_risk": false,
          "start_date": "2026-06-03T16:26:45.640718Z"
        }
      ],
      "has_more": true,
      "total_results": 10
    },
    "status": "success"
  }
}

About the Polymarket API

Market Discovery

Three endpoints handle market discovery. search_markets accepts a query string and returns matching events with nested market objects, current prices, and a has_more flag for pagination awareness. get_trending_markets returns events sorted by 24-hour trading volume, with each event carrying yes/no price odds, liquidity, and category tags. get_top_markets adds sorting (volume24hr, volume, liquidity), filtering by active or closed status, category slug filtering, and offset-based pagination — making it the right entry point for building browsable market directories.

Market Detail and Token IDs

get_event_details takes an event slug (obtained from discovery endpoints) and returns the complete event record: id, title, description, volume, liquidity, markets_count, and a markets array where each entry includes CLOB token IDs. Those token IDs are the keys for all order book and price queries. The description field typically contains resolution criteria, which is useful for displaying settlement logic.

Order Book, Prices, and Trades

get_order_book accepts one or more comma-separated CLOB token IDs and returns an array of books, each containing bids, asks, tick_size, and last_trade_price. get_price_history takes a single token_id with an optional interval (1h, 6h, 1d, 1w, 1m) and fidelity (minutes between points), returning a history array of {t, p} pairs — unix timestamp and price. get_last_trade_prices returns the most recent trade price and side (BUY or SELL) for each requested token.

Leaderboard

get_leaderboard returns ranked trader data filterable by sort (profit or volume) and timeframe (today, weekly, monthly, all). Each entry in the traders array includes rank, wallet_address, name, profit_loss, and volume. A separate biggest_wins array surfaces the highest-profit individual trades for the period, with event_title and profit per entry.

Reliability & maintenanceVerified

The Polymarket API is a managed, monitored endpoint for polymarket.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when polymarket.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.

This isn't an official polymarket.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.

Last verified
7h ago
Latest check
7/8 endpoints passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Build a prediction market dashboard showing trending events with live yes/no odds from get_trending_markets.
  • Chart probability over time for a specific outcome token using get_price_history with configurable fidelity intervals.
  • Display real-time bid/ask spreads and last trade prices for market tokens via get_order_book and get_last_trade_prices.
  • Filter and rank open markets by 24-hour volume or liquidity using get_top_markets with order and active params.
  • Show top traders by profit or volume for a given timeframe using the traders and biggest_wins arrays from get_leaderboard.
  • Resolve event slugs to CLOB token IDs with get_event_details to wire up downstream order book and price queries.
  • Power a keyword search interface over prediction markets using search_markets with query and limit parameters.
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo1005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min

One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.

Frequently asked questions
Does Polymarket have an official developer API?+
Yes. Polymarket provides a public CLOB (Central Limit Order Book) API and a data API documented at https://docs.polymarket.com. This Parse API surfaces the same market, order book, and leaderboard data through a normalized REST interface.
How do I get the token IDs needed for `get_order_book` and `get_price_history`?+
Call get_event_details with an event slug. Each object in the markets array includes clob_token_ids — typically two IDs per binary market (one for YES, one for NO). Pass those IDs as comma-separated values to get_order_book or individually to get_price_history.
Does `get_price_history` cover the full lifetime of a market?+
The interval parameter supports up to 1m (one month) of history with configurable fidelity down to per-minute granularity. Longer historical series going back to market inception are not currently exposed by this endpoint. You can fork the API on Parse and revise it to add an endpoint covering extended historical ranges.
Does the API expose individual trade history or position data for a wallet address?+
Not currently. The API covers leaderboard-level trader data (profit, volume, biggest wins) and last trade prices per token, but per-wallet trade history and open positions are not included. You can fork the API on Parse and revise it to add a wallet-specific trade history endpoint.
What does the `biggest_wins` array in `get_leaderboard` contain?+
Each entry includes rank, username, event_title, and profit — representing the single highest-profit trades made by any user in the selected timeframe. It is separate from the traders array, which aggregates total profit or volume across all activity by a trader.
Page content last updated . Spec covers 8 endpoints from polymarket.com.
Related APIs in FinanceSee all →
polymarketanalytics.com API
Track any trader's performance on Polymarket by retrieving their wallet positions, trade history, profit/loss records, category breakdowns, and deposit/withdrawal activity. Monitor trading strategies and market exposure across multiple prediction markets in real-time.
app.hyperliquid.xyz API
Access real-time leaderboard rankings, market data for perpetual and spot markets, order books, and detailed trader analytics on the Hyperliquid decentralized exchange. Monitor top traders' open positions and identify delta-neutral trading strategies.
manifold.markets API
Search and discover prediction markets on Manifold Markets by keyword, with flexible sorting and filtering options to find exactly what you're looking for. Easily browse markets with pagination support to explore thousands of predictions on topics from politics to pop culture.
moondev.com API
Access live crypto market data from MoonDev's public endpoints: aggregated Hyperliquid positions near liquidation, fees leaderboard, PnL share stats by address, Polymarket sweep trades, and soon-to-expire Polymarket markets — plus a single aggregate endpoint that pulls all major datastreams at once.
polygon.io API
Access real-time and historical market data for stocks, cryptocurrencies, forex, and commodities—including price aggregates, ticker details, and financial statements—all from a single platform. Get the latest market news, check trading status across exchanges, and retrieve comprehensive ticker information to power your investment analysis and trading decisions.
sentimentrader.com API
Track real-time market sentiment and investor behavior by accessing Smart Money/Dumb Money confidence levels, trending stocks, and capitulation signals to inform your trading decisions. Monitor macroeconomic conditions alongside sentiment indicators to get a comprehensive view of current market psychology and potential turning points.
etoro.com API
Monitor top eToro traders by accessing their profiles, portfolio holdings, performance statistics, and trading history to inform your investment decisions. Discover trending stocks and cryptocurrencies, search for specific instruments, and view detailed market data and news to stay updated on investment opportunities.
cmegroup.com API
Get CME Group market data including FedWatch interest-rate probabilities, futures quotes and settlements, volume/open interest history, and options expirations and near-the-money option chains.