Polymarket US API (2026): Keys, Endpoints and Rate Limits

How is the Polymarket US API different from Polymarket's?

Polymarket US is the regulated version of Polymarket for US traders, explained in what Polymarket US is, and it runs on a separate stack. Nothing from the global Polymarket API carries over: there is no wallet, no CLOB credential and no Polygon transaction. Accounts hold US dollars at the exchange, and markets are addressed by slug.

If you also build on global Polymarket, the Polymarket API guide covers that side.

How do you get a Polymarket US API key?

1. Create an account in the Polymarket US app and complete identity verification. You need approval before you can trade or use the API.
2. Open the developer portal at polymarket.us/developer and sign in with the same method you used in the app: Apple, Google or email.
3. Create an API key. You get a Key ID and a Secret Key, and the secret is shown only once, so store it immediately.

Polymarket's documentation warns that switching between sign-in methods may break your API key access, and that you can email support if you need help or an invite code. Revoke a compromised key from the same portal.

How does authentication work?

Every authenticated request carries three headers:

Timestamps must be within 30 seconds of server time, so a drifting system clock is the first thing to check when signatures start failing. Without an SDK, signing looks like this, using the requests and cryptography packages:

import base64, os, time
import requests
from cryptography.hazmat.primitives.asymmetric import ed25519

key = ed25519.Ed25519PrivateKey.from_private_bytes(base64.b64decode(os.environ["POLYMARKET_SECRET_KEY"])[:32])

def headers(method, path):
    ts = str(int(time.time() * 1000))
    sig = base64.b64encode(key.sign(f"{ts}{method}{path}".encode())).decode()
    return {"X-PM-Access-Key": os.environ["POLYMARKET_KEY_ID"], "X-PM-Timestamp": ts,
            "X-PM-Signature": sig, "Content-Type": "application/json"}

path = "/v1/portfolio/positions"
print(requests.get("https://api.polymarket.us" + path, headers=headers("GET", path)).json())

What endpoints does the Polymarket US API have?

Order types are limit and market orders, with time-in-force options of day, good till cancel, good till date, immediate or cancel, and fill or kill. Public data is a plain request, for example GET https://gateway.polymarket.us/v1/markets/{slug}/bbo for one market's best bid and offer.

What are the Polymarket US API rate limits?

The Retail API allows 20 requests a second per API key across all authenticated endpoints, and public endpoints allow 20 requests a second per IP. Going over returns 429 Too Many Requests, and Polymarket's guidance is to wait at least a second and retry with exponential backoff.

One error looks like a rate limit and isn't. During periods of higher latency, Polymarket US rejects any new order or cancel-replace that has not been processed within 5 seconds, to protect you from a fill at a stale price. Those rejects carry the message Global Rate Limit Exceeded, but the documentation is explicit that they are a transient latency reject, not a signal to throttle. Plain cancels are never rejected this way.

The best way to stay under the limits is to stop polling: cache market metadata, and stream orders, positions, balances and books over WebSocket instead of requesting them repeatedly.

How do you stream live Polymarket US data?

The authenticated API has two WebSocket endpoints, and both use the same three signed headers in the handshake, signed over the timestamp, GET and the socket path:

• wss://api.polymarket.us/v1/ws/markets: market data with three subscription types, SUBSCRIPTION_TYPE_MARKET_DATA for the full book and market stats, SUBSCRIPTION_TYPE_MARKET_DATA_LITE for lightweight prices, and SUBSCRIPTION_TYPE_TRADE for trades.
• wss://api.polymarket.us/v1/ws/private: your own orders, positions and balance updates.

Which Polymarket US SDK should you use?

Polymarket publishes polymarket-us for Python 3.10+, with sync and async clients, and for TypeScript on Node.js 18+. Both sign requests for you. Public market data works without keys:

from polymarket_us import PolymarketUS

client = PolymarketUS()

markets = client.markets.list({"limit": 5, "active": True, "closed": False})["markets"]
for m in markets:
    bbo = client.markets.bbo(m["slug"])["marketData"]
    bid, ask = bbo.get("bestBid"), bbo.get("bestAsk")
    print(m["question"], bid and bid["value"], ask and ask["value"])

Pass your keys to trade. This is the order shape from Polymarket's quickstart, buying 100 contracts at 55 cents:

import os
from polymarket_us import PolymarketUS

client = PolymarketUS(key_id=os.environ["POLYMARKET_KEY_ID"], secret_key=os.environ["POLYMARKET_SECRET_KEY"])

order = client.orders.create({
    "marketSlug": "your-market-slug",
    "intent": "ORDER_INTENT_BUY_LONG",
    "type": "ORDER_TYPE_LIMIT",
    "price": {"value": "0.55", "currency": "USD"},
    "quantity": 100,
    "tif": "TIME_IN_FORCE_GOOD_TILL_CANCEL",
})

When is Polymarket US open for trading?

Nearly around the clock. There is a recurring weekly maintenance window every Thursday from 6:00 to 8:00 AM ET, and trading can be paused without notice for emergency maintenance. Daily reporting runs as of 5:00 PM ET each business day. Build your bot to treat a maintenance window as expected downtime rather than an error.

How do you use Polymarket US alongside other venues?

Polymarket US prices many of the same events as Kalshi, Polymarket and other venues, so comparing them usually means a second and third integration. The Predictefy API serves Polymarket US next to Polymarket, Kalshi and 15+ other venues on one normalized schema, so one call can read the same event everywhere it trades. You can also trade Polymarket US through Predictefy with your own Key ID and Secret Key, which Predictefy uses for the one request that needs them and never stores.

Frequently Asked Questions