Polymarket API: the developer’s data and trading reference (2026)

By /

title: “Polymarket API: the developer’s data and trading reference (2026)” slug: polymarket-api post_type: guide meta_title: “Polymarket API Guide (2026): CLOB, Gamma, Auth & Examples” meta_description: “Polymarket’s CLOB API handles 200K+ daily trades. Endpoints, auth, rate limits, Python/curl/JavaScript examples, plus Dune & Goldsky alternatives.” focus_keyword: polymarket api secondary_keywords: – polymarket clob api – polymarket gamma api – polymarket api documentation – polymarket trading bot – polymarket data feed – polymarket python sdk – polymarket websocket – polymarket api rate limit – polymarket dune analytics – polymarket goldsky subgraph schema: – Article – TechArticle last_updated: 2026-05-28 sub_id: guide-polymarket-api cro_audit_version: v1 cro_audit_date: 2026-05-28

Last updated: May 28, 2026.

Newcomer to APIs? Start with the prediction-markets explainer — you’ll get more out of this page once the mechanics are clear. Experienced trader without dev background? Skip to Read-only data access — useful endpoints for research without writing trading code. Developer / quant building a bot? Jump to Authentication and code examples — the actionable sections.

The Polymarket CLOB API processes 200K+ trades per day. Here’s how to read it, query it, and build on it. As of May 28, 2026, Polymarket exposes two public APIs (the CLOB API for trading and live order-book data, and the Gamma API for market metadata), supports REST and WebSocket access, authenticates via account-derived API key triplets, and is mirrored by community data feeds on Dune Analytics and the Polymarket Goldsky subgraph for analytical workflows. Below is the working developer reference — sourced from Polymarket’s official docs.polymarket.com, the open-source py-clob-client repository, the Polygon block explorer for on-chain verification, and several community Dune dashboards.

The short answers

  • What’s the Polymarket API? Two public APIs: CLOB (trading + live data) and Gamma (market metadata, legacy).
  • Do I need an API key? Read-only queries: no. Trading or per-account data: yes — generate via your Polymarket account.
  • Does it support WebSocket? Yes — for real-time order-book and trade-event subscriptions.
  • What language SDKs exist? Official: py-clob-client (Python), clob-client (TypeScript/JS). Community: Rust, Go, others.
  • Rate limits? Generous for public endpoints; account-specific endpoints have stricter per-key limits.
  • Best for analytical research without trading? Polymarket Dune queries + the Goldsky subgraph.

TL;DR

Polymarket’s API surface is reasonably modern: a REST CLOB API for trading and order-book reads, a WebSocket endpoint for live subscriptions, and a separate (legacy) Gamma API that primarily exposes market metadata. Authentication uses a three-piece API key generated from your Polymarket account (API key + secret + passphrase), signed against EIP-712 messages for trade execution.

For most developer use cases, the entry point is the CLOB API at clob.polymarket.com. The most-used endpoints are /markets (list markets and metadata), /orderbook/{token_id} (live order book snapshots), /trades (recent executed trades), and /order (place a new order via authenticated POST).

If you only want analytical data — historical price series, trade volume, market resolution outcomes — without writing any trading code, the cleanest path is the Polymarket Goldsky subgraph (a GraphQL endpoint that mirrors all Polygon on-chain Polymarket events) or the Polymarket Dune Analytics dashboards (curated SQL views you can query in the browser).

This guide walks through both surfaces with code examples in Python and curl, explains the authentication flow, covers rate limits and common errors, and points to the most useful community resources. We will not turn this into “build a profitable trading bot in 10 minutes” — that takes much more than API knowledge. We will show you the working primitives you can build on.

Polymarket’s API architecture (the 60-second tour)

Polymarket’s on-chain settlement runs on Polygon. Every market is a smart contract; every trade settles on-chain. The public APIs are off-chain wrappers that make the on-chain state easy to query and interact with.

Three surfaces matter:

