Polymarket vs Kalshi API: Beginner Tutorial (2025)

If you want to automate trades on prediction markets, Polymarket and Kalshi are the two most important platforms to understand — and both offer public APIs you can start using today. Polymarket is a decentralized crypto-based market running on Polygon, while Kalshi is a regulated US exchange offering federally legal event contracts. This guide walks you through both APIs from scratch, comparing authentication, endpoints, and practical use cases so you can start building in under an hour.

---

Why Use APIs for Prediction Market Trading?

Manual trading on prediction markets works fine when you're placing a handful of bets per week. But the moment you want to monitor dozens of markets simultaneously, react to price changes in real time, or run systematic strategies, you need programmatic access.

APIs give you:

• Real-time market data without refreshing a browser
• The ability to place and cancel orders automatically
• Historical data for backtesting strategies
• Integration with external signals (news feeds, sports APIs, financial data)

Platforms like PredictEngine are built on top of exactly this kind of API access — aggregating data, running models, and executing trades faster than any human could manually.

Whether you're building a simple price monitor or a full AI trading bot, understanding the raw API layer is essential. Let's start with the basics of each platform.

---

Polymarket API: How It Works

Polymarket operates on the Polygon blockchain, which means its API architecture is different from traditional financial APIs. There are actually two layers you interact with:

1. The CLOB (Central Limit Order Book) API — for placing and managing orders
2. The Gamma API — for fetching market metadata, prices, and outcomes

Polymarket Authentication

Polymarket uses API keys tied to an Ethereum-compatible wallet. Here's how to get started:

1. Create a wallet (MetaMask or similar) and fund it with USDC on Polygon
2. Visit clob.polymarket.com and generate API credentials
3. You'll receive an API key, secret, and passphrase
4. All authenticated requests use HMAC-SHA256 signing

A basic Python setup looks like this:

import requests
import hmac
import hashlib
import time

API_KEY = "your_api_key"
SECRET = "your_secret"
PASSPHRASE = "your_passphrase"

def get_headers(method, path, body=""):
    timestamp = str(int(time.time()))
    message = timestamp + method + path + body
    signature = hmac.new(SECRET.encode(), message.encode(), hashlib.sha256).hexdigest()
    return {
        "POLY-API-KEY": API_KEY,
        "POLY-SIGNATURE": signature,
        "POLY-TIMESTAMP": timestamp,
        "POLY-PASSPHRASE": PASSPHRASE
    }

Fetching Markets on Polymarket

The Gamma API (public, no auth required) is the easiest entry point:

response = requests.get("https://gamma-api.polymarket.com/markets?limit=20")
markets = response.json()

Each market object includes:

• conditionId — unique identifier
• question — the yes/no question text
• outcomePrices — current bid/ask prices (expressed as probabilities, e.g., 0.72 = 72%)
• volume — total trading volume in USD
• endDate — resolution date

Placing a Trade on Polymarket

Orders go through the CLOB API. You specify the token ID (YES or NO side), the price (0 to 1), and the size in USDC.

order = {
    "tokenId": "your_token_id",
    "price": 0.65,
    "size": 10,
    "side": "BUY",
    "type": "GTC"  # Good Till Cancelled
}

headers = get_headers("POST", "/order", str(order))
response = requests.post("https://clob.polymarket.com/order", json=order, headers=headers)

One important note: Polymarket orders are on-chain, so there's a small gas fee for each transaction, usually a fraction of a cent on Polygon.

---

Kalshi API: How It Works

Kalshi is a CFTC-regulated prediction market exchange based in the US. Its API is much closer to a traditional brokerage API — REST-based, JSON responses, and standard OAuth-style authentication.

Kalshi Authentication

Kalshi uses RSA key authentication for production and a simple email/password flow for the demo environment.

1. Create an account at kalshi.com
2. Navigate to Account Settings → API Access
3. Generate an RSA key pair and upload your public key
4. Use your private key to sign requests

from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
import base64

def sign_request(private_key_path, timestamp, method, path):
    with open(private_key_path, "rb") as f:
        private_key = serialization.load_pem_private_key(f.read(), password=None)
    
    message = f"{timestamp}{method}{path}".encode()
    signature = private_key.sign(message, padding.PKCS1v15(), hashes.SHA256())
    return base64.b64encode(signature).decode()

