← Back to Blog
Kalshi Bots & AutomationPrediction-Market StrategiesBacktesting & ResearchPolymarket & Arbitrage

Polymarket Backtesting Without Coding: Paper Runs, Data and Limits (2026)

Updated 10 min readRyan Bajollari

Test a Polymarket strategy without code in Turbine Studio. Compare Paper Runs, historical replay and live execution, fees, and what real backtest evidence shows.

To test a Polymarket strategy without writing code in Turbine Studio, describe it in plain English, review the YAML that Studio generates, and run it as a Paper Run where the venue is available to you. A Paper Run simulates orders against new market data; it is not a replay of past markets.

This guide covers that workflow, a step-by-step historical replay of 30 resolved Polymarket markets using public data, how a replay, a Paper Run, and live execution differ, and what evidence a real backtest should give you. For a completed historical replay, the backtesting engine publishes a recorded 30-day Kalshi backtest with its run ID, data coverage, fees, result, and CSV. For forward testing in more depth, see Paper trading.

Replay, Paper, or live: which one answers your question?

TestWhat it can showWhat it cannot show
Historical replay (backtest)How fixed rules would have behaved on recorded past dataFills the recorded data does not contain; results depend on coverage and the fill model
Paper RunEntries, exits, and skips on new market data, with simulated orders and balanceReal queue position, latency, or market impact
Live BotReal orders and fillsAnything without risking capital

How to test a Polymarket strategy without code

  1. Open Studio and choose regular Polymarket or Polymarket US, according to the venue available to you.
  2. Describe the market, entry, exit, size, and skip conditions. Compare the generated YAML with the Polymarket examples or the Polymarket US reference. Exit rules come first because the first matching rule wins.
  3. Start a Paper Run from the Paper tab and confirm the target venue and Bot. Regular Polymarket does not apply the deploy-dialog risk limits used by Kalshi and Polymarket US, so check the strategy's own limits.
  4. Inspect the simulated fills, skipped entries, and failures. Record the dates, markets, and number of decisions alongside the result.
  5. Treat a short Paper Run as a behavior check. A few days of simulated trades cannot estimate long-run profitability.

Location matters even for Paper mode. Studio blocks regular Polymarket deployment, including Paper Bots, from restricted locations, including the United States. US users should review the separate Polymarket US workflow. The venue documentation explains the restrictions; Paper mode is not a way around them.

How to backtest a Polymarket strategy on historical data

You can replay a fixed rule on resolved Polymarket markets with public data and a short script. We did this on October 20, 2026, for 30 "Bitcoin Up or Down" daily markets, outside Studio, with a Python script that reads Polymarket's public APIs and places no orders. Each step shows what we chose and why.

1. Fix the markets and dates before looking at results

Choose resolved markets and a date range first, so you cannot keep only the markets that worked. We used every "Bitcoin Up or Down" daily market that closed from September 21 to October 20, 2026. Each closes at 16:00 UTC (noon ET) and resolves by comparing Binance BTC/USDT one-minute closes at noon ET on consecutive days.

2. Download each market's metadata

Polymarket's events endpoint returns each market's outcome token IDs (clobTokenIds), close time (endDate), resolved prices (outcomePrices), and fee schedule (feeSchedule):

curl --fail --silent --show-error --max-time 20 --get \
  'https://gamma-api.polymarket.com/events' \
  --data-urlencode 'slug=bitcoin-up-or-down-on-october-20-2026'

3. Download price history for each outcome token

The price-history endpoint takes one outcome's token ID, a Unix-time window, and a sample spacing in minutes. This request returns one-minute samples of the October 20 market's Up token for the 30 minutes before our decision time:

curl --fail --silent --show-error --max-time 20 --get \
  'https://clob.polymarket.com/prices-history' \
  --data-urlencode 'market=108169775810626438610106712218476490480205150553401395236100090422445398973800' \
  --data-urlencode 'startTs=1792495800' \
  --data-urlencode 'endTs=1792497600' \
  --data-urlencode 'fidelity=1'

Keep the raw JSON. Each sample has a time t and a price p. The documentation does not say whether p is a midpoint or a trade, so treat it as a price, not a quote you could have filled.

4. Write down the rule, fill model, and fees

  • Rule: four hours before close, if exactly one outcome's last sample is from $0.60 to $0.85, buy 10 shares of it and hold to resolution. One entry per market.
  • Fill: the sample price plus $0.01, our assumed cost of crossing the spread.
  • Fees: Polymarket's taker fee is shares × fee rate × p × (1 − p). These markets list a 0.07 rate, so 10 shares at $0.75 pay about $0.13.
  • Settlement: $1 per winning share, $0 per losing share.

5. Skip markets with missing history