1. The CLOB API (clob.polymarket.com)

The Central Limit Order Book (CLOB) API is Polymarket’s primary trading and live-data surface. It’s a REST API with a parallel WebSocket endpoint for subscriptions. Read endpoints are open; write endpoints (placing orders, canceling orders) require authentication.

This is where you’ll spend most of your developer time if you’re building any kind of interactive or trading application.

2. The Gamma API (gamma-api.polymarket.com)

The Gamma API is older and primarily exposes market metadata — market titles, descriptions, resolution sources, condition IDs, related events. Gamma was originally the main API and has been partially deprecated in favor of CLOB; some metadata that’s not on CLOB still lives only on Gamma.

For market discovery and metadata enrichment, Gamma is the right entry point.

3. On-chain Polygon contracts

Everything trade-related on Polymarket ultimately settles on a set of smart contracts on the Polygon network. You can query the contracts directly through Polygonscan, the Goldsky subgraph, or any Ethereum-compatible RPC. This is the canonical record — the APIs above are convenience wrappers around it.

For verification, analytics, or building on top of historical data, going direct to the on-chain layer (via subgraph or Dune) is often cleaner than querying the off-chain APIs.

Read-only data access

The simplest entry point: if you only need market data and don’t need to place trades, you can pull a lot of useful information without ever generating an API key.

Endpoints that don’t require auth:

  • GET /markets — list all currently-listed markets with metadata
  • GET /markets/{condition_id} — fetch a single market by ID
  • GET /orderbook/{token_id} — fetch the current order book for a specific outcome token
  • GET /trades — recent trades across all markets (filterable by token_id, market, time range)
  • GET /events — events (the higher-level grouping above markets)
  • GET /prices-history — historical price series for a token (with time granularity controls)

Use these for: market discovery, research, backtesting, building dashboards, populating an analytics tool. None of these require authentication — they’re rate-limited per IP but generous enough for most non-production use.

The CLOB API endpoints worth knowing

The full Polymarket CLOB API surface is documented at docs.polymarket.com. Below are the endpoints that cover ~80% of practical developer use cases.

Market discovery and metadata

  • GET /markets — list markets. Query params: active, closed, archived, limit, next_cursor. Returns market objects with condition_id, tokens (each YES and NO outcome has a token_id), category, enable_order_book, and more.
  • GET /markets/{condition_id} — get a single market by its condition ID. Returns full metadata including settlement rules text.
  • GET /events — markets grouped by event. Useful for discovering related markets (“All NFL Week 17 markets” or “All Fed December decision markets”).

Live order-book data

  • GET /orderbook/{token_id} — snapshot of the current order book for a YES or NO token. Returns bids (sorted desc by price) and asks (sorted asc by price), with price and size per level.
  • GET /book/{token_id} — alias for the above on some doc versions.
  • GET /midpoint?token_id={token_id} — mid-price between best bid and best ask. Quick read for current implied probability.

Trade history

  • GET /trades — recent executed trades. Query params: token_id, market, taker, maker, before, after, limit. Returns trade records with price, size, side, timestamp.
  • GET /prices-history?market={condition_id}&interval={1m|1h|1d} — time-series price history at configurable granularity. The cleanest endpoint for backtesting or chart construction.

Order placement (authenticated)

  • POST /order — place a new limit or market order. Requires API key auth + signed EIP-712 message for the order itself. Returns an order ID and status.
  • DELETE /order/{order_id} — cancel an existing order.
  • GET /orders — list your own orders (active and historical). Returns paginated order objects.

Account-specific reads (authenticated)

  • GET /positions — your current open positions.
  • GET /balance — your USDC balance available on Polymarket.
  • GET /trades?taker={your_address} — your own trade history.

For the complete schema of each endpoint (request/response shapes, error codes), refer to docs.polymarket.com.

Authentication: CLOB API keys

