Kalshi Paper Trading (2026): Demo Account vs Real Order Books

Does Kalshi have paper trading?

Kalshi's answer is a demo environment. It runs on mock funds at https://demo.kalshi.co/, with its own markets, accounts and API. For safety, credentials are not shared between the demo and production, so nothing you do there can touch a real balance.

Getting started takes three steps:

1. Create a demo account at demo.kalshi.co, following Kalshi's step-by-step tutorial in its API documentation.
2. Generate an API key inside the demo account. A production key will not work there, and a demo key will not work in production.
3. Point your client at the demo hosts: https://external-api.demo.kalshi.co/trade-api/v2 for REST and wss://external-api-ws.demo.kalshi.co/trade-api/ws/v2 for WebSockets.

from kalshi_python_sync import Configuration, KalshiClient

config = Configuration(host="https://external-api.demo.kalshi.co/trade-api/v2")
config.api_key_id = "YOUR_DEMO_API_KEY_ID"
with open("kalshi-demo-private-key.pem") as f:
    config.private_key_pem = f.read()

client = KalshiClient(config)
print(client.get_balance())

What is the Kalshi demo good for?

The demo is built for testing integrations, and it is excellent at that:

• Authentication. RSA-PSS request signing, key handling and clock issues all show up here first.
• The order lifecycle. Creating, amending and cancelling orders, and handling every rejection your code needs to survive.
• WebSockets. Subscriptions, message handling and reconnect logic.

It is less suited to judging a strategy. Kalshi's own documentation notes that the price and behaviour of demo markets may not reflect those in real markets, because the demo is a separate exchange with its own participants and its own liquidity. A strategy that fills beautifully in the demo has not yet met Kalshi's real order book.

How do you paper trade against Kalshi's real order books?

This is the gap Predictefy's paper trading fills. Every account gets a simulated USD balance and order routes that mirror the live ones, and orders are filled by a paper engine against the real order books Predictefy already streams, Kalshi's included. Nothing reaches the venue: no order is sent, no balance moves, and you do not need a Kalshi account at all.

You need one thing: a Predictefy API key with the trade scope, enabled by ticking "Allow this key to place trades" when you create it.

import { Predictefy } from '@predictefy/sdk';
import { randomUUID } from 'node:crypto';

const client = new Predictefy({ apiKey: process.env.PREDICTEFY_API_KEY });

const [market] = await client.kalshi.fetchMarkets({ query: 'fed', status: 'active', limit: 1 });
const yes = market.outcomes.find((o) => o.side === 'yes') ?? market.outcomes[0];

const order = await client.placePaperOrder({
  venue: 'kalshi',
  marketId: market.marketId,
  outcomeId: yes.outcomeId,
  side: 'buy',
  price: 0.4,
  size: 100,
  tif: 'GTC',
  idempotencyKey: randomUUID(),
});

const working = await client.listPaperOrders({ status: 'open' });
const portfolio = await client.paperPortfolio();

The Python client takes the same parameters:

import uuid
from predictefy import Predictefy

client = Predictefy(api_key="pk_live_YOUR_KEY")

order = client.place_paper_order(
    "kalshi", "MARKET_ID", "OUTCOME_ID", "buy", 0.40, 100,
    tif="GTC",
    idempotency_key=str(uuid.uuid4()),
)
positions = client.paper_positions()
portfolio = client.paper_portfolio()

How are paper fills decided?

Fills come from one rule set, shared by paper trading and Predictefy's backtester, and it is deliberately conservative. When the engine cannot be sure a fill would have happened, it does not fill:

• Marketable orders walk the book. A buy at or above the best ask takes each displayed level at that level's own price, stopping at your limit.
• Resting orders need a real cross. Once your order rests, the market has to trade strictly through your price, not just touch it.
• No order takes more than a quarter of a level on any single book update.
• Fees are charged on every fill from verified venue fee schedules, at that fill's price and size.
• Stale books are ignored. Nothing fills against a book older than 30 seconds; the order waits for a fresh one.
• Time in force behaves as it does live. GTC rests, IOC takes what it can and cancels the rest, and FOK fills completely or not at all.

The result is simulated PnL that errs on the cautious side, which is what you want before real money is involved. Positions are marked from Predictefy's catalog prices, and the simulation can be restarted at any time while keeping every past fill as history.

Kalshi demo or Predictefy paper trading?

Most traders use both: the demo to prove the plumbing, and paper trading on real books to prove the strategy. The same paper account also covers Polymarket paper trading, so a cross-venue idea can be tested end to end in one place.

How many paper orders can you run?

Paper trading is included on every Predictefy plan, and the only per-plan difference is how many orders can be open at once. Fills, cancels and account resets are unlimited.

How do you move from paper to live?

On Kalshi directly, switch your client to the production host and a production key, and place orders with the V2 order methods described in the Kalshi SDK guide. Through Predictefy, the same order parameters go to live execution, where orders are built server side, signed in your own process and relayed, so your keys never leave your control. For a complete bot built on these pieces, see how to build a Kalshi trading bot, and to understand what your orders will meet, the Kalshi order book API.

Frequently Asked Questions