Stop Order vs Stop-Limit Order: How Each Fills

A stop order and a stop-limit order both rest inactive until the market touches a price you choose, and they part company the moment it does. A stop order turns into a market order and takes whatever price is available, however far that sits from your trigger. A stop-limit order turns into a limit order at a price you set, and it goes unfilled rather than trade below it. One favors getting the trade done, the other favors the price, and neither gives you both.

What is a stop order?

A stop order is an instruction left with your broker: when the stock prints at or through my stop price, send a market order. Until that print lands the order does nothing. It is not resting on an exchange book, no other trader sees it, and it supplies no liquidity at your price. Most retail stops sit on the broker's own systems and reach an exchange only after the trigger condition is met.

Once released it is a plain market order with no floor under it, taking the best offer and then the next until the size is done. In a deep, tight market that costs a penny. In a thin or fast one it can cost several percent. The difference between a market order and a limit order is the whole story of what happens after the trigger, since a stop inherits every property of the order it becomes.

What is a stop-limit order?

A stop-limit order carries two prices. The stop price is the trigger, and it works exactly as above. The limit price is the worst price you will accept once the order is live. When the trigger prints, your broker releases a limit order at that limit price instead of a market order.

From there it behaves like any limit order: it fills at your limit or better, and while the market sits below it, it waits. If the price never returns, the order runs out its time in force and expires with the position untouched. A limit set equal to the stop is the strictest version and the likeliest to miss. A limit set well under the stop is looser, closer to a stop order with a floor beneath it.

Stop order vs stop-limit order in a gap

Work one hypothetical. A stock closes at $50 and you leave a stop at $48. The next morning the first print is $41. The stop order fires at the open and fills near $41. Your $48 was never available, and the order never asked for it. A stop-limit at $48 with a $47.50 limit also fires at the open, then posts an offer to sell at $47.50 into a market trading at $41. Nothing fills, and you still hold the stock at $41 with a live order sitting six and a half dollars above the market.

A move that size is rare for a large-cap name. The small ones are routine, and a stop only needs the small kind to release. The panel below counts, for five household names over the five years of sessions ending July 2026, how often the opening print landed at least one percent and at least three percent under the prior close. Split dates are dropped from the comparison: a 10-for-1 split turns one share into ten and cuts the quoted price by about ninety percent, which is arithmetic rather than a gap. Why stocks gap overnight covers the overnight session itself.

WITH sessions AS
(
    SELECT
        ticker,
        date,
        toFloat64(open)  AS open_px,
        toFloat64(close) AS close_px,
        row_number() OVER (PARTITION BY ticker ORDER BY date)     AS session_n,
        row_number() OVER (PARTITION BY ticker ORDER BY date) + 1 AS next_session_n
    FROM global_markets.stocks_daily_aggs
    WHERE ticker IN ('AAPL', 'MSFT', 'NVDA', 'SPY', 'KO')
      AND date >= '2021-08-01'
      AND date <  '2026-08-01'
)
SELECT
    cur.ticker                                                              AS symbol,
    round(100 * countIf(cur.open_px <= prior.close_px * 0.99) / count(), 1) AS opened_1pct_lower_pct,
    round(100 * countIf(cur.open_px <= prior.close_px * 0.97) / count(), 1) AS opened_3pct_lower_pct
FROM sessions AS cur
INNER JOIN sessions AS prior
    ON cur.ticker = prior.ticker
   AND cur.session_n = prior.next_session_n
WHERE (cur.ticker, cur.date) NOT IN
(
    SELECT ticker, execution_date
    FROM global_markets.stocks_splits
)
GROUP BY symbol
ORDER BY opened_1pct_lower_pct DESC

Over that window, NVDA opened at least one percent under the prior close on 22.1% of sessions, and at least three percent under on 3.4%. At the quiet end of the panel, KO did it on 2.3%. A stop resting near the market lives one overnight session away from release.

Size is what separates the two order types, and the first half hour is where the difference gets expensive. The next panel pins the 8 largest downside gaps NVDA has opened with over the same five years. Each row carries two measurements: the opening print against the prior close, and the low of the first thirty minutes of regular trading against that opening print.