Polymarket’s CLOB API auth uses a three-piece credential set:

  • API key (a public identifier)
  • API secret (used for HMAC signing)
  • API passphrase (an additional secret rotated separately)

All three are needed to sign authenticated requests. The triplet is generated from your Polymarket account (effectively from your Polygon address signing a derivation message), so each Polymarket account can derive its own deterministic API key set.

To generate API keys:

  1. Sign in to Polymarket
  2. Connect your wallet (or use Polymarket’s managed wallet for US-app accounts)
  3. Use the official py-clob-client or clob-client SDK to derive your API key triplet:
from py_clob_client.client import ClobClient
from py_clob_client.constants import POLYGON

host = "https://clob.polymarket.com"
key = "YOUR_PRIVATE_KEY"  # never commit this anywhere
chain_id = POLYGON

client = ClobClient(host, key=key, chain_id=chain_id)
api_creds = client.create_or_derive_api_creds()
print(api_creds)
# Returns: ApiCreds(api_key="...", api_secret="...", api_passphrase="...")
  1. Store the returned credentials securely (environment variables, a secrets manager — never in source code or git).

Signing trades: Polymarket orders are signed using EIP-712 typed data signatures, the same scheme used across Ethereum. The official SDKs handle EIP-712 signing automatically; if you’re implementing from scratch in a non-supported language, you’ll need an EIP-712 library and to sign each order before submission.

Security best practice: generate one set of API keys per environment (development, staging, production), rotate them periodically, and never share them. A compromised key gives an attacker the ability to place trades on your account up to your USDC balance.

Python example: fetch an orderbook

The cleanest way to start: pull a live order book for a single market.

import requests

# Find a market's condition_id and token_id from /markets first
# This example uses a hypothetical token_id for a YES outcome
token_id = "12345..."  # replace with actual token_id

response = requests.get(
    f"https://clob.polymarket.com/orderbook/{token_id}",
    timeout=10
)
data = response.json()

print(f"Best bid: ${float(data['bids'][0]['price']):.3f} × {data['bids'][0]['size']}")
print(f"Best ask: ${float(data['asks'][0]['price']):.3f} × {data['asks'][0]['size']}")
print(f"Spread:   ${float(data['asks'][0]['price']) - float(data['bids'][0]['price']):.3f}")

Run that against any active market’s token_id and you have a live order-book reader in eight lines of Python. No authentication required.

Python example: list active markets

A more complete example — list the first 50 active markets and their categories:

import requests

response = requests.get(
    "https://clob.polymarket.com/markets",
    params={"active": "true", "closed": "false", "limit": 50},
    timeout=10
)
markets = response.json().get("data", [])

for m in markets:
    print(f"[{m.get('category', 'uncategorized'):>10}] {m.get('question', 'no question')}")
    print(f"    condition_id: {m.get('condition_id', '')[:16]}...")
    print(f"    tokens: YES={m['tokens'][0]['token_id'][:16]}... NO={m['tokens'][1]['token_id'][:16]}...")
    print()

Output: a paginated list of current markets with their question text, category, and the YES/NO token_id values you’d need to query order books or place orders.

curl example: a quick CLI sanity check

For a fast sanity check before writing any code, hit the API from your shell:

# List the 10 most recent markets
curl -s "https://clob.polymarket.com/markets?active=true&limit=10" | jq '.data[] | {question, condition_id, category}'

# Fetch midpoint for a specific token
curl -s "https://clob.polymarket.com/midpoint?token_id=12345..." | jq

# Fetch recent trades
curl -s "https://clob.polymarket.com/trades?limit=20" | jq '.data[] | {price, size, side, taker_order_id}'

If curl returns a valid JSON response, the API is reachable from your environment and you can move to writing code. If you get a 401/403, you’re trying to hit an authenticated endpoint without credentials.

JavaScript / TypeScript example

For Node.js or browser-based applications:

const response = await fetch(
  'https://clob.polymarket.com/orderbook/12345...',
  { method: 'GET' }
);
const book = await response.json();

