# Stock Trading Halts: Why a Stock Is Halted and When It Resumes (`scrapemint/stock-trading-halts-tracker`) Actor

Live US trading halts, keyless. Every halt carries the official reason spelled out instead of a bare code, the halt and resumption times, how long it has been frozen, and the last price move that triggered it. Filter by symbol, market or reason, or monitor for new halts only.

- **URL**: https://apify.com/scrapemint/stock-trading-halts-tracker.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 halt rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Stock Trading Halts: Why a Stock Is Halted and When It Resumes

A ticker freezes mid session and three questions follow immediately: why did it stop, is it still stopped, and what time does it come back.

The exchange publishes all three, as bare codes with no explanation. This turns that feed into rows a person can read, and adds the price move that caused the halt. No key, no login, no proxy.

### What you get

One row per halt:

| Field | Meaning |
| --- | --- |
| `symbol`, `companyName`, `market` | The halted security |
| `reasonCode` | The exchange code, e.g. `LUDP`, `T1`, `T12` |
| `reason`, `reasonDescription` | The official meaning of that code, spelled out |
| `reasonCategory` | `volatility`, `news`, `regulatory`, `etf`, `market_wide`, `ipo`, `delisting` |
| `status`, `isHalted` | `halted`, `resumption_scheduled` or `resumed` |
| `haltedAt`, `resumesAt`, `quotesResumeAt` | Real timestamps, converted from exchange time |
| `haltDurationMinutes` | How long the pause lasted |
| `haltedForMinutes`, `minutesUntilResumption` | How long it has been frozen, how long until it trades |
| `lastPrice`, `netChange`, `percentChange`, `volume`, `moveDirection` | The move behind the halt |

**Summary mode** returns one row per reason code: how many halts it caused, how many of those names are still frozen, how many symbols were affected, and which markets they trade on.

### Common uses

- **Live halt monitor.** Schedule it with `newOnly` and it returns only halts it has not reported before, so each run is a clean alert list.
- **Why is my stock halted.** Put your tickers in `symbols` and get the reason and the resumption time.
- **Still frozen.** Turn off `todayOnly` and turn on `onlyStillHalted` to list every stock halted in an earlier session that has never resumed. Most are regulatory holds, and some have been frozen for months.
- **Volatility scan.** Filter `reasonCodes` to `LUDP` and `M` for the pause list, which on a busy day is the fastest map of what is running.

### Example input

```json
{
  "mode": "halts",
  "todayOnly": true,
  "includeQuote": true
}
```

Monitor only the regulatory holds:

```json
{
  "todayOnly": false,
  "onlyStillHalted": true,
  "reasonCodes": ["T12", "H4", "H9", "H10", "H11"],
  "newOnly": true
}
```

### Two things worth knowing

**This is a live list, not an archive.** The source cannot be queried by date. It carries the current session plus every older halt that never resumed, so a history has to be collected by scheduling the actor with `newOnly` rather than requested after the fact.

**A halt with no resumption time is still halted.** Those rows arrive with an empty time against a populated date. They are reported as `status: "halted"` with no `resumesAt`, never as resumed, and the price move field stays empty rather than reading as zero when the exchange has not published one.

### Pricing

Pay per halt row, `$0.004`. The first 2 rows of every run are free. Note rows, including the one explaining a quiet market, are never charged.

Price lookups happen only for the rows actually returned, after every filter and the row cap, so a filtered run never pays for the whole feed.

### Related actors

- **US Stock Market Movers & Screener** for what is moving before it gets halted
- **Stock Options Scraper** for unusual option activity on the same names
- **Stock Analyst Ratings** and **Stock Earnings Estimates** for the catalysts behind news halts

# Actor input Schema

## `mode` (type: `string`):

halts = one row per halted stock with the reason and resumption times. summary = one row per reason code showing how many names it is holding.

## `todayOnly` (type: `boolean`):

On by default. Turn it off to also return halts from earlier sessions that have never resumed, some of them months old, which is how you find the stocks still frozen for regulatory reasons.

## `onlyStillHalted` (type: `boolean`):

Drop halts that have already resumed and keep only what is frozen right now or waiting on a scheduled resumption.

## `symbols` (type: `array`):

Watchlist filter, e.g. AAPL, GME. Empty returns every halted stock.

## `reasonCodes` (type: `array`):

Keep only these halt codes. LUDP and M are volatility pauses, T1 and T2 are news halts, T12 and H4 and H10 are regulatory. Empty returns every reason.

## `markets` (type: `array`):

Keep only these markets, e.g. NASDAQ, AMEX, NYSE Arca, Non NASDAQ. Matches on part of the name.

## `includeQuote` (type: `boolean`):

Look up the last price, net change, percent move and volume for each returned stock, which is what tells you whether it froze on the way up or the way down. Adds one request per returned row.

## `newOnly` (type: `boolean`):

Monitor mode. Remembers what it has already reported, so a scheduled run returns only halts it has not seen before. The first run returns everything.

## `maxRows` (type: `integer`):

Cap on rows returned. Controls total cost and, when price lookups are on, run time.

## Actor input object example

```json
{
  "mode": "halts",
  "todayOnly": true,
  "onlyStillHalted": false,
  "symbols": [],
  "reasonCodes": [],
  "markets": [],
  "includeQuote": true,
  "newOnly": false,
  "maxRows": 200
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "todayOnly": true,
    "includeQuote": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/stock-trading-halts-tracker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "todayOnly": True,
    "includeQuote": True,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/stock-trading-halts-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "todayOnly": true,
  "includeQuote": true
}' |
apify call scrapemint/stock-trading-halts-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapemint/stock-trading-halts-tracker"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/8Q9LgyQvXlDetr6Ek/builds/JkIKQkHO8DTCaNyfX/openapi.json