WITH sessions AS
(
    SELECT
        date,
        toFloat64(open)  AS open_px,
        toFloat64(close) AS close_px,
        row_number() OVER (ORDER BY date)     AS session_n,
        row_number() OVER (ORDER BY date) + 1 AS next_session_n
    FROM global_markets.stocks_daily_aggs
    WHERE ticker = 'NVDA'
      AND date >= '2021-08-01'
      AND date <  '2026-08-01'
),
gap_days AS
(
    SELECT
        cur.date                                           AS d,
        round(100 * (cur.open_px / prior.close_px - 1), 2) AS gap_pct
    FROM sessions AS cur
    INNER JOIN sessions AS prior ON cur.session_n = prior.next_session_n
    WHERE cur.date NOT IN
    (
        SELECT execution_date
        FROM global_markets.stocks_splits
        WHERE ticker = 'NVDA'
    )
    ORDER BY gap_pct ASC
    LIMIT 8
),
opening_30m AS
(
    SELECT
        toDate(toTimeZone(window_start, 'America/New_York')) AS d,
        argMin(toFloat64(open), window_start)                AS first_print,
        min(toFloat64(low))                                  AS low_30m
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker = 'NVDA'
      AND window_start >= '2021-08-01'
      AND window_start <  '2026-08-01'
      AND toDate(toTimeZone(window_start, 'America/New_York')) IN (SELECT d FROM gap_days)
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) >= 570
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) < 600
    GROUP BY d
)
SELECT
    toString(g.d)                                     AS session_date,
    g.gap_pct                                         AS open_vs_prior_close_pct,
    round(100 * (o.low_30m / o.first_print - 1), 2)   AS first_30m_low_vs_open_pct
FROM gap_days AS g
INNER JOIN opening_30m AS o ON o.d = g.d
ORDER BY g.d

On 2025-04-16, the most recent of them, the open measured -6.82% against the prior close, and the low of the opening half hour measured -0.19% against the open itself. The oldest row, 2022-02-24, opened at -6.13%. A stop order released into one of those mornings fills somewhere inside that band, and the holder picks none of it.

Does the stop-limit fill later in the day?

Sometimes. A limit that misses at the open is still working, and if the price climbs back before the order expires, it can fill. The question is how often it comes back the same day.

The panel below applies one fixed hypothetical to the same names: a stop two percent under the prior close, with the limit one percent under the stop. It keeps only sessions that opened below both prices, the case where the trigger fires at the open with the limit already out of reach, then asks whether the session high ever reached the limit price.

WITH sessions AS
(
    SELECT
        ticker,
        date,
        toFloat64(open)  AS open_px,
        toFloat64(high)  AS high_px,
        toFloat64(close) AS close_px,
        row_number() OVER (PARTITION BY ticker ORDER BY date)     AS session_n,
        row_number() OVER (PARTITION BY ticker ORDER BY date) + 1 AS next_session_n
    FROM global_markets.stocks_daily_aggs
    WHERE ticker IN ('AAPL', 'MSFT', 'NVDA', 'SPY', 'KO')
      AND date >= '2021-08-01'
      AND date <  '2026-08-01'
)
SELECT
    cur.ticker                                                                AS symbol,
    count()                                                                   AS gapped_through_sessions,
    round(100 * countIf(cur.high_px >= prior.close_px * 0.9702) / count(), 1) AS reached_limit_intraday_pct
FROM sessions AS cur
INNER JOIN sessions AS prior
    ON cur.ticker = prior.ticker
   AND cur.session_n = prior.next_session_n
WHERE cur.open_px < prior.close_px * 0.9702
  AND (cur.ticker, cur.date) NOT IN
  (
      SELECT ticker, execution_date
      FROM global_markets.stocks_splits
  )
GROUP BY symbol
ORDER BY reached_limit_intraday_pct DESC

KO traded back to the limit at some point in the same session on 100% of its 2 gap-through days, the highest share of the 5 names that had any. MSFT came back on 66.7%. Touching a price is not the same as filling at it: your order joins a queue there, and a brief tick through the level may clear only what sits ahead of you. For the longer version of that question, see whether stock gaps get filled.

What actually trips a stop

