Kalshi API Guide

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

# Load your private key once at startup
with open("kalshi_private_key.pem", "rb") as f:
    private_key = serialization.load_pem_private_key(f.read(), password=None)

API_KEY_ID = "YOUR_KALSHI_API_KEY_ID"
BASE_URL = "https://trading-api.kalshi.com"


def kalshi_auth_headers(method: str, path: str) -> dict:
    """Build signed headers for a Kalshi API request."""
    timestamp = str(int(time.time() * 1000))
    message = f"{timestamp}{method}{path}".encode()

    signature = private_key.sign(
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH,
        ),
        hashes.SHA256(),
    )

    return {
        "KALSHI-ACCESS-KEY": API_KEY_ID,
        "KALSHI-ACCESS-TIMESTAMP": timestamp,
        "KALSHI-ACCESS-SIGNATURE": base64.b64encode(signature).decode(),
        "Content-Type": "application/json",
    }


# Example: list open markets
path = "/trade-api/v2/markets"
resp = httpx.get(
    f"{BASE_URL}{path}",
    headers=kalshi_auth_headers("GET", path),
    params={"limit": 10, "status": "open"},
)
print(resp.json())

const crypto = require("crypto");
const fs = require("fs");

const privateKey = fs.readFileSync("kalshi_private_key.pem", "utf8");
const API_KEY_ID = "YOUR_KALSHI_API_KEY_ID";
const BASE_URL = "https://trading-api.kalshi.com";

function kalshiAuthHeaders(method, path) {
  const timestamp = Date.now().toString();
  const message = `${timestamp}${method}${path}`;

  const signature = crypto.sign("sha256", Buffer.from(message), {
    key: privateKey,
    padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
    saltLength: crypto.constants.RSA_PSS_SALTLEN_MAX_HASH,
  });

  return {
    "KALSHI-ACCESS-KEY": API_KEY_ID,
    "KALSHI-ACCESS-TIMESTAMP": timestamp,
    "KALSHI-ACCESS-SIGNATURE": signature.toString("base64"),
    "Content-Type": "application/json",
  };
}

// Example: list open markets
const path = "/trade-api/v2/markets";
const resp = await fetch(`${BASE_URL}${path}?limit=10&status=open`, {
  headers: kalshiAuthHeaders("GET", path),
});
const data = await resp.json();
console.log(data);

# RSA-PSS signing is not practical in pure bash.
# Generate the signature in Python/Node, then pass it:
curl "https://trading-api.kalshi.com/trade-api/v2/markets?limit=10&status=open" \
  -H "KALSHI-ACCESS-KEY: YOUR_KALSHI_API_KEY_ID" \
  -H "KALSHI-ACCESS-TIMESTAMP: ${TIMESTAMP}" \
  -H "KALSHI-ACCESS-SIGNATURE: ${SIGNATURE}"

path = "/trade-api/v2/markets"
resp = httpx.get(
    f"{BASE_URL}{path}",
    headers=kalshi_auth_headers("GET", path),
    params={"limit": 20, "status": "open"},
)
data = resp.json()
for market in data["markets"]:
    print(f"{market['ticker']}  {market['title']}  YES: {market['yes_bid']}")
# Paginate: pass data["cursor"] in the next request

const path = "/trade-api/v2/markets";
const resp = await fetch(`${BASE_URL}${path}?limit=20&status=open`, {
  headers: kalshiAuthHeaders("GET", path),
});
const data = await resp.json();
data.markets.forEach((m) => console.log(`${m.ticker}  YES: ${m.yes_bid}`));

curl "https://trading-api.kalshi.com/trade-api/v2/markets?limit=20&status=open" \
  -H "KALSHI-ACCESS-KEY: YOUR_KALSHI_API_KEY_ID" \
  -H "KALSHI-ACCESS-TIMESTAMP: ${TIMESTAMP}" \
  -H "KALSHI-ACCESS-SIGNATURE: ${SIGNATURE}"

path = "/trade-api/v2/portfolio/orders"
order = {
    "ticker": "KXFED-26MAR19",
    "action": "buy",
    "side": "yes",
    "type": "limit",
    "count": 10,       # Number of contracts
    "yes_price": 62,   # Limit price in cents
}
resp = httpx.post(
    f"{BASE_URL}{path}",
    headers=kalshi_auth_headers("POST", path),
    json=order,
)
result = resp.json()["order"]
print(f"Order ID: {result['order_id']}")
print(f"Status: {result['status']}")

const path = "/trade-api/v2/portfolio/orders";
const order = {
  ticker: "KXFED-26MAR19",
  action: "buy",
  side: "yes",
  type: "limit",
  count: 10,
  yes_price: 62,
};
const resp = await fetch(`${BASE_URL}${path}`, {
  method: "POST",
  headers: kalshiAuthHeaders("POST", path),
  body: JSON.stringify(order),
});
const { order: result } = await resp.json();
console.log(`Order ID: ${result.order_id}`);
console.log(`Status: ${result.status}`);

curl -X POST "https://trading-api.kalshi.com/trade-api/v2/portfolio/orders" \
  -H "KALSHI-ACCESS-KEY: YOUR_KALSHI_API_KEY_ID" \
  -H "KALSHI-ACCESS-TIMESTAMP: ${TIMESTAMP}" \
  -H "KALSHI-ACCESS-SIGNATURE: ${SIGNATURE}" \
  -H "Content-Type: application/json" \
  -d '{
    "ticker": "KXFED-26MAR19",
    "action": "buy",
    "side": "yes",
    "type": "limit",
    "count": 10,
    "yes_price": 62
  }'

import httpx

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

# Fetch normalized market data
market = rekko.get("/markets/kalshi/KXFED-26MAR19").json()
print(f"Market: {market['title']}")
print(f"YES price: {market['yes_price']}")
print(f"Volume (24h): ${market['volume_24h']:,.0f}")

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

const resp = await fetch(
  `${rekko.base}/markets/kalshi/KXFED-26MAR19`,
  { headers: rekko.headers }
);
const market = await resp.json();
console.log(`Market: ${market.title}`);
console.log(`YES price: ${market.yes_price}`);

curl https://api.rekko.ai/v1/markets/kalshi/KXFED-26MAR19 \
  -H "Authorization: Bearer YOUR_API_KEY"

signal = rekko.post(
    "/signals",
    params={"wait": "true"},
    json={"platform": "kalshi", "market_id": "KXFED-26MAR19"},
).json()
print(f"Recommendation: {signal['recommendation']}")
print(f"Edge: {signal['edge']:+.1%}")
print(f"Kelly fraction: {signal['size_pct']:.1%} of bankroll")
print(f"Risk rating: {signal['risk_rating']}")

const signal = await fetch(`${rekko.base}/signals?wait=true`, {
  method: "POST",
  headers: { ...rekko.headers, "Content-Type": "application/json" },
  body: JSON.stringify({ platform: "kalshi", market_id: "KXFED-26MAR19" }),
}).then((r) => r.json());
console.log(`Recommendation: ${signal.recommendation}`);
console.log(`Edge: ${(signal.edge * 100).toFixed(1)}%`);

curl -X POST "https://api.rekko.ai/v1/signals?wait=true" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"platform": "kalshi", "market_id": "KXFED-26MAR19"}'