const bestBid = parseFloat(book.bids[0].price);
const bestAsk = parseFloat(book.asks[0].price);
const midpoint = (bestBid + bestAsk) / 2;
const spread = bestAsk - bestBid;

console.log(`Implied probability: ${(midpoint * 100).toFixed(1)}%`);
console.log(`Spread: ${(spread * 100).toFixed(1)} bps`);

For an authenticated trading client in TypeScript, use the official @polymarket/clob-client npm package:

import { ClobClient, Chain } from "@polymarket/clob-client";

const host = "https://clob.polymarket.com";
const client = new ClobClient(host, Chain.POLYGON, /* signer */);

// Derive API credentials (do this once, store the result)
const creds = await client.createOrDeriveApiKey();

// Now you can place orders, query positions, etc.

WebSocket subscriptions

For real-time updates without polling the REST endpoints, use the CLOB WebSocket:

wss://ws-subscriptions-clob.polymarket.com/ws/

You subscribe to channels by sending a JSON message after connection:

const ws = new WebSocket("wss://ws-subscriptions-clob.polymarket.com/ws/market");

ws.onopen = () => {
  ws.send(JSON.stringify({
    type: "Market",
    assets_ids: ["12345..."]  // token_ids to subscribe to
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log("Event:", data.event_type, data);
};

You’ll receive book events (order book updates), last_trade_price events (when a trade executes), and tick_size_change events (when the price increment changes). For trading bots that need sub-second response times, WebSocket is the only practical option.

Rate limits and error handling

Polymarket’s rate limits are not heavily documented but follow predictable patterns:

  • Read-only public endpoints (/markets, /orderbook, /trades): generous, typically several requests per second per IP. Suitable for normal application use.
  • Authenticated trading endpoints (/order POST/DELETE): tighter limits per API key, designed to prevent bot abuse. Plan for ~1–5 orders per second sustained per key.
  • Bulk historical queries (/prices-history): may rate-limit during heavy load. Implement exponential backoff.

Common error codes:

  • 401 Unauthorized — missing or invalid auth headers on a protected endpoint.
  • 403 Forbidden — auth is valid but the action isn’t permitted (e.g., trying to access another account’s data).
  • 429 Too Many Requests — rate limit exceeded. Back off and retry with exponential delay.
  • 400 Bad Request — malformed parameters. Check your token_id format, your numeric precision, or your order payload.
  • 500 / 502 / 503 — server-side issue. Retry with backoff.

Recommended pattern for production:

import time
import random

def safe_request(url, max_retries=5, **kwargs):
    for attempt in range(max_retries):
        try:
            response = requests.get(url, timeout=10, **kwargs)
            if response.status_code == 429:
                # Rate limited — exponential backoff with jitter
                delay = (2 ** attempt) + random.uniform(0, 1)
                time.sleep(delay)
                continue
            response.raise_for_status()
            return response.json()
        except requests.RequestException as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)
    raise Exception("Max retries exceeded")

Always handle 429 explicitly and respect any Retry-After header if one is returned. Polymarket’s rate limits are reasonable for compliant clients; aggressive querying will get you blocked.

How to use the API for trading bots

The honest framing: a working API client is the first 10% of a trading bot. The other 90% is signal-generation, risk management, position sizing, execution-quality monitoring, and operational reliability.

The basic loop a trading bot runs:

  1. Pull current market state (/markets, /orderbook, /midpoint)
  2. Compute a signal (your probability estimate, derived from external data — news, polls, on-chain events, etc.)
  3. Compute desired position size (a function of edge, confidence, current position, risk budget)
  4. Reconcile desired vs. current position (place orders to bridge the gap)
  5. Monitor execution and update P&L tracking
  6. Re-poll every N seconds (or react to WebSocket events for tighter loops)

Important practical caveats:

  • Slippage matters. Your bot’s modeled edge has to clear actual fill costs. If your edge is 100 bps but spreads are 200 bps, you have no edge.
  • Latency matters less than people think. On most non-marquee Polymarket markets, the order book doesn’t move on millisecond timescales. Polling-once-per-5-seconds bots work fine for medium-frequency trading. Sub-second is only needed if you’re competing with other algos on highly-liquid contracts.
  • Cancel logic must be robust. Leaving stale orders on the book during a sharp market move can result in immediate losses. Implement a kill switch and a heartbeat-based auto-cancel.
  • Test with tiny size first. Whatever your modeled position size, divide by 100 for the first week of live trading. Reality will diverge from your backtest in ways you didn’t predict.

For most developers exploring Polymarket APIs, the honest first project is a research/analytics tool, not a trading bot. Build something that helps you understand the markets first; build a bot only after you have a documented, testable signal worth executing on.

Get the Bellwether weekly market roundup → One short email each Sunday. What we watched on Kalshi and Polymarket this week, the regulation news that mattered, and the smart-money trades that worked. No spam, unsubscribe anytime.

Subscribe — it’s free →

We send one email per week. We don’t share your email — ever.

How to use the API for analysis (no trading)

A lot of the most useful API work has nothing to do with trading. Examples:

Building a research dashboard. Pull market state every few minutes, store it in a database, build charts of probability over time, correlate against news events. This is what most journalists and policy analysts using prediction markets are doing — they want time-series, not execution.

Backtesting signals. Pull historical price series via /prices-history, simulate what a particular signal would have predicted, and compute hit rates. No real-money risk; you’re testing whether your edge model has any historical evidence behind it.

Market discovery and curation. Use /markets and /events to find under-the-radar markets that are mispriced relative to your view. Feed your shortlist into a simple notification system. The discovery layer is often more valuable than the execution layer.

Resolution-source tracking. Some markets resolve based on specific sources (USDA reports, CDC data, weather observations). Build a scraper that monitors the resolution source and notifies you when an outcome is determined. Helps with timing exits before the official Polymarket resolution.

For these workflows, you mostly don’t need authentication — read-only endpoints cover 95% of what you need.

What r/Polymarket actually says about API usage:

“I built a Dune dashboard for Fed-decision market history before I ever placed a trade. Spending two weeks just looking at how prices moved relative to FOMC announcements taught me more about edge than any trading book did. The data is free — start there before you try to trade.”

— Composite of r/Polymarket developer-thread posts, Q1 2026

Polymarket on Dune Analytics

If you don’t want to host or query a raw API, Dune Analytics has dozens of community-maintained dashboards and SQL views over Polymarket on-chain data. Dune queries the Polymarket smart contracts on Polygon directly and exposes them as easy-to-write SQL.

Useful public Dune dashboards (searchable on dune.com):

  • Polymarket market overview — total volume, active markets, trader counts over time
  • Polymarket top traders — leaderboard by realized P&L on-chain
  • Polymarket resolution tracker — recently resolved markets and their final outcomes
  • Polymarket category breakdown — volume by category (politics, sports, crypto, etc.)

Why use Dune: if you want to ask analytical questions (“what’s the average spread on political markets vs sports markets?”, “what fraction of YES holders exit before resolution?”), Dune’s SQL interface is much faster than building a custom indexer over the raw on-chain data. Free tier covers most non-production use.

The downside: Dune is read-only and not real-time (data refreshes on schedules, typically every few minutes to hours). For sub-minute latency, use the CLOB API directly.

The Polymarket Goldsky subgraph

For analytical queries that need lower latency and more flexibility than Dune, the Polymarket subgraph on Goldsky is the canonical source. A subgraph is a GraphQL endpoint that indexes specific on-chain events (in this case, every Polymarket trade, market resolution, and position transfer on Polygon) and exposes them through a query interface.

Goldsky URL pattern: https://api.goldsky.com/api/public/{project_id}/subgraphs/polymarket/{version}/gn

(The specific subgraph IDs change as Polymarket updates; check docs.polymarket.com or the Goldsky public catalog for the current URL.)

Example GraphQL query (Polymarket trades in the last 24 hours):

query RecentTrades {
  trades(
    first: 100
    orderBy: timestamp
    orderDirection: desc
    where: { timestamp_gt: "1716847200" }
  ) {
    id
    timestamp
    market { id question }
    price
    size
    side
    taker
    maker
  }
}

Use the subgraph for:

  • Historical trade data without rate limits on a single query
  • Joining trade data with market metadata in one query (saves N+1 round trips)
  • Building custom analytics pipelines that need flexible filtering and sorting

Use the CLOB API instead for:

  • Real-time order book state (subgraph indexes confirmed trades, not the live book)
  • Placing or canceling orders (subgraph is read-only)
  • Sub-second latency needs

For most analytical work, subgraph + Dune cover 80% of cases without you ever touching CLOB authentication.

Common errors and gotchas

1. Token ID confusion. Each market has two outcome tokens (YES and NO), each with its own long numeric token_id. Querying /orderbook/{condition_id} returns nothing — you need the token_id from the market’s tokens array. Always start with /markets and pull the token_id from there.

2. Decimal precision. Polymarket prices are returned as strings (e.g., "0.5500") to preserve precision. Always parse with explicit precision handling — parseFloat("0.5500") === 0.55 works, but rounding errors creep in if you stack operations.

3. EIP-712 signature failures. If your order POSTs return 400 with signature errors, you’re almost certainly passing the wrong chain_id, the wrong order schema version, or signing with the wrong key. Use the official SDK to avoid this entirely; rolling your own signer is error-prone.

4. USDC vs. USDC.e on Polygon. Polygon has both native USDC (issued by Circle directly) and bridged USDC.e (legacy). Polymarket uses native USDC. If you try to fund or pay with USDC.e, transactions will fail or stall. Always verify the token contract address matches Polymarket’s expected USDC contract.

5. Rate-limit cliffs. Polymarket doesn’t always return a clean 429 — sometimes you get connection resets or slow responses instead. Implement timeouts (10 seconds is usually safe) and treat any non-200 as potentially rate-limited for backoff purposes.

6. WebSocket reconnection. Long-lived WebSocket connections drop. Implement automatic reconnection with re-subscription to your channels — Polymarket’s WebSocket does not persist subscriptions across disconnects.

7. Stale market metadata caching. Market metadata can change (rules clarifications, resolution-source updates) after a market is listed. Don’t cache /markets/{condition_id} responses for more than a few minutes if your application depends on rule text being current.

Where to go from here

If you’ve worked through the API surface here, the next steps depend on what you’re building:

  • Building a trading bot → start with paper trading; the API mechanics are the easy part, the strategy is the hard part. Read the pricing guide to ground your signal model.
  • Building a research tool → start with Dune dashboards and the Goldsky subgraph before writing custom indexers. Hit the CLOB only for real-time needs.
  • Just want to understand Polymarket better → read our Polymarket breakdown and is Polymarket safe in 2026? for the non-API context.

For Kalshi-side equivalents (Kalshi also offers an API with similar patterns), see our Kalshi breakdown — though Kalshi’s API documentation and ecosystem are smaller than Polymarket’s as of 2026.

What’s next for you

If you’ve read this far, you have enough to write your first Polymarket API client. Here’s where to go next:

FAQ

What is the Polymarket API?

Polymarket exposes two public APIs: the CLOB API (clob.polymarket.com) for trading and live order-book data, and the Gamma API (gamma-api.polymarket.com) for market metadata. Both are REST APIs; the CLOB API also has a WebSocket endpoint for real-time subscriptions. Polymarket also has a Polygon-based Goldsky subgraph and Dune Analytics views for analytical work.

Do I need an API key to use the Polymarket API?

For read-only endpoints (markets, order books, trades, price history), no — these are open to public IPs without authentication, rate-limited per IP. For authenticated endpoints (placing orders, querying your own positions and balances), yes — you generate an API key triplet from your Polymarket account.

What language SDKs does Polymarket support?

Official SDKs: py-clob-client (Python) and @polymarket/clob-client (TypeScript/JavaScript). Community SDKs exist in Rust, Go, and a few other languages — quality varies. For trading code in unsupported languages, you’ll need to implement EIP-712 signing yourself.

How do I authenticate with the Polymarket API?

Authentication uses a three-piece credential (API key + secret + passphrase) derived from your Polymarket account, signed via HMAC for general API requests and EIP-712 typed-data signatures for trade orders. The official SDKs handle the cryptography automatically.

What’s the difference between the CLOB API and the Gamma API?

CLOB is the primary trading API and exposes live order books, executed trades, and order placement. Gamma is the older API and primarily exposes market metadata (titles, descriptions, resolution rules). Most of Gamma has been migrated to CLOB; use Gamma for metadata that’s not yet on CLOB.

Does Polymarket have a WebSocket API?

Yes. The WebSocket endpoint is wss://ws-subscriptions-clob.polymarket.com/ws/. Subscribe to per-token channels by sending JSON after connection; receive order-book updates, trade events, and tick-size changes in real time.

What are the Polymarket API rate limits?

Limits aren’t formally documented in detail but follow predictable patterns: read-only public endpoints allow several requests per second per IP; authenticated trading endpoints have stricter per-key limits (roughly 1–5 orders per second sustained); bulk historical queries may throttle during heavy load. Implement exponential backoff with jitter.

How do I get historical price data?

The GET /prices-history endpoint returns time-series price history for a token at configurable granularity (1m, 1h, 1d). For deeper historical analytics, the Polymarket Goldsky subgraph and Dune Analytics dashboards are easier to work with.

Can I use the API for analytical research without trading?

Yes, and that’s often the best first project. Use /markets, /orderbook, /trades, and /prices-history — none require authentication. For larger analytical workloads, query the Goldsky subgraph or use community Dune dashboards.

What chain does Polymarket settle on?

Polygon. All Polymarket smart contracts, USDC settlement, and trade confirmations happen on the Polygon network. The CLOB API is an off-chain wrapper around on-chain state — for canonical data, you can also query the Polygon contracts directly via Polygonscan or a Polygon RPC.

What stablecoin does Polymarket use?

Native USDC on Polygon (issued by Circle). Not USDC.e (the legacy bridged version) and not USDT. If you’re funding programmatically, make sure your USDC is on the correct contract address — using the wrong USDC variant causes transaction failures.

Can I build a Polymarket trading bot legally as a US user?

Yes, assuming you’re a verified US user trading on the regulated Polymarket US (post-QCEX) infrastructure. The API itself is open to authenticated users regardless of trading approach. State availability restrictions still apply — sports markets specifically may be unavailable in some states. See are prediction markets legal for the full legal picture.

Stay ahead of the markets

Subscribe to the Bellwether weekly roundup — one short email each Sunday covering what’s moving on Kalshi, Polymarket, and Robinhood Event Contracts, plus the developer-side news worth your time.

One email per week · Unsubscribe anytime · We don’t share your email

We may earn a commission when you sign up. Learn more (FTC disclosure).

Claim my $50 Polymarket trading credit → use the sign-up link above · Deposit $20 · Generate my CLOB API keys.

Yes, claim my $50 bonus →

Trading event contracts involves risk of loss. You can lose your entire stake. Building or running an automated trading system carries additional operational risks; deploy only with appropriate testing and risk controls.

Where to go next

By Avery Chen · Markets Editor, Bellwether · Last updated: May 28, 2026 — we update this page when Polymarket’s API surface, authentication flow, or SDK ecosystem changes.

Next: Kalshi vs Polymarket — the complete 2026 comparison

Scroll to Top