Can machine learning actually beat Kalshi's Bitcoin markets?

Seven wins in a row sounds like a system. It could also just be a coin flip that landed heads seven times. That's the uncomfortable truth sitting at the center of every AI-powered trading experiment on Kalshi's Bitcoin markets, and it's exactly why so many people building these bots eventually stop and ask: is this actually working, or am I just watching variance play out in real time?

Kalshi's hourly and 15-minute Bitcoin markets have become a popular playground for anyone curious about whether machine learning can predict short-term price direction. The setup is deceptively simple: will Bitcoin be above or below a certain price when the window closes? But underneath that simplicity is a market that's already pricing in almost everything a basic model can see. If you're thinking about building your own version of this experiment, here's what actually matters.

What are Kalshi's Bitcoin markets, and why do people try to model them?

Kalshi is a CFTC-regulated exchange that lets you trade on the outcome of real-world events, including short-term Bitcoin price movements. You can check out Kalshi's Bitcoin markets directly, where contracts settle in windows as short as 15 minutes.

These crypto contracts ask a single yes-or-no question about where price will land relative to a target. As one market breakdown puts it, unlike traditional crypto trading, where investors buy and sell the underlying asset, 15-minute prediction markets revolve around a single question of whether Bitcoin will finish above or below a specific price when the market closes. That structure is what makes it so tempting to model: you're not trying to predict a continuous price, just a binary outcome over a short, fixed window.

The volume backs up how popular these markets have become. Event contracts for betting on Bitcoin's hour-by-hour price changes have seen $143 million in trading volume to date, according to reporting on Kalshi's crypto expansion. That's a lot of people trying to answer the same question you are.

Why is it so hard to find an actual edge?

Here's the part that trips people up. Kalshi's market price isn't some static number waiting for you to outsmart it — it moves continuously based on where Bitcoin's spot price sits relative to the strike, and it updates almost in real time. One of the biggest misconceptions about prediction markets is that the current price guarantees the result — imagine Bitcoin is trading at $64,354, while the target price is $64,260 and there are eight minutes remaining until settlement. That gap between "current price" and "guaranteed outcome" is exactly the space a model would need to exploit, and it's razor thin.

Each market also resets independently. Because new contracts open every fifteen minutes, every market stands on its own, and winning one contract has no impact on the next market that opens fifteen minutes later. That independence matters for anyone building a strategy — a hot streak in one window tells you nothing reliable about the next one. If your model wins seven times in a row, you don't actually know if that's skill or a lucky run until you've got a much bigger sample size behind it.

The honest answer is that most retail-level models aren't seeing anything the market hasn't already priced in. A basic model trained on recent price action and volume is looking at the same public data everyone else — including the market itself — already has access to. If Kalshi's price already reflects the probability distribution of where Bitcoin lands, a model needs a genuinely novel signal to beat it, not just a slightly different way of looking at the same numbers.

How do you actually build a Kalshi ML experiment?

If you want to test this yourself instead of just taking someone's word for it, the process breaks down into a few concrete steps. You'll need market data, a model, and a way to place trades — and Kalshi's API handles the first and third parts.

Start with Kalshi's official API documentation, which covers everything from authentication to market data and trade execution. This documentation covers the Kalshi Exchange API for real-time market data and trade execution, and by continuing to use or access Kalshi's API, you are agreeing to be bound to its Developer Agreement.

Here's the practical setup:

Pull market data without an API key first. Kalshi's Quick Start: Market Data guide walks through public endpoints. Kalshi provides several public endpoints that don't require API keys, allowing you to access market data directly from its production servers. This is the easiest way to start pulling historical prices for your Bitcoin markets before you write a single line of trading logic.
Generate API keys once you're ready to trade. According to Kalshi's API Keys documentation, each request to Kalshi's trading API needs to be signed with a private key, and headers must include the key ID, a timestamp, and a signature generated by signing a concatenation of the timestamp, HTTP method, and path. Keep that private key safe — Kalshi warns that for security reasons, it won't be stored or retrievable once generated.
Test in the demo environment before risking real money. Kalshi explicitly recommends this path. If you want to experiment with authenticated endpoints, you'll need API keys, and you may also want to sign up for a demo account to test without real funds.
Build your model on historical trade and candlestick data. Kalshi separates live and historical data access. Kalshi partitions exchange data into live and historical tiers, and historical data must be accessed via dedicated historical API endpoints. This is where you'd pull past hourly windows to backtest whatever signal you're testing — momentum, volume spikes, order book imbalance, whatever your hypothesis is.
Automate order placement. Once your model spits out a prediction, the same API handles execution. The Kalshi API offers comprehensive order management, letting you place, modify, and cancel orders programmatically across all markets.

If you'd rather see a working example instead of building from scratch, there are open-source projects that walk through this exact loop — pulling Kalshi Bitcoin market data, training a model, and placing trades automatically. Studying an existing repo's structure (how it handles authentication, data pipelines, and order logic) will save you hours versus starting from a blank file.

Should you try polymarket instead, or alongside Kalshi?

If you want to compare your model's predictions against a second market, Polymarket runs similar short-window crypto contracts. Some tools even track both platforms side by side. Kalshi runs crypto markets that settle every 15 minutes on whether a price finishes up or down, and Polymarket runs its own version of the same windows, with terminals tracking the live price against the target, what each platform thinks the odds are, and what it costs to take either side. Running your model against both markets simultaneously is actually a smart way to test whether any edge you find is real or just noise specific to one exchange's liquidity and pricing behavior.

What should you actually expect from an experiment like this?

Set your expectations correctly before you start. A short-term crypto prediction market is about as efficient as markets get — thousands of traders and algorithms are already watching the same price feed you are. Small edges do exist sometimes, in things like order book depth, momentary liquidity gaps, or subtle timing differences between when Kalshi's price updates and when the underlying spot price moves. But finding a durable, repeatable edge is a much higher bar than getting a good-looking win streak over one afternoon.

Treat this like what it actually is: an experiment in probability, data pipelines, and API automation, not a guaranteed income strategy. Track your results over hundreds of trades, not dozens, before you draw any conclusions about whether your model has real skill or you just got lucky during a favorable stretch of market conditions.

Build it, test it honestly, and let the sample size — not the streak — tell you the truth about whether your edge is real.