How Long a Market Order Takes to Fill

How long a market order takes to fill, on an actively traded US stock in regular hours, is normally a matter of milliseconds. The order leaves your app, clears the broker's risk checks, gets routed to a venue, and crosses with a quote that is already resting there. What you experience is longer than the match itself, since the confirmation has to travel back to your screen before the spinner stops.

A market order is an instruction to trade at the best price available right now rather than at a price you name. That single difference is what makes it fast and what makes the fill price uncertain, and market order vs limit order works through the trade-off.

How long a market order takes to fill, segment by segment

The round trip has five legs. Only the last two leave a public record.

1. Your app to the broker. The instruction crosses the ordinary internet to the broker's order gateway. Tens of milliseconds is normal, and it is the one leg a retail trader can influence.
2. Broker checks. Buying power and position limits are validated inside the broker's order system, which is sub-millisecond work.
3. Routing. A smart order router picks a destination: an exchange, or a wholesaler that pays the broker for retail order flow. Where those orders went is disclosed publicly in Rule 605 and 606 execution reports.
4. The match. At the venue, the order crosses with a resting quote. Matching engines work in microseconds.
5. The report back. The execution is written to your account and sent to the consolidated tape, and your screen updates after that.

Is a market order filled instantly?

Not instantly, but on a liquid name the wait has nothing to do with finding a counterparty. Somebody is nearly always quoting both sides. The panel below counts every print in a pinned half hour of one past session for five household names.

SELECT
    ticker                                                                  AS symbol,
    concat(formatDateTime(min(toTimeZone(sip_timestamp, 'America/New_York')),
                          '%b %e, %Y at %H:%i'), ' ET')                     AS et_window,
    count()                                                                 AS prints,
    round(1800.0 / count(), 4)                                              AS avg_seconds_between_prints
FROM global_markets.stocks_trades
WHERE ticker IN ('SPY', 'NVDA', 'AAPL', 'MSFT', 'KO')
  AND sip_timestamp >= toDateTime('2026-09-16 14:00:00', 'UTC')
  AND sip_timestamp <  toDateTime('2026-09-16 14:30:00', 'UTC')
GROUP BY ticker
ORDER BY prints DESC

Over the 30 minutes beginning Sep 16, 2026 at 10:00 ET, NVDA printed 190835 separate trades, one every 0.0094 seconds on average. Even the quietest of the five, KO, printed every 0.0781 seconds. An order arriving at any moment inside that window meets a two-sided quote, so the elapsed time comes from travel and handling rather than from waiting for a counterparty.

Which parts of the trip can you actually see?

Every print on the consolidated tape carries two clocks: the venue's own timestamp and the timestamp of the consolidated feed that published it. The gap between them is the reporting leg, segment five above, and it is the only piece of the elapsed time any member of the public can measure directly. Market data timestamps explained walks through the fields themselves.

SELECT
    ticker AS symbol,
    round(quantileDeterministic(0.5)(
        toFloat64(dateDiff('microsecond', participant_timestamp, sip_timestamp)),
        cityHash64(ticker, sequence_number)), 0)  AS median_report_microseconds,
    round(quantileDeterministic(0.95)(
        toFloat64(dateDiff('microsecond', participant_timestamp, sip_timestamp)),
        cityHash64(ticker, sequence_number)), 0)  AS p95_report_microseconds
FROM global_markets.stocks_trades
WHERE ticker IN ('SPY', 'NVDA', 'AAPL', 'MSFT', 'KO')
  AND sip_timestamp >= toDateTime('2026-09-16 14:00:00', 'UTC')
  AND sip_timestamp <  toDateTime('2026-09-16 14:30:00', 'UTC')
  AND participant_timestamp >  toDateTime('2026-09-16 00:00:00', 'UTC')
  AND participant_timestamp <= sip_timestamp
GROUP BY ticker
HAVING count() > 100
ORDER BY median_report_microseconds

In the same half hour, AAPL prints reached the consolidated feed a median of 458 microseconds after the venue stamped them, where a microsecond is a millionth of a second. The five names do not cluster. The slowest, KO, ran a median of 94509 microseconds, tens of milliseconds rather than a handful, and its 95th percentile sat at 501996 microseconds, in the hundreds of milliseconds. On that name the reporting leg is the largest piece of the trip an outsider can measure. Venues and trade reporting facilities stamp their own clocks and submit on their own schedules, so a tail like that describes the reporting path rather than the speed of the match.

What no outsider can see is the broker's internal clock from order receipt to routing decision, or the transit time of your specific packet. Your trade confirmation shows an execution time, which is the broker's record of segment four. The nearest public substitute for the earlier segments is a monthly statistic, and it lives in Rule 605.

How do I read execution speed in a Rule 605 report?

Rule 605 of Regulation NMS requires market centers to publish a monthly, machine-readable report on the orders they execute. The reports are organized into cells: one row per security, order type, and order size band. The long-standing size bands run 100 to 499 shares, 500 to 1,999, 2,000 to 4,999, and 5,000 to 9,999. The SEC's 2024 amendments add categories for odd lots and fractional shares and extend the reporting duty to larger broker-dealers.

Inside each cell, the speed field is the average time from order receipt at the market center to execution. Two readings matter. The clock starts when the market center receives the order, not when you tapped the button, which leaves your app-to-broker leg outside the number. And it averages many orders across a month, so it hides the tail; the amended reports publish time-to-execution percentiles alongside the average.

The neighbouring fields are what turn speed into execution quality: the count of covered orders, the share-weighted price improvement against the quote, the effective spread paid, and the realized spread measured minutes after the fill. A cell with 40 orders tells you far less than a cell with 400,000.

