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

Two alert products for Polymarket, two venue feeds for your own script — and why the price that triggers an alert is often a quote nobody traded at.

*https://predictionmarkets.tools/how-to/get-an-alert-when-a-price-moves · next to Trading Clients, SDKs & Bots*

**Answer:** For Polymarket, two products here do it without code: a phone app that pushes on a price threshold or a percentage move, and a Telegram and email service that watches a target price or cents moved inside a window. For Kalshi, or for a rule neither product offers, poll the public REST price or subscribe to a venue stream yourself. Decide first which price you mean, because midpoint, bid and last trade fire at different times.

## The approaches, in order

1. [Polymarket Alerts](https://predictionmarkets.tools/tools/polymarket-alerts.md) — Phone push on a price threshold or a percentage move, no login and no wallet; Polymarket only, with paid tiers whose limits are not published.
2. [PolyAlertHub](https://predictionmarkets.tools/tools/polyalerthub.md) — Telegram or email on a target price or on cents moved inside a time window; skips markets under 50,000 USD volume and 5-minute to 4-hour markets.
3. [Polymarket CLOB API](https://predictionmarkets.tools/tools/polymarket-clob-api.md) — The keyless market WebSocket for your own rule — a best_bid_ask event on every top-of-book change, and last_trade_price on every fill.
4. [Kalshi API](https://predictionmarkets.tools/tools/kalshi-api.md) — Poll the public market endpoint with no key, or open the signed WebSocket for a ticker channel that pushes whenever a price field changes.

*Ordered editorially. Paid placement does not affect this order.*

## 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:

```python
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](https://predictionmarkets.tools/tools/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](https://predictionmarkets.tools/tools/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](https://predictionmarkets.tools/tools/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](https://predictionmarkets.tools/tools/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](https://predictionmarkets.tools/how-to/stream-an-order-book) covers deltas,
snapshots and reconnects properly. If the alert keeps turning into an order, read
[what a bot cannot fix](https://predictionmarkets.tools/guides/what-a-bot-cannot-fix) before automating the second step, and
[placing an order from code](https://predictionmarkets.tools/how-to/place-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](https://predictionmarkets.tools/how-to/track-a-wallets-positions) is that page.

## FAQ

### Can I get a Kalshi price alert without writing code?

Not from any product in this catalogue that documents one. Both alert products here watch Polymarket only, and Kalshi's own card records no alert feature. Lychee counts alerts in its plan limits across both venues, but its pages do not say what an alert watches or how it is delivered. A short polling script against Kalshi's public market endpoint is the documented route.

### Why did my alert fire when nobody traded?

Because it was watching a quote. On Polymarket a price_change event fires when an order is placed or cancelled, not when one fills, and the price Polymarket displays is the midpoint of the bid and ask. One order placed or pulled on a thin book moves both. If you want only fills, trigger on last_trade_price.

### Is an alert a reason to trade?

No. An alert tells you a number crossed a line you drew. It says nothing about why, whether the move will last, or what the contract is worth — and on a thin book it may say only that one order arrived. This page is about getting the notification right, not about acting on it.

## Sources

1. [Real-time data streaming (market channel events and heartbeat)](https://github.com/Polymarket/agent-skills/blob/main/websocket.md) — Polymarket, read 2026-10-04
2. [Prices and Orderbook (how the displayed price is chosen)](https://docs.polymarket.com/concepts/prices-orderbook) — Polymarket, read 2026-10-04
3. [Prices and Order Books (midpoint, price, last-trade-price endpoints)](https://docs.polymarket.com/market-data/prices-order-books) — Polymarket, read 2026-10-04
4. [Get Market (GET /markets/{ticker})](https://docs.kalshi.com/api-reference/market/get-market) — Kalshi, read 2026-10-04
5. [Market Ticker (WebSocket channel)](https://docs.kalshi.com/websockets/market-ticker) — Kalshi, read 2026-10-04
6. [Rate Limits and Tiers](https://docs.kalshi.com/getting_started/rate_limits) — Kalshi, read 2026-10-04

*Last updated 2026-10-04. A reference page, corrected in place — not a dated post.*