How to get an alert when a prediction market's price moves

The short way

If the market is on Polymarket and the rule is "tell me when it crosses a number", install one of the two alert products below and set it there. If the market is on Kalshi, or the rule is something neither product offers, run a small loop against the venue's public price and send yourself the message.

Before either, write down which price you mean. Polymarket's own concept page says the price it displays is the midpoint of the bid and ask, unless the spread is wider than 0.10 dollars, in which case it shows the last traded price instead. So the number on the market page can switch definitions while you watch it, and an alert on "the price" inherits whichever definition its author picked.

A minimal Kalshi version needs no account at all, because GET /markets/{ticker} is public:

import time
import requests

URL = "https://external-api.kalshi.com/trade-api/v2/markets/YOUR_MARKET_TICKER"
LEVEL, REARM = 0.60, 0.57   # fire when the YES bid reaches 0.60; re-arm below 0.57
armed = True

while True:
    m = requests.get(URL, timeout=10).json()["market"]
    bid, ask = float(m["yes_bid_dollars"]), float(m["yes_ask_dollars"])
    if ask - bid <= 0.05:                     # ignore the reading when the book is too wide to mean much
        if armed and bid >= LEVEL:
            print(f"YES bid {bid:.4f}, ask {ask:.4f}")   # replace with your own notifier
            armed = False
        elif not armed and bid < REARM:
            armed = True
    time.sleep(30)

The re-arm level and the spread guard are the two lines that make it usable; without them, a price sitting on the line sends a message every thirty seconds, and an empty book sends one for nothing.

What the options are

Polymarket Alerts is a phone app that watches public Polymarket data and pushes a notification when something you chose happens: for a market, a price threshold or a percentage move, plus new comments and closing or resolving. There is no login and no wallet connection; settings sit on the vendor's servers against your phone's push token. The download is free and the App Store lists Hobby at 1.99 USD and Pro at 4.99 USD a month, without saying which alerts each tier unlocks. Its terms disclaim the timeliness of alerts outright.

PolyAlertHub delivers to Telegram, through its own bot to a DM, group or topic, and to email. Its price rules are a target price, or a number of cents moved inside a time window, and it states two exclusions for movement rules: markets from 5 minutes to 4 hours long, and markets under 50,000 USD of volume, are not watched. The free tier's quota is stated two ways — three alerts shared across rule types in the user guide, five price alerts in the older terms — and Pro at 9.99 USD a month raises it to 500 price alerts.

The Polymarket CLOB API is the feed for your own rule, and it needs no key. Subscribe on the market channel by outcome token id with custom_feature_enabled set to true and you get a best_bid_ask event — best bid, best ask, spread — whenever the top of the book changes, alongside last_trade_price on each fill. Send PING every ten seconds or the connection drops. For a slower loop, the REST /midpoint, /price and /last-trade-price endpoints each return a single decimal string.

The Kalshi API serves the polling version shown above with no credentials, returning yes_bid_dollars, yes_ask_dollars and last_price_dollars as fixed-point dollar strings. The push version is the ticker channel, which sends an update whenever any ticker field changes — but Kalshi's WebSocket handshake is signed even for public channels, so a live stream means an account and an API key.

Where this breaks

Polling misses what happens between polls. A 30-second loop sees the price at two instants and nothing in between; a spike that comes and goes inside that window never fires. Polling faster costs requests: Kalshi answers an over-limit call with a 429 and no Retry-After header, and Polymarket's per-IP limits delay requests rather than reject them, so a too-eager loop gets slower answers rather than an error. A WebSocket sees every change, but only while it is connected.

A reconnect is a blind spot nobody announces. Neither venue's stream documents a replay. If the connection drops, a cross that happened while you were away is simply gone, and your script will not fire on it when it comes back because the price is already past the line. On reconnect, read the current price once over REST and compare it with your rule before trusting the stream again.

On a thin book, a "move" is one order. A price_change on Polymarket fires when an order is placed or cancelled, not when anything trades. The midpoint moves when either side of the book moves, so a single resting order arriving or leaving can push it ten cents on a quiet market and back again a minute later. PolyAlertHub's 50,000 USD volume floor for movement rules draws the same line. Alert on the bid or ask you could actually trade at, require the spread to be narrow before a reading counts, or trigger on last_trade_price if only real fills matter to you.

"Price" is four different numbers. Bid, ask, midpoint and last trade differ, sometimes by a lot, and Polymarket's displayed price switches from midpoint to last trade when the spread passes 0.10 dollars. A last trade on a market that has not traded for hours is an old number that looks exactly like a current one. Name the field in the alert text, so the message says which number crossed.

Ticks change near the edges. Polymarket's streaming notes put a finer tick size on prices above 0.96 or below 0.04, and Kalshi assigns each market a price grid, some with sub-cent steps near the ends. A rule written as "alert at 0.97" can be stepped over rather than landed on, so compare with greater-than-or-equal rather than with an exact value.

Delivery is the vendor's, and neither promises it. Polymarket Alerts' terms disclaim accuracy, completeness and timeliness and say data "may be delayed, incomplete, or inaccurate"; PolyAlertHub's terms say access can be suspended if you block its Telegram bot or its email. A home-made script has the opposite problem: it alerts exactly as reliably as the machine it runs on stays awake.

If you outgrow this

If you find yourself keeping a local copy of the book to decide when to alert, you are building a stream consumer, and streaming an order book covers deltas, snapshots and reconnects properly. If the alert keeps turning into an order, read what a bot cannot fix before automating the second step, and placing an order from code for the mechanics. And if the move you care about is somebody else's trade rather than the price, that is wallet tracking, not a price alert — tracking a wallet's positions is that page.