# Premarket Movers - Top Stock Gainers & Losers (`michael_b/premarket-movers-gainers-losers`) Actor

Today's top premarket movers: biggest US stock gainers and losers before the open, plus regular and after-hours movers. Each row has ticker, session % change, price, volume, gap, market cap, sector, float. Clean JSON for AI trading agents and LLM pipelines.

- **URL**: https://apify.com/michael\_b/premarket-movers-gainers-losers.md
- **Developed by:** [Michal Búci](https://apify.com/michael_b) (community)
- **Categories:** AI, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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/platform/actors/running/actors-in-store#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

## Premarket Movers - Top Stock Gainers & Losers

Answers the first question every trader and trading agent asks in the morning: **what's moving before the open?** Returns the top US stock gainers and losers for the premarket session - and the same for the regular session and after-hours - as clean, flat JSON rows ready for AI agents, LLM pipelines, and morning watchlists.

### What it does

One run returns up to `limit` gainers and `limit` losers for the chosen session, ranked by session % change. Every row includes the move (% and $), session price/volume/open/high/low, gap vs previous close, market cap, sector, industry, float, and relative volume.

Defaults are tuned so the list contains **real moves, not noise**: sub-$1 stocks, near-zero-volume prints, leveraged ETFs, and OTC pink sheets are filtered out unless you opt in.

### Sessions and timing

| Session | Data available (ET) | What `price` / `prevClose` mean |
|---------|--------------------|--------------------------------|
| `premarket` | from ~4:00 AM on trading days | latest premarket print / yesterday's close |
| `regular` | always (most recent trading day) | latest price / previous day's close |
| `afterhours` | from ~4:00 PM until next premarket | latest after-hours print / today's regular close |

Asking for a session that hasn't populated yet (e.g. after-hours at 9 AM) is handled gracefully: the actor pushes a single free `no_data` row explaining when that session populates, and charges nothing. If the session has data but your filters matched nothing, you get a free `filters_too_strict` row telling you which knobs to loosen.

On weekends and market holidays the columns hold the **last trading day's** data - check `scrapedAt` against the market calendar if your agent runs on a fixed schedule.

### Input

All fields are optional - the default run returns this morning's top 25 premarket gainers and 25 losers.

| Field | Default | Notes |
|-------|---------|-------|
| `session` | `premarket` | `premarket` / `regular` / `afterhours` |
| `direction` | `both` | `gainers` / `losers` / `both` |
| `limit` | `25` | per direction, max 100 |
| `minPrice` | `1` | whole USD, on the reference close |
| `minVolume` | `50000` | shares traded in the selected session |
| `minMarketCap` | `0` | set `1000000000` for large caps only |
| `includeEtfs` | `false` | leveraged ETFs dominate raw movers lists |
| `includeOtc` | `false` | pink sheets are thin and noisy |

### Output fields

| Field | Description |
|-------|-------------|
| `ticker`, `companyName` | who |
| `session`, `direction` | which session, `gainer` or `loser` |
| `changePercent` | the move - ranking key, vs previous session close |
| `price`, `changeAbs`, `sessionVolume` | latest session price, $ change, session-only volume |
| `prevClose`, `gapPercent` | reference close and open-gap vs it |
| `sessionOpen/High/Low` | session range |
| `marketCap`, `sector`, `industry` | company context |
| `relativeVolume`, `avgVolume10d`, `floatShares` | liquidity context - low float + heavy volume = volatile open |
| `exchange`, `symbolFull` | provenance; `symbolFull` is the stable dedup key |
| `sessionDate`, `scrapedAt` | the trading day (ET) the data is for, and when it was scraped. They differ e.g. for an after-hours run made after midnight, which returns the prior day's close |

### Pricing

Pay-per-event: one charge per mover row returned. A default morning briefing (25 gainers + 25 losers) costs a few cents. Meta rows (`no_data`, `filters_too_strict`) are always free.

### Use with AI agents (MCP)

This actor is built MCP-first - call it from Claude, ChatGPT, or any MCP-compatible agent via the [Apify MCP server](https://apify.com/apify/actors-mcp-server):

```bash
npx @apify/actors-mcp-server --tools michael_b/premarket-movers-gainers-losers
```

Typical agent flow for a morning briefing:

1. **This actor** → "what's moving premarket and by how much?"
2. **[finviz-ticker-news](https://apify.com/michael_b/finviz-ticker-news)** with the top tickers → "why is it moving?"
3. Cross-check with **[stock-earnings-calendar](https://apify.com/michael_b/stock-earnings-calendar)**, **[stock-analyst-ratings](https://apify.com/michael_b/stock-analyst-ratings)**, **[stock-insider-trading](https://apify.com/michael_b/stock-insider-trading)**, or **[stock-unusual-options-activity](https://apify.com/michael_b/stock-unusual-options-activity)** for the catalyst.

The `ticker` field feeds directly into all of them.

### Typical uses

- **Morning briefing agent** - scheduled run at 8:00 AM ET, joined with news per ticker
- **Gap scanner** - `gapPercent` + `floatShares` + `relativeVolume` for open plays
- **Large-cap monitor** - `minMarketCap: 1000000000` to catch big names moving on overnight news
- **After-hours earnings reaction tracker** - `session: afterhours` at 5:00 PM ET

# Actor input Schema

## `session` (type: `string`):

Which trading session to scan. Premarket data is available from ~4:00 AM ET on trading days; after-hours data from ~4:00 PM ET until the next premarket. Asking for a session that hasn't populated yet returns a free `no_data` row explaining the timing.

## `direction` (type: `string`):

Gainers, losers, or both. With 'both', the dataset contains up to `limit` gainers followed by up to `limit` losers; each row carries a `direction` field.

## `limit` (type: `integer`):

How many top movers to return per direction, ranked by session % change. 25 gainers + 25 losers is a readable morning briefing that fits comfortably in an LLM context window.

## `minPrice` (type: `integer`):

Minimum stock price in whole dollars, applied to the reference close (previous close during premarket, latest price intraday). A stock that CRASHES below this in the session still appears - the filter screens out stocks that were already sub-dollar. Set 0 to see everything.

## `minVolume` (type: `integer`):

Minimum shares traded IN THE SELECTED SESSION (premarket volume for premarket, etc.). Separates real moves from thin 200-share prints. Set 0 to disable.

## `minMarketCap` (type: `integer`):

Minimum market capitalization in USD. Set 1000000000 (1B) to only see large/mid caps moving, 0 (default) for no cap filter.

## `includeEtfs` (type: `boolean`):

Include ETFs and other funds. Off by default because leveraged ETFs (2x/3x products) otherwise dominate every movers list without carrying any single-stock signal.

## `includeOtc` (type: `boolean`):

Include OTC / pink-sheet listings. Off by default - OTC quotes are thin and noisy. NASDAQ/NYSE/AMEX/CBOE listings are included either way.

## Actor input object example

```json
{
  "session": "premarket",
  "direction": "both",
  "limit": 25,
  "minPrice": 1,
  "minVolume": 50000,
  "minMarketCap": 0,
  "includeEtfs": false,
  "includeOtc": false
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of top movers ranked by session % change. Includes free meta rows (no\_data / filters\_too\_strict) when a session hasn't populated yet or filters matched nothing.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("michael_b/premarket-movers-gainers-losers").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("michael_b/premarket-movers-gainers-losers").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call michael_b/premarket-movers-gainers-losers --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=michael_b/premarket-movers-gainers-losers",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/0LIFdRULKlhe5GfRo/builds/j5qpHBxkNBMDq65o0/openapi.json