Fetching Markets on Kalshi

headers = {
    "KALSHI-ACCESS-KEY": "your_key_id",
    "KALSHI-ACCESS-TIMESTAMP": timestamp,
    "KALSHI-ACCESS-SIGNATURE": signature
}

response = requests.get(
    "https://trading-api.kalshi.com/trade-api/v2/markets",
    headers=headers,
    params={"limit": 20, "status": "open"}
)

Kalshi market objects include:

• ticker — e.g., INXD-23DEC31-T4500
• title — human-readable question
• yes_bid / yes_ask — prices in cents (50 = $0.50)
• volume — number of contracts traded
• close_time — expiration

Placing a Trade on Kalshi

order_payload = {
    "ticker": "INXD-23DEC31-T4500",
    "action": "buy",
    "side": "yes",
    "type": "limit",
    "count": 10,
    "yes_price": 65
}

response = requests.post(
    "https://trading-api.kalshi.com/trade-api/v2/portfolio/orders",
    json=order_payload,
    headers=headers
)

Unlike Polymarket, Kalshi settles in USD (not crypto) and is subject to standard US financial regulations, including position limits and KYC requirements.

---

Polymarket vs Kalshi API: Side-by-Side Comparison

Here's a direct comparison to help you decide where to start:

Feature	Polymarket	Kalshi
Regulation	Decentralized (no US regulation)	CFTC-regulated US exchange
Currency	USDC (crypto)	USD (fiat)
Auth Method	HMAC with wallet keys	RSA key signing
API Style	REST + blockchain interaction	Pure REST
Order Book	Central Limit Order Book (CLOB)	Central Limit Order Book
Gas Fees	Yes (tiny, ~$0.001)	No
US Residents	Restricted (geoblocked)	Fully available
Market Types	Crypto, politics, sports, misc	Politics, economics, weather, sports
Price Format	0.00–1.00 (probability)	1–99 (cents per contract)
Liquidity	Higher (especially politics)	Growing, especially for regulated users
Rate Limits	10 req/sec (public), 5 req/sec (private)	10 req/sec standard
WebSocket Support	Yes (price feeds)	Yes (order book updates)

For algorithmic traders, the biggest decision is usually about jurisdiction and currency. If you're a US resident who wants clean USD accounting, Kalshi is the straightforward choice. If you want higher liquidity on political markets and you're comfortable with crypto, Polymarket wins.

For strategies like those covered in our mean reversion strategies via API guide, both platforms work — but you'll need to account for Polymarket's decimal pricing vs. Kalshi's cents-based system.

---

Building Your First Dual-Platform Market Monitor

Let's put both APIs together in a simple script that monitors the same event across both platforms and flags pricing discrepancies (the foundation of arbitrage).

Step-by-Step: Price Monitor

1. Identify a shared market topic — e.g., "Will the Fed cut rates in 2025?"
2. Pull current prices from both APIs using the GET endpoints above
3. Normalize prices to the same format (convert Kalshi cents to 0–1 decimal)
4. Calculate the spread — if Polymarket shows 0.72 and Kalshi shows 0.68, that's a 4-point gap
5. Set a threshold — only flag gaps above 2–3 points (to account for transaction costs)
6. Log or alert when the threshold is crossed
7. Optionally auto-trade by buying the cheaper side and selling (or shorting) the expensive side

def normalize_kalshi_price(cents_price):
    return cents_price / 100

def check_spread(poly_price, kalshi_price, threshold=0.03):
    spread = abs(poly_price - normalize_kalshi_price(kalshi_price))
    if spread >= threshold:
        print(f"Arbitrage opportunity: {spread:.2%} spread detected")
    return spread

This is exactly the kind of logic that powers more advanced polymarket arbitrage strategies. Even a 2–3% edge, captured consistently across many markets, compounds into significant returns.

For a deeper dive into portfolio-level thinking with these strategies, the momentum trading in prediction markets guide covers position sizing and risk management that applies directly to API-based approaches.

---

Common Beginner Mistakes to Avoid

When you're first connecting to these APIs, a few mistakes will cost you time (and sometimes money):

On Polymarket:

• Forgetting to approve the USDC spend limit on-chain before placing orders
• Using mainnet credentials on testnet endpoints (or vice versa)
• Ignoring token ID — each YES/NO outcome has a different token ID, not just one per market
• Not handling the allowances check — if your wallet allowance is zero, orders silently fail

On Kalshi:

• Sending prices as decimals instead of integers (65 not 0.65)
• Missing the count field (number of contracts) and defaulting to 0
• Not refreshing auth tokens — Kalshi tokens expire and need renewal
• Exceeding position limits on regulated contracts (Kalshi enforces these strictly)

These issues mirror broader patterns described in our piece on common market making mistakes on prediction markets — most beginner errors are structural, not analytical.

Also worth reviewing: common mistakes in earnings surprise markets covers how data normalization errors (exactly like the cents vs. decimal issue) can silently destroy your edge.

---

Rate Limits, Costs, and Scaling Considerations

Both platforms impose rate limits that matter once you start running automated systems:

• Polymarket: Public endpoints allow ~10 requests/second; private (authenticated) endpoints are limited to ~5 requests/second. For high-frequency monitoring, use WebSocket subscriptions instead of polling.
• Kalshi: Standard accounts get 10 requests/second. Enterprise API access is available for institutional users with higher throughput needs.

Cost structure:

• Polymarket charges a trading fee of 0% to 2% depending on market and maker/taker status. Makers (limit orders that add liquidity) often pay 0%.
• Kalshi charges fees in the range of $0.03 per contract on most markets, plus potential exchange fees.

For context, if you're trading 100 contracts at $0.65 each on Kalshi ($65 notional), you're paying roughly $3 in fees — about 4.6% of capital. This makes small positions expensive; efficient API trading on Kalshi generally requires position sizes above $50 per trade to keep fees under 3%.

---

Frequently Asked Questions

Is Polymarket legal for US users?

Polymarket is technically geoblocked for US residents due to its unregulated status, though VPN usage is common. US residents who want a legally compliant option should use Kalshi, which is fully regulated by the CFTC and explicitly available to American traders.

Do I need crypto to use the Polymarket API?

Yes — Polymarket settles in USDC on the Polygon network. You'll need a funded Polygon wallet to place any trades. Funding typically requires buying USDC on a centralized exchange and bridging it to Polygon, which can take 10–30 minutes if you're doing it for the first time.

Can I use the same strategy on both platforms?

Most strategies — including momentum, mean reversion, and arbitrage — transfer between platforms conceptually. However, you'll need to adapt your code for the different authentication systems, price formats, and order schemas. Some traders run the same core logic with platform-specific adapters for each API.

How do I handle WebSockets for real-time data?

Both Polymarket and Kalshi support WebSocket connections for streaming order book updates and price changes. Polymarket's WebSocket endpoint is at wss://ws-subscriptions-clob.polymarket.com/ws/market; Kalshi's is at wss://trading-api.kalshi.com/trade-api/ws/v2. Subscribe to specific market channels to avoid receiving all market data at once.

What programming language works best for these APIs?

Python is the most common choice due to the availability of libraries like requests, cryptography, and web3.py. JavaScript/TypeScript also works well, especially for frontend dashboards. Kalshi has an unofficial Python SDK on GitHub that simplifies authentication significantly for beginners.

How much money do I need to start API trading on these platforms?

You can technically start with as little as $10–$20 on either platform, but realistic testing with meaningful position sizes typically requires $100–$500. Keep in mind Kalshi's per-contract fees make very small trades inefficient. For Polymarket, gas fees are negligible on Polygon, so even small USDC amounts work fine for testing.

---

Get Started with Smarter Prediction Market Trading

You now have everything you need to make your first API calls on both Polymarket and Kalshi — from authentication to order placement to spotting price discrepancies across platforms. The next step is putting these building blocks together into a systematic strategy that runs automatically.

PredictEngine is built for exactly this — combining real-time data from prediction markets with AI-driven signals and execution tools, so you can focus on strategy rather than infrastructure. Whether you're exploring swing trading prediction outcomes or want to explore our ready-to-deploy Polymarket bot, PredictEngine gives you the edge that manual traders simply can't match. Check out our pricing page to find the plan that fits your trading style, and start building smarter today.