Polymarket API Guide

curl "https://gamma-api.polymarket.com/markets?limit=5&active=true"

import httpx

resp = httpx.get("https://gamma-api.polymarket.com/markets", params={
    "limit": 5,
    "active": True,
})
markets = resp.json()

const resp = await fetch(
  "https://gamma-api.polymarket.com/markets?limit=5&active=true"
);
const markets = await resp.json();

TIMESTAMP=$(date +%s)
METHOD="GET"
PATH="/markets"
BODY=""
MESSAGE="${TIMESTAMP}${METHOD}${PATH}${BODY}"
SIGNATURE=$(echo -n "$MESSAGE" | openssl dgst -sha256 -hmac "$POLYMARKET_SECRET" | cut -d' ' -f2)

curl "https://clob.polymarket.com/markets" \
  -H "POLY-API-KEY: $POLYMARKET_API_KEY" \
  -H "POLY-TIMESTAMP: $TIMESTAMP" \
  -H "POLY-SIGNATURE: $SIGNATURE"

import hmac
import hashlib
import time
import httpx

API_KEY = "YOUR_POLYMARKET_API_KEY"
API_SECRET = "YOUR_POLYMARKET_SECRET"

def sign_request(method: str, path: str, body: str = "") -> dict:
    timestamp = str(int(time.time()))
    message = f"{timestamp}{method}{path}{body}"
    signature = hmac.new(
        API_SECRET.encode(),
        message.encode(),
        hashlib.sha256,
    ).hexdigest()

    return {
        "POLY-API-KEY": API_KEY,
        "POLY-TIMESTAMP": timestamp,
        "POLY-SIGNATURE": signature,
    }

# Example: get order book
headers = sign_request("GET", "/book")
resp = httpx.get("https://clob.polymarket.com/book", headers=headers, params={
    "token_id": "YOUR_TOKEN_ID",
})
book = resp.json()

const crypto = require("crypto");

const API_KEY = "YOUR_POLYMARKET_API_KEY";
const API_SECRET = "YOUR_POLYMARKET_SECRET";

function signRequest(method, path, body = "") {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const message = `${timestamp}${method}${path}${body}`;
  const signature = crypto
    .createHmac("sha256", API_SECRET)
    .update(message)
    .digest("hex");

  return {
    "POLY-API-KEY": API_KEY,
    "POLY-TIMESTAMP": timestamp,
    "POLY-SIGNATURE": signature,
  };
}

// Example: get order book
const headers = signRequest("GET", "/book");
const resp = await fetch(
  "https://clob.polymarket.com/book?token_id=YOUR_TOKEN_ID",
  { headers }
);
const book = await resp.json();

curl "https://gamma-api.polymarket.com/markets?limit=10&active=true&order=volume24hr&ascending=false"

import httpx

resp = httpx.get("https://gamma-api.polymarket.com/markets", params={
    "limit": 10,
    "active": True,
    "order": "volume24hr",
    "ascending": False,
})
markets = resp.json()

for m in markets:
    prices = m.get("outcomePrices", [])
    yes_price = prices[0] if prices else "N/A"
    print(f"{m['question']} | YES: {yes_price}")

const resp = await fetch(
  "https://gamma-api.polymarket.com/markets?" +
    new URLSearchParams({
      limit: "10",
      active: "true",
      order: "volume24hr",
      ascending: "false",
    })
);
const markets = await resp.json();

markets.forEach((m) => {
  const yesPrice = m.outcomePrices?.[0] ?? "N/A";
  console.log(`${m.question} | YES: ${yesPrice}`);
});

# See authentication section for $HEADERS
curl "https://clob.polymarket.com/book?token_id=YOUR_TOKEN_ID" \
  -H "POLY-API-KEY: $POLYMARKET_API_KEY" \
  -H "POLY-TIMESTAMP: $TIMESTAMP" \
  -H "POLY-SIGNATURE: $SIGNATURE"

import httpx

# Using the sign_request helper from the authentication section
headers = sign_request("GET", "/book")
resp = httpx.get("https://clob.polymarket.com/book", headers=headers, params={
    "token_id": "YOUR_TOKEN_ID",
})
book = resp.json()

print("Bids:")
for bid in book.get("bids", [])[:5]:
    print(f"  ${bid['price']} x {bid['size']}")

print("Asks:")
for ask in book.get("asks", [])[:5]:
    print(f"  ${ask['price']} x {ask['size']}")

// Using the signRequest helper from the authentication section
const headers = signRequest("GET", "/book");
const resp = await fetch(
  "https://clob.polymarket.com/book?token_id=YOUR_TOKEN_ID",
  { headers }
);
const book = await resp.json();

