# Can you arbitrage BTC options against 15-minute prediction markets? No, but the options smile is still useful. — retained record

> Retained reddit record from reddit:algotrading.

Canonical: https://highsignal.app/data/records/00f5f8a35a915047

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:algotrading)  published 2026-09-28 15:47 ingested 2026-09-29 02:44

[original source ↗](https://www.reddit.com/r/algotrading/comments/1wsi74s/can_you_arbitrage_btc_options_against_15minute/)

## retained text



```
The recent rise of prediction markets got me curious, especially the crypto ones. There are 15-minute and hourly BTC markets, and at the same time there's a 0-1DTE BTC options market. I started comparing the two, and what caught my attention was the depth both provide.

My first idea was arbitrage between the two venues. To do that, I'd need to replicate the binary payoff. The technical approach is to put on a call spread with the same expiry as the prediction market contract. The problem is the width of the spread. To replicate a binary payoff closely, you need a very small strike increment, and the option chain steps at $500, which is too wide.

Even if I made assumptions and heuristically adjusted for that gap, I'd still face settlement and pin risk that I couldn't match on the two venues. That makes it impractical to keep rebalancing the spread leg through to expiry.

The research did give me something useful, though. I could take the smile observed in the option chain and scale it down to price the short-dated 15-minute and hourly prediction markets. I started with the 15-minute market for quick iteration.

To make this work, I found that a naive sqrt-t scaling isn't enough. Over a 15-minute window, spot updates are noisy and discrete (bid-ask bounce, stale ticks), so short-horizon realized variance doesn't match what you'd get by scaling the implied vol down. On top of that, the binary's gamma blows up as expiry approaches with spot near the strike, so a small error in vol turns into a large error in fair value. Accounting for both made the model's probabilities noticeably better calibrated than the naive scaling, especially in the final 3 minutes.

[My own tooling charting out the model vs market price.](https://preview.redd.it/5ujg9zck7ash1.png?width=1608&format=png&auto=webp&s=71d558c2ebffe8a1342fc5bdcbc2af1c0435b50e)

One sanity check I cared about was avoiding circularity. The model is built only from the option chain smile and doesn't take the prediction market price as an input. So if it's truly independent, it should track the contract price closely when the option chain is quiet, since both are pricing the same thing with nothing new to disagree about, and diverge when the chain is moving. That's what I see.

[A quiet option chain, a model that hugs the market.](https://preview.redd.it/or50i3dk7ash1.png?width=1621&format=png&auto=webp&s=04f9c9ec8ea4949c01d0e767f4f23fcb383f726f)

With that pricing in place, I could start designing the execution engine.

My thesis is that the model leads the market and that retail prices the contract with more optimism than it should. That creates a mispricing, which is the edge. Entering to capture that gap was the easy part. The hard part was stop-loss and risk management once a position was open.

A naive stop-loss that watches the contract price is vulnerable to sudden spikes and to a taker crossing the spread. So I went back to the thesis: if the model really leads the market, it shouldn't react to a sudden spike in the contract price. I anchored the stop-loss to the model price instead, and the stop only becomes active once the model price falls below my entry price. This let me ride through most fake-outs.

[When the regime change, so is the loss. ](https://preview.redd.it/vrgcccdk7ash1.png?width=1608&format=png&auto=webp&s=3070e6b1fae65c6955b712ca54bb1043a8c02022)

The remaining gap was when the market truly flips, or when spot crosses the strike. In those cases, the entry thesis is broken. To partly address this, I compute the probability of spot touching the strike. When it's elevated, spot is close to the strike, and the outcome is too uncertain. Since I had already solved the vol/smile scaling, feeding it into a touch probability calculation was straightforward. I use it both to gate entries and to decide when the stop-loss becomes active.

[Adding touch probability providing new entry gate and stop-loss. ](https://preview.redd.it/jhul28dk7ash1.png?width=1620&format=png&auto=webp&s=574e5ab94461ddc36ac5effa4aae55ab06e766a2)

Treating this as an option pricing problem gave me a very different execution pipeline from the technical-analysis-based bots (RSI, Bollinger, MACD, VWAP, etc.).

Happy to discuss further.
```



document fetched 2026-09-29 00:45 · canonical https://reddit.com/r/algotrading/comments/1wsi74s/can_you_arbitrage_btc_options_against_15minute
