How to Trade News on Prediction Markets

News trading on prediction markets is a race. A headline drops, the true probability of some contract jumps, and the order book has not caught up yet. Your edge is the seconds between the world learning something and the market fully pricing it. That window is closing as the venues grow. Combined monthly trading volume on Kalshi and Polymarket has scaled fast, and more volume means faster repricing and tighter competition for the same edge.

This is a workflow, not a pitch. It covers where the edge actually comes from, how to build a reaction loop, and the failure mode that quietly eats event-driven traders alive: trading into resolution.

Where the edge actually is

A prediction market contract pays out $1 if the outcome happens and $0 if it does not, so the price is a live probability estimate. On Kalshi, every market pays $1.00 if the event occurs and $0.00 if it does not, and the current price reflects the crowd's implied probability. When news changes the true probability, the price should move. Your job is to move first, or to move better.

There are three distinct edges, and they are not equally durable:

• Speed: you see and act on a public headline before the book reprices. This is the pure latency game and it decays as venues get faster and more crowded.
• Interpretation: the news is out, but the market is mispricing what it means (ambiguous wording, a partial report, a number that beats or misses a threshold). Slower, more durable, harder to automate.
• Access to structure: you understand the exact resolution criteria better than the crowd, so a headline that looks decisive to others does not actually resolve the contract. This edge lives entirely in the contract terms.

One caution before you build anything. Prediction markets reward whoever gets information first, and that has drawn scrutiny. A Bloomberg review looked at 34,000 transactions flagged as potential insider trades on Polymarket's global exchange between August 2025 and June 2026. Trading faster on public news is fair game. Trading on material non-public information is a different thing entirely, and it is exactly what regulators and the venues are now watching.

The reaction loop

Every news-trading setup is the same loop: ingest a signal, map it to a fair probability, compare that to the live book, and fire an order if the gap clears your threshold. The parts that matter are latency and discipline, not cleverness.

On the data side, poll-based REST is too slow for this. Kalshi's own developer team put it bluntly: order book data used to require polling the REST API repeatedly, and even then it was not guaranteed to be fresh. Use the streaming feed. Kalshi's WebSocket API streams real-time order book, ticker, and fill updates with low latency, and you maintain a persistent connection to cut authentication overhead. Polymarket settles on-chain but exposes similar streaming market data. Keep one persistent socket per venue and reconstruct the book locally from snapshot plus deltas.

On the signal side, your latency budget is the sum of: source-to-you (news feed lag), you-to-decision (parsing plus fair-value calc), and decision-to-fill (order round trip). Optimize the biggest term first. For most retail setups the news feed is the bottleneck, not the exchange.

A minimal loop looks like this. Note the risk gate is not optional, it is the whole point of running unattended.

import banger

class NewsReact(banger.Strategy):
    def on_signal(self, event):
        # event: a parsed headline mapped to a market + fair prob
        book = self.book(event.ticker)
        fair = event.fair_prob            # your estimate, 0..1
        ask  = book.best_ask              # cost to buy YES now

        edge = fair - ask
        if edge > self.params.min_edge:   # e.g. 0.04
            self.buy(event.ticker,
                     limit=ask + 0.01,    # cross a little, don't chase
                     size=self.size_for(event.ticker))

    def size_for(self, ticker):
        # respect per-trade cap and liquidity at top of book
        return min(self.params.per_trade_cap,
                   self.book(ticker).ask_depth)

Two rules baked into that snippet. Cross the spread by a fixed tick instead of chasing a moving book, and size to the depth actually resting at the top of the book. Thin markets punish size: in low-liquidity contracts, spreads are wide and prices move fast on a single order. If your fill moves the price past your fair value, you have traded away your own edge.

Paper trade the loop before it touches money

Latency strategies fail in ways backtests hide: your fair-value map is wrong, your fills are worse than the top-of-book you saw, or your signal fires on noise. Run the strategy against the live order book in paper mode first so you get realistic repricing and fill behavior without capital at risk. This is where Banger fits: you write a banger.Strategy, run banger run strategy.py --paper against the live book, and only promote it to real orders once the paper P&L and fill quality hold up. Banger never custodies funds. You bring your own venue keys, and the risk envelope (per-trade cap, daily loss stop, max open positions, kill switch) is declared up front, not bolted on after a bad night.

If you automate directly against a venue API instead, the same discipline applies: the Kalshi API is key-signed and the key can only place and cancel orders within limits you set, it cannot withdraw funds. Generate the key, scope it, and be ready to revoke it.

The risk nobody prices: trading into resolution

Here is the failure mode. A headline hits, you buy YES at 0.90 because the outcome looks certain, and then the contract does not resolve YES. The problem was never the news. It was the resolution criteria.

Settlement risk is embedded at market creation, not at resolution. A contract must specify the exact authoritative source and how ambiguous cases are handled, and where those definitions are vague, disputes become likely. An election market that resolves on official certification behaves very differently from one that resolves on a media projection, even though the same headline moves both.

The two venues resolve differently, and it changes how you should trade the last mile. Kalshi is a CFTC-regulated designated contract market that determines each outcome from a pre-named authoritative source, and settlement typically occurs within a few hours after the outcome is determined. Polymarket uses UMA's Optimistic Oracle: anyone can propose an outcome by posting a bond, a challenge window opens, and if nobody disputes it the market settles. That uncontested window is approximately two hours, and a disputed resolution can stretch to 4 to 6 days total. Cancelled or voided events, delayed data releases, and disputed-but-certified results all have specific handling that the crowd frequently gets wrong.

Practical rules for the endgame:

• Read the resolution rules before you trade, not after. Polymarket's own docs say every market has pre-defined rules for the resolution source, end date, and edge cases, and to always read them first.
• The closer to resolution, the smaller the edge and the larger the tail. A contract at 0.96 has 4 cents of upside and 96 cents of downside if you are wrong about the criteria.
• Price in the settlement delay. Capital locked in a two-hour-plus dispute window is capital you cannot redeploy on the next headline.
• When the resolution source is ambiguous, the news does not resolve the contract. That gap is either your edge or your trap, depending on which side of it you understood first.

News trading rewards speed, but it is won on interpretation and lost on resolution. Build the fast loop, then spend most of your effort on the two things the latency game cannot give you: a fair-value map you trust, and a genuine read of the contract terms.