The trigger condition is narrower than an order ticket suggests. At most brokers a sell stop fires on a last-sale print at or below the stop price. The bid can sag through your level for a minute without a single trade there and leave the order dormant, and one small print can wake it up. Odd lots count at many brokers, so a 7-share trade at a stray price is enough.

Two conditions make that fragile. Quotes at the open sit at their widest of the day, a pattern why spreads widen at the open takes apart in detail. Reopenings after a trading halt look similar, with the first print landing far from the last one before the halt.

Timing matters as much as the level. The panel below measures how far a single one-minute bar travels, high to low, at each half hour of the session, in basis points. One basis point is a hundredth of a percent, so 50 bps is half a percent of the price.

SELECT
    formatDateTime(toStartOfInterval(toTimeZone(window_start, 'America/New_York'), INTERVAL 30 MINUTE), '%H:%i') AS et_time,
    round(avgIf(10000 * (toFloat64(high) - toFloat64(low)) / toFloat64(close), ticker = 'NVDA'), 1) AS nvda_range_bps,
    round(avgIf(10000 * (toFloat64(high) - toFloat64(low)) / toFloat64(close), ticker = 'SPY'), 1)  AS spy_range_bps
FROM global_markets.delayed_stocks_minute_aggs
WHERE ticker IN ('NVDA', 'SPY')
  AND window_start >= '2025-08-01'
  AND window_start <  '2026-08-01'
  AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
       + toMinute(toTimeZone(window_start, 'America/New_York'))) >= 570
  AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
       + toMinute(toTimeZone(window_start, 'America/New_York'))) < 960
GROUP BY et_time
HAVING countIf(ticker = 'NVDA') > 0
   AND countIf(ticker = 'SPY') > 0
ORDER BY et_time

For NVDA, the 09:30 bucket averages 28.5 bps of travel per minute against 10 bps in the 12:30 bucket. SPY, a much broader instrument, runs 7 bps at the open and 3.9 bps at the same midday hour. A stop that survived the night releases into the first of those buckets.

How time in force changes a stop

A stop carries a time in force like any other order. A day stop expires at the close and has to be entered again the next morning. A good-till-canceled stop persists across sessions, subject to whatever expiry your broker applies to resting orders. The move that fires a stop often happens overnight, exactly when yesterday's day order no longer exists. Order time in force explained walks through day orders, GTC, and the extended-hours variants.

Many brokers also evaluate stop triggers only during the regular session unless the order is marked for extended hours. A stock can trade five percent lower at 7 a.m. while the stop sits dormant until the open.

Trailing stops and stops on options

A trailing stop uses the same trigger logic with a moving reference. You set a distance in cents or percent, and the trigger follows the best price reached since entry, ratcheting one way and never the other. It comes as both a trailing stop order and a trailing stop-limit, and it inherits the same trade-off the moment it fires.

Options are the harder case. Option quotes start wider than stock quotes and stretch further in fast markets, and a contract's price moves with the underlying, with the clock, and with implied volatility, the future movement priced into the option. A stop on a contract can fire on one print in a market where the bid and the offer are dollars apart. Some brokers restrict stop types on options.

FAQ

Does a stop-loss order guarantee my price?

No. A stop order guarantees only that an order goes out once the trigger prints, and it fills at whatever the book offers, which after a gap can be well under the stop price. A stop-limit order guarantees the price and gives up the guarantee of filling at all.

Is a stop-limit order better than a stop order?

They answer different questions. A stop order treats the exit itself as the priority. A stop-limit treats the exit price as the priority and accepts that the position can stay open. The risk moves from price to completion rather than disappearing.

Can other traders see my stop order?

Not as a stop. A broker-held stop rests on the broker's systems, and nothing appears on any exchange book until the trigger releases it. What the market sees afterwards is an ordinary market or limit order.

What price triggers a stop order?

At most brokers a sell stop fires on a last-sale print at or below the stop price, and a buy stop on a print at or above it. Quote-based rules exist too, and a single odd-lot print can be enough. Your broker's order-handling disclosure states which rule applies to your account.

Every panel here carries the SQL that produced it. Swap the ticker or the gap threshold and the same question answers itself for the names you follow, in plain English, on the Strasmore terminal.