console.log("Bids:");
book.bids?.slice(0, 5).forEach((b) => {
  console.log(`  $${b.price} x ${b.size}`);
});

# List Polymarket markets
curl "https://api.rekko.ai/v1/markets?source=polymarket&limit=5" \
  -H "Authorization: Bearer YOUR_REKKO_API_KEY"

# Trigger analysis
curl -X POST "https://api.rekko.ai/v1/markets/polymarket/0xabc123.../analyze" \
  -H "Authorization: Bearer YOUR_REKKO_API_KEY"

# Get completed analysis (poll status first, then retrieve)
curl "https://api.rekko.ai/v1/markets/polymarket/0xabc123.../analysis" \
  -H "Authorization: Bearer YOUR_REKKO_API_KEY"

# Check for cross-platform arbitrage
curl "https://api.rekko.ai/v1/arbitrage?min_spread=0.02" \
  -H "Authorization: Bearer YOUR_REKKO_API_KEY"

import time
import httpx

rekko = httpx.Client(
    base_url="https://api.rekko.ai/v1",
    headers={"Authorization": "Bearer YOUR_REKKO_API_KEY"},
)

# 1. Browse Polymarket markets (normalized format, no HMAC needed)
markets = rekko.get("/markets", params={
    "source": "polymarket",
    "limit": 5,
}).json()

for m in markets:
    print(f"{m['title']} | YES: {m['yes_price']} | Vol: ${m['volume_24h']:,.0f}")

# 2. Pick the highest-volume market and analyze it
market = markets[0]
resp = rekko.post(f"/markets/polymarket/{market['market_id']}/analyze")
analysis_id = resp.json()["analysis_id"]

# 3. Poll until analysis completes
while True:
    status = rekko.get(
        f"/markets/polymarket/{market['market_id']}/analyze/{analysis_id}/status"
    ).json()
    if status["status"] == "complete":
        break
    if status["status"] == "error":
        raise Exception(status.get("error_message", "Analysis failed"))
    time.sleep(5)

# 4. Retrieve the full analysis with causal decomposition
analysis = rekko.get(
    f"/markets/polymarket/{market['market_id']}/analysis",
    params={"expand": "causal,scenarios"},
).json()

print(f"\nMarket: {market['title']}")
print(f"Market price: {market['yes_price']}")
print(f"AI probability: {analysis['probability']}")
print(f"Edge: {analysis['edge']}")
print(f"Recommendation: {analysis['recommendation']}")

# 5. Check for cross-platform arbitrage
arbs = rekko.get("/arbitrage", params={"min_spread": 0.02}).json()
for opp in arbs["opportunities"]:
    print(f"\n{opp['event']}")
    print(f"  Spread: {opp['spread_pct']:.1f}%")
    print(f"  Cheaper on: {opp['cheaper_on']}")

const base = "https://api.rekko.ai/v1";
const headers = { Authorization: "Bearer YOUR_REKKO_API_KEY" };

// 1. Browse Polymarket markets (normalized format)
const marketsResp = await fetch(
  `${base}/markets?source=polymarket&limit=5`,
  { headers }
);
const markets = await marketsResp.json();

markets.forEach((m) => {
  console.log(
    `${m.title} | YES: ${m.yes_price} | Vol: $${m.volume_24h.toLocaleString()}`
  );
});

// 2. Analyze the top market
const market = markets[0];
const trigger = await fetch(
  `${base}/markets/polymarket/${market.market_id}/analyze`,
  { method: "POST", headers }
);
const { analysis_id } = await trigger.json();

// 3. Poll until complete
let status;
do {
  await new Promise((r) => setTimeout(r, 5000));
  const poll = await fetch(
    `${base}/markets/polymarket/${market.market_id}/analyze/${analysis_id}/status`,
    { headers }
  );
  status = await poll.json();
} while (status.status !== "complete");

// 4. Get the analysis
const analysis = await fetch(
  `${base}/markets/polymarket/${market.market_id}/analysis?expand=causal,scenarios`,
  { headers }
).then((r) => r.json());

console.log(`\nAI probability: ${analysis.probability}`);
console.log(`Edge: ${analysis.edge}`);
console.log(`Recommendation: ${analysis.recommendation}`);

// 5. Check for cross-platform arbitrage
const arbs = await fetch(`${base}/arbitrage?min_spread=0.02`, {
  headers,
}).then((r) => r.json());

arbs.opportunities.forEach((opp) => {
  console.log(`\n${opp.event} | Spread: ${opp.spread_pct}% | Cheaper on: ${opp.cheaper_on}`);
});