If an outcome has no sample in the 30 minutes before the decision time, skip that market and record why. Do not carry an older price forward. In this run every market had a sample within a minute of the decision time.

6. Report every market, including skips

EvidencePolymarket replay
TypeHistorical replay of Polymarket price samples; simulated orders, none sent to the exchange
Markets30 resolved "Bitcoin Up or Down" daily markets, closing September 21–October 20, 2026
RuleFour hours before close, buy 10 shares of an outcome priced $0.60–$0.85; hold to resolution
Fills and feesSample price plus $0.01; taker fee at each market's listed 0.07 rate
Activity14 entries and 16 skips with no outcome in the price band; 8 of 14 entries won
ResultCost $104.90, settlement $80.00, gross −$24.90, fees $1.77, net −$26.67
FilesMarket-by-market CSV · Python script

The rule bought favorites at an average of about $0.75, so it needed them to win about three times in four just to break even before fees. They won 8 of 14. Fourteen entries in one month are too few to judge the idea, and another month could reverse the sign. What the run does show is the method: a fixed market set, saved inputs, stated fill and fee assumptions, and a file anyone can re-run.

One-minute price samples carry no depth, so a $0.01 spread cost may understate what a larger order would pay. The fee rate comes from each market's metadata as read on October 20, 2026.

What a real backtest result should include

Whatever tool you use to backtest a Polymarket idea, ask for the same evidence as the replay above and our recorded Kalshi run. Our recorded Kalshi run took the documented rolling BTC 15-minute example, unchanged, through Studio's default 30-day backtest on October 19, 2026:

EvidenceRecorded Kalshi run
TypeHistorical replay of past Kalshi order books; no orders were sent to the exchange
Run ID915dc99858c87d19a20e1086beaf5d3e3666128bf1c4c31c6f6b1b326502ad90
Dates and coverageSeptember 19–October 19, 2026; coverage marked partial, with 2,733 markets simulated
Fees and fillsKalshi fee schedule per fill; simulated taker fills against the next executable recorded quote
Result2,456 simulated fills; gross −$64.87, fees $61.51, net −$126.38
FilesPublic run page and order-log CSV

A result without its dates, coverage, fee model, and a downloadable log is a claim, not evidence. A losing example is still useful: it shows what the rules did and what costs they paid.

Fees, fills, and live execution differ

Regular Polymarket Paper Bots pay no fees by default. Polymarket US Paper fees are also zero, and its unrealized_pnl field reads zero in Paper mode. Live fees are charged by the venue: consult Polymarket's current fee documentation. Do not equate fee-free Paper PnL with net live returns.

A Paper fill walks the live book at the moment of the order, but it has no real queue position, latency, or market impact. Live orders can rest or never fill. The product reference lists other live differences, including minimum order size, default cooldown, recovery exits, and position handling.

Historical prices are not historical order books

A price series can help study a signal, but it does not reconstruct the depth or bid/ask available for an order. Current books are also insufficient to establish what could have filled last month. Polymarket's official price history is useful research data; it is not, by itself, a fill-accurate backtest.

See the historical data guide for official price-history retrieval and the difference between source data and simulated trades.

Frequently Asked Questions

Can I backtest a Polymarket trading strategy without coding?

In Turbine, the no-code way to test a Polymarket strategy is a Paper Run: describe the rules in Studio, review the generated strategy, and run it on new market data where the venue is available to you. A Paper Run is not a historical backtest. If you can run a short script, you can replay a rule on resolved markets with Polymarket's public price history, as in the 30-market walkthrough above. For what a completed historical replay should show, see our recorded Kalshi run.

Can I paper trade Polymarket without writing code?

Yes, for supported strategies on a venue available to you. Describe the rules in Turbine Studio, review the generated strategy, and start a Paper Run. Regular Polymarket deployment, including Paper Bots, is subject to location restrictions that include the United States; Polymarket US is a separate venue with Paper support. Paper fills and fees differ from live execution.

What is the difference between a backtest, a Paper Run, and live trading?

A backtest replays past market data with simulated orders. A Paper Run simulates orders and a balance on new market data as it arrives. Live trading sends real orders to the exchange and risks capital. Only live trading shows actual fills.

Are Paper fees the same as live fees?

No. Regular Polymarket Paper Bots pay no fees by default, and Polymarket US Paper fees are zero. Live fees follow the venue's current rules. Compare those assumptions before interpreting a difference in PnL.

Can I backtest Kalshi–Polymarket arbitrage?

No. Turbine's cross-venue arbitrage workflow has no historical backtesting. It does have a Paper Run, which trades the strategy on live prices from the moment you start it, with each leg filling on its own. Separate single-venue results do not establish synchronized two-leg fills, settlement equivalence, or a cross-venue profit.

Review Studio plans and supported testing workflows.