Trading halts explained: LULD pauses, circuit breakers and halt reasons

A trading halt is a temporary stop in trading of a stock, ordered by the exchange where it is listed or by a regulator. While a US stock is halted, no trades in it execute anywhere. Halts give everyone time to absorb pending news or let a violent move cool. The common kinds are news halts, limit up-limit down (LULD) volatility pauses, regulatory halts and, rarely, market-wide circuit breakers.

This explainer covers each kind, how long they last, and how to detect them programmatically, the part brokerage glossaries skip. If you build on a stock API, halts are the reason a perfectly healthy feed can go silent on one symbol in the middle of the afternoon.

What is a trading halt? The main types

News halts are the most common single-stock halts people notice. A company about to announce a merger, a trial result or a regulatory decision asks its listing exchange to halt the stock so nobody trades on a leak. The news goes out, the market gets a few minutes to read it, and trading resumes, often at a very different price.

LULD: the five-minute volatility pause

Limit up-limit down is a guardrail around every stock's recent price. Each stock gets a band centred on its reference price, the average of its trades over the previous five minutes, and trades outside the band are not allowed. If buyers or sellers are stuck at the edge of the band for 15 seconds, the stock enters a five-minute trading pause, then reopens with an auction. If the auction cannot find a price, the pause is extended.

Market-wide circuit breakers

Circuit breakers are the whole-market version, and they key off one number: the decline of the US 500 large-cap benchmark from the previous day's close.

They are rare. Level 1 tripped four times in March 2020, on the 9th, 12th, 16th and 18th, the first market-wide halts under the current rules, and each time trading resumed after 15 minutes. A Level 1 or 2 drop reached at or after 3:25 p.m. ET does not halt anything; only Level 3 can stop the market that late.

Halt, quote-only, resume: the lifecycle

A halt is a sequence, not a single event. On the TickerLayer stream each step arrives as one frame on the stocks.status channel, and its status field says where the stock is:

{
  "type": "status",1
  "channel": "stocks.status",
  "asset": "stocks",
  "symbol": "US:KO",3
  "status": "halted",
  "reason": "news_pending",2
  "ts": 17435124000004
}

The reason values are a coarse classification produced by our aggregation layer, not raw exchange codes: volatility, market_wide, news_pending, news_released, information_requested, regulatory, corporate_action, operational and ipo. The split is the one a subscriber acts on. A volatility pause resumes in minutes; a regulatory halt may not resume this week. The channel carries only the halt lifecycle: no auction imbalances, price indications or short-sale restriction notices.

Detect halted stocks in code with stocks.status

Subscribe to stocks.status with explicit US symbols, or with US:* for every US listing when the market wildcard add-on is enabled on your account. Three properties of the channel shape the client:

• No snapshot. The channel never replays a status on subscribe, because a cached halt is a claim about the present that may no longer hold. The snapshot option has no effect here: you get the acknowledgement, then only events that happen after it.
• Silence is normal. Most symbols never halt on a given day. A quiet channel is not a broken one, so do not alert on it.
• Disconnects create doubt. A halt or a resume can happen while you are offline, and nothing replays it. After a reconnect, treat halted symbols as unknown until a live trade proves otherwise.

This client keeps a live list of halted stocks for a watchlist, which is also the most reliable way to answer "which stocks are halted today": build the list from the stream. It subscribes to trades as well, so a live print can clear a symbol whose status went stale during a disconnect. The WebSocket market data guide covers connecting and subscribing, and WebSocket reconnects the backoff logic.

import asyncio
import json
import os
import random
from datetime import datetime, timezone

import websockets  # pip install websockets (14 or newer)

URL = "wss://stream.tickerlayer.com/?apiKey=" + os.environ["TICKERLAYER_API_KEY"]
WATCHLIST = ["US:KO", "US:JPM", "US:DIS", "US:BA", "US:GE"]
NOT_TRADING = {"halted", "paused", "quoting"}

state = {}  # symbol -> last known status; "unknown" after a reconnect


def on_status(msg):
    reason = msg.get("reason", "unclassified")  # optional field: decode tolerantly
    when = datetime.fromtimestamp(msg["ts"] / 1000, timezone.utc)
    state[msg["symbol"]] = msg["status"]
    print(f"{when:%H:%M:%S} UTC  {msg['symbol']:<7} {msg['status']:<8} {reason}")
    stopped = sorted(s for s, v in state.items() if v in NOT_TRADING)
    print("  not trading now:", ", ".join(stopped) or "none")


async def stream():
    async with websockets.connect(URL, compression=None, open_timeout=10) as ws:
        ready = json.loads(await ws.recv())
        if ready.get("event") != "ready":
            raise RuntimeError(f"expected ready frame, got {ready}")
        await ws.send(json.dumps({
            "action": "subscribe",
            "channels": ["stocks.status", "stocks.trades"],
            "symbols": WATCHLIST,
        }))
        async for raw in ws:
            msg = json.loads(raw)
            if msg.get("type") == "status":
                on_status(msg)
            elif msg.get("type") == "trade" and not msg.get("snapshot"):
                if state.get(msg["symbol"]) == "unknown":
                    state[msg["symbol"]] = "resumed"  # a live print proves trading is on
            elif msg.get("type") in ("system", "error"):
                print("control:", msg)


async def main():
    backoff = 1.0
    while True:
        try:
            await stream()
        except (websockets.ConnectionClosed, OSError, asyncio.TimeoutError) as exc:
            # No snapshot on stocks.status: a halt or resume may have happened while away.
            for symbol, status in state.items():
                if status in NOT_TRADING:
                    state[symbol] = "unknown"
            print(f"disconnected ({exc!r}); reconnecting in {backoff:.0f}s")
        await asyncio.sleep(backoff + random.uniform(0, backoff / 2))
        backoff = min(backoff * 2, 30.0)


if __name__ == "__main__":
    asyncio.run(main())

control: {'type': 'system', 'event': 'subscribed', 'channels': ['stocks.status', 'stocks.trades'], 'symbols': ['US:BA', 'US:DIS', 'US:GE', 'US:JPM', 'US:KO']}

No halts hit the watchlist during that run, which is the normal case: the acknowledgement arrives, then nothing. When a status event does arrive, the client prints its UTC time, symbol, status and reason, followed by the current list of symbols that are not trading. Note the server sorted the symbols in the acknowledgement; match on content, not order.

What a halt looks like in your price data

If you consume only quotes and trades, a halt shows up as absence. The last trade stops updating and its ts grows old, quotes may freeze or disappear, and minute bars simply do not exist: stocks.agg publishes no bar for a minute without trades, so a halted stretch is a gap in the series, not a flat line. Then the stock reopens, often at a different price, and a naive chart draws a cliff. Halts in pre-market and after-hours trading look the same, on even thinner volume.