Filled is not settled, and neither is buying power

Four clocks run at different speeds, and several of the questions people ask about fill time are really about the later three.

• Filled, meaning executed: the moment the trade matches. Milliseconds. The shares are yours at that price, and the print hits the tape.
• Reflected in your app: the broker updates positions once the execution report comes back, usually a second or two, longer during a busy open.
• Buying power: in a cash account the proceeds of a sale become settled cash only at settlement, and many brokers extend purchasing power against pending proceeds right away, so the two figures can differ on screen for a day.
• Settled: US equities settle on T plus one business day, when shares and cash change hands at the clearing corporation.

A fill is final the instant it prints. A pending order can be cancelled; an executed one cannot, and the rare reversal afterwards is an exchange-level trade break under the clearly erroneous execution rules.

Does a faster fill mean a better fill?

No. Speed and price are separate axes, and for a retail-sized order the price axis is much larger. A fill in 20 milliseconds one penny worse than the national best bid and offer costs a 100-share order one dollar. A fill 200 milliseconds slower at the quote costs nothing. What the NBBO is sets out how that reference price gets built.

The scale of the price axis is the quoted spread, and it varies more than you might expect between names that all feel liquid.

SELECT
    ticker AS symbol,
    round(quantileDeterministic(0.5)(
        10000 * (toFloat64(ask_price) - toFloat64(bid_price))
              / ((toFloat64(ask_price) + toFloat64(bid_price)) / 2),
        cityHash64(ticker, sequence_number)), 2)  AS median_spread_bps,
    round(quantileDeterministic(0.9)(
        10000 * (toFloat64(ask_price) - toFloat64(bid_price))
              / ((toFloat64(ask_price) + toFloat64(bid_price)) / 2),
        cityHash64(ticker, sequence_number)), 2)  AS p90_spread_bps
FROM global_markets.cache_stocks_quotes
WHERE ticker IN ('SPY', 'NVDA', 'AAPL', 'MSFT', 'KO')
  AND sip_timestamp >= toDateTime('2026-09-16 14:00:00', 'UTC')
  AND sip_timestamp <  toDateTime('2026-09-16 14:10:00', 'UTC')
  AND bid_price > 0
  AND ask_price > bid_price
GROUP BY ticker
HAVING count() > 100
ORDER BY median_spread_bps DESC

In the first ten minutes of that window, the widest median quote of the five belonged to MSFT at 3.24 basis points, with a 90th percentile of 5.45. The tightest, SPY, held a median of 0.26 basis points. A basis point is one hundredth of a percentage point, so a 10 basis point spread on a $100 stock is 10 cents wide and crossing half of it costs 5 cents a share. No plausible millisecond difference is worth that, which is why Rule 605 pairs its speed field with price-improvement statistics.

When does it genuinely depend? Thin names and large orders

Two conditions change the answer. In a thin name, there may be no resting quote at a size that fills you, and the order waits for a counterparty to arrive. The panel below buckets every exchange-listed name by how many trades it printed in that same session.

SELECT
    multiIf(session_prints <    100, '1. under 100 prints',
            session_prints <   1000, '2. 100 to 999 prints',
            session_prints <  10000, '3. 1,000 to 9,999 prints',
            session_prints < 100000, '4. 10,000 to 99,999 prints',
                                     '5. 100,000 prints or more')  AS print_count_bucket,
    count()                                                        AS names,
    round(23400.0 / quantileDeterministic(0.5)(
        toFloat64(session_prints), cityHash64(ticker)), 1)          AS median_seconds_between_prints
FROM
(
    SELECT
        ticker,
        max(transactions) AS session_prints
    FROM global_markets.stocks_daily_aggs
    WHERE date = '2026-09-16'
      AND transactions > 0
      AND ifNull(otc, 0) = 0
      AND ticker NOT IN ('SPCX')
    GROUP BY ticker
)
GROUP BY print_count_bucket
ORDER BY print_count_bucket

3357 names printed fewer than 100 trades across the entire session, and the median name in that bucket went 731.2 seconds between prints. In the busiest bucket the median name printed every 0.2 seconds. A market order sent into the first group lands in a market that may update only a few times an hour, where the quote on your screen can be minutes old.

Size does the same thing to a liquid name. Displayed depth at the inside quote is often only a few hundred shares, so a larger order fills in pieces across price levels that print as separate trades milliseconds apart. That is visible to you after the fact: how to read the equity trade tape shows how to match your own execution to the public record by time and size.

FAQ

How long does a market order take to fill?

On a liquid US stock in regular hours, the match happens in milliseconds and the confirmation normally reaches your screen inside a second or two. A longer wait usually points at the stock's liquidity or at a trading halt rather than at your broker.

Is a market order guaranteed to fill?

A market order is close to certain to execute during regular hours, but never at a guaranteed price. In a thin or fast-moving name, the price you receive can sit far from the quote you saw.

What is the difference between filled and settled?

A fill is the execution: the trade has matched and printed to the tape. Settlement is the later transfer of shares and cash at the clearing corporation, one business day after the trade date for US equities.

Why is the cash from my sale not in my buying power yet?

In a cash account, sale proceeds become settled cash on the business day after the trade. Many brokers release the value for new purchases immediately, so the purchasing-power figure and the settled-cash figure can disagree on screen until settlement.

Does a market order fill faster than a limit order?

A market order takes the quote, so it fills as soon as it reaches a venue with size available. A limit order priced away from the market waits for the price to come to it, which can take seconds, days, or forever.

Every panel here ships with the exact SQL beneath it, so expand one to see how the number was counted. The same questions can be asked in plain English on the Strasmore terminal.