Why Your Options Order Isn't Getting Filled

Why your options order isn't filling usually comes down to machinery a retail screen never shows: where your order sits in the exchange's allocation queue, whether the size you joined is still there, how wide the market actually is, and whether a multi-leg order's net price is executable at all. A displayed quote is a snapshot of what someone was willing to trade a moment ago. Matching that price gets your order into the line. It does not put you at the front of it.

Is an options quote a promise that you can trade there?

No. A quote is a two sided offer that whoever posted it can cancel or reprice at any instant, and the size attached to it applies only to that instant. On an actively quoted underlying, a single contract republishes its bid and offer many times a second. Our options bid ask spread guide covers what the two sides represent. What decides fills is how briefly any one version of that quote survives.

The panel below counts every quote update the feed carried for Apple option contracts over one pinned 30 second window, starting at 2:00:00 p.m. ET on June 17, 2026, second by second.

SELECT
    formatDateTime(toTimeZone(sip_timestamp, 'America/New_York'), '%H:%i:%S') AS et_time,
    round(count() / 1000, 1)                                                 AS quote_updates_k,
    round(count() / uniqExact(ticker), 1)                                    AS updates_per_contract
FROM global_markets.cache_options_quotes
WHERE ticker IN
(
    SELECT ticker
    FROM global_markets.options_greeks
    WHERE underlying_symbol = 'AAPL'
      AND date = '2026-06-17'
)
  AND sip_timestamp >= toDateTime('2026-06-17 18:00:00', 'UTC')
  AND sip_timestamp <  toDateTime('2026-06-17 18:00:30', 'UTC')
GROUP BY et_time
ORDER BY et_time

In the opening second the feed carried about 0.9 thousand quote updates across those contracts, roughly 1.9 republished quotes per contract in that one second. An order ticket does not travel at that speed. By the time a click becomes a message sitting at the exchange, the book it lands in has already turned over.

Does being at the best price put you first in line?

Not on its own. Stock exchanges mostly run price-time priority: at a given price, whoever arrived first trades first. Options exchanges add two rules on top, and those rules are where resting orders get stranded.

Public customer orders come first. Almost every US options exchange gives an order from a public customer precedence over market maker and professional orders resting at the same price. That part works in a retail trader's favor.

After customer priority, allocation is pro-rata rather than time ordered. An incoming order is divided across the resting orders in proportion to their size, often with a small overlay for whoever posted the price first. Size, not arrival time, sets the share.

Put those together and a 1 lot resting beside a 500 lot counts as one contract out of 501 rather than as one of two orders in a queue. An incoming 100 lot can sweep the price with a single contract landing on the small order.

The panel below buckets every Apple option trade printed on June 17, 2026 by trade size, then compares each bucket's share of the day's prints against its share of the day's contracts.

WITH
    (
        SELECT count()
        FROM global_markets.options_trades
        WHERE underlying_symbol = 'AAPL'
          AND sip_timestamp >= toDateTime('2026-06-17 00:00:00', 'UTC')
          AND sip_timestamp <  toDateTime('2026-06-18 00:00:00', 'UTC')
    ) AS day_prints,
    (
        SELECT sum(size)
        FROM global_markets.options_trades
        WHERE underlying_symbol = 'AAPL'
          AND sip_timestamp >= toDateTime('2026-06-17 00:00:00', 'UTC')
          AND sip_timestamp <  toDateTime('2026-06-18 00:00:00', 'UTC')
    ) AS day_contracts
SELECT
    multiIf(size = 1,    '1 contract',
            size <= 5,   '2 to 5',
            size <= 20,  '6 to 20',
            size <= 100, '21 to 100',
                         'over 100')       AS size_bucket,
    round(100 * count()   / day_prints, 2) AS share_of_trades_pct,
    round(100 * sum(size) / day_contracts, 2) AS share_of_volume_pct
FROM global_markets.options_trades
WHERE underlying_symbol = 'AAPL'
  AND sip_timestamp >= toDateTime('2026-06-17 00:00:00', 'UTC')
  AND sip_timestamp <  toDateTime('2026-06-18 00:00:00', 'UTC')
GROUP BY size_bucket
ORDER BY min(size)

Single contract trades made up 48.48% of the day's prints and 7.83% of the contracts that changed hands. The over 100 bucket inverts that shape: 0.44% of prints carrying 16.67% of the volume. Under pro-rata allocation the second number is the one that governs how much of an arriving order reaches any one resting order. Market makers quote both sides continuously and manage inventory as they go, which our guide to how market makers make money works through in detail.

Why is my options order not filling at the mid?

The mid is arithmetic: the bid plus the ask, divided by two. Nobody is obliged to trade there. The two prices that always exist are the naturals, the ask if you are buying and the bid if you are selling. Everything between the natural and the mid is a negotiation that completes when the other side's model prices the contract on your side of the midpoint, or when a second public order arrives wanting the opposite trade.

How much room that negotiation covers tracks how wide the market is, and width varies enormously with the price of the contract. The panel below takes the same 30 second window, groups every Apple options quote by the price of the contract, and reports the median quoted spread in cents alongside the same spread as a percentage of the mid.

SELECT
    price_bucket,
    round(quantileExact(0.5)(spread) * 100, 1)       AS median_spread_cents,
    round(quantileExact(0.5)(100 * spread / mid), 1) AS spread_pct_of_mid
FROM
(
    SELECT
        toFloat64(ask_price) - toFloat64(bid_price)       AS spread,
        (toFloat64(ask_price) + toFloat64(bid_price)) / 2 AS mid,
        multiIf(mid < 0.50,  'under $0.50',
                mid < 2.00,  '$0.50 to $2',
                mid < 5.00,  '$2 to $5',
                mid < 15.00, '$5 to $15',
                             '$15 and up')                AS price_bucket,
        multiIf(mid < 0.50, 1, mid < 2.00, 2, mid < 5.00, 3, mid < 15.00, 4, 5) AS bucket_order
    FROM global_markets.cache_options_quotes
    WHERE ticker IN
    (
        SELECT ticker
        FROM global_markets.options_greeks
        WHERE underlying_symbol = 'AAPL'
          AND date = '2026-06-17'
    )
      AND sip_timestamp >= toDateTime('2026-06-17 18:00:00', 'UTC')
      AND sip_timestamp <  toDateTime('2026-06-17 18:00:30', 'UTC')
      AND bid_price > 0
      AND ask_price > bid_price
)
GROUP BY price_bucket
ORDER BY min(bucket_order)

Contracts in the under $0.50 bucket quoted a median spread of 17 cents, which works out to 75% of the mid. Contracts in the $15 and up bucket quoted 170 cents, or 3.8% of the mid. In cents the expensive contract shows the wider quote. In percentage terms the cheap contract is the wider market by a distance, and an order resting at its midpoint is asking a counterparty to give up a large share of that spread. Liquidity and volatility pull those widths in different directions, and two contracts on the same underlying can behave nothing alike.

A market order versus a limit order removes the pricing question and replaces it with a different one. A market order trades against whatever the book holds at that instant, which on a thin options series can sit several ticks away from the last quote your screen drew.

Why doesn't a spread fill when both legs look executable?

A multi-leg order does not sit in the two single-leg books. It routes to a complex order book and is matched as one package, on its net price. The exchange fills it against another complex order, or against the single-leg books when their combined price beats your net, and it does neither until the whole package prices.

Take a hypothetical two leg call spread. The long leg is quoted $1.20 bid at $1.35 ask, the short leg $0.60 bid at $0.72 ask. Buying the package on the naturals costs $1.35 minus $0.60, a $0.75 debit. Selling on the naturals brings in $1.20 minus $0.72, a $0.48 credit. The net market on the package is $0.48 bid at $0.75 ask, with a midpoint of $0.615. Watching the legs separately says nothing about whether $0.62 is executable. The combined book keeps its own two sided market and its own resting orders.

Two things follow. A leg that trades at your price on the single-leg screen leaves your spread unfilled, and your order was never resting in that book to begin with. A spread priced in leg terms rather than net terms is priced against a book that does not exist.

Why won't an order fill on a strike with zero volume?

Nothing is broken. Most listed strikes do not trade on most days. A chain lists every strike the exchange has opened, and the majority sit quoted but untouched, sometimes for weeks at a time. Volume counts contracts that changed hands today. Open interest counts positions still outstanding, and the gap between the two is worked through in our options volume vs open interest explainer.

The panel below measures how thin the outer strikes get. It takes every Apple contract with 20 to 45 days to expiry across May and June 2026, groups them by how far the strike sat from the underlying price that day, and reports median daily volume alongside the share of contract days that printed fewer than 10 contracts.

SELECT
    moneyness_bucket,
    round(quantileExact(0.5)(toFloat64(volume)), 0) AS median_daily_volume,
    round(100 * countIf(volume < 10) / count(), 1)  AS share_under_10_lots_pct
FROM
(
    SELECT
        abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) AS gap,
        multiIf(gap < 0.02, '0% to 2% from spot',
                gap < 0.05, '2% to 5% from spot',
                gap < 0.10, '5% to 10% from spot',
                gap < 0.20, '10% to 20% from spot',
                            'more than 20% from spot') AS moneyness_bucket,
        multiIf(gap < 0.02, 1, gap < 0.05, 2, gap < 0.10, 3, gap < 0.20, 4, 5) AS bucket_order,
        volume
    FROM global_markets.options_greeks
    WHERE underlying_symbol = 'AAPL'
      AND date >= '2026-05-01'
      AND date <  '2026-07-01'
      AND days_to_expiry BETWEEN 20 AND 45
      AND underlying_close > 0
)
GROUP BY moneyness_bucket
ORDER BY min(bucket_order)

Contracts 0% to 2% from spot carried a median daily volume of 354 contracts, with 2% of contract days printing under 10. Contracts more than 20% from spot recorded a median of 6 contracts a day, and 55.4% of contract days there printed under 10. An order resting on one of those strikes waits on flow that is not arriving, and the only standing counterparty is the market maker who quoted the strike in the first place.

What the machinery changes about an order ticket

• A spread is priced on the net. The complex book matches packages, and a single leg price carries no standing there.
• The mid works as an anchor. The two prices always available on a wide market are the naturals, the ask for a buy and the bid for a sell.
• Size sets the share of a pro-rata fill. A 1 lot resting beside much larger orders receives a proportional slice of whatever arrives.
• A quiet strike is a quoting question before it is an order question. Nothing is arriving to match against.

FAQ

Why is my options limit order not filling when it is at the bid?

Joining the bid puts your order in the queue at that price, and options exchanges allocate fills by customer status and by size rather than purely by arrival time. A small order resting alongside much larger ones receives a proportional slice of anything that trades, which can round down to nothing on a modest print.

Do options exchanges fill orders in the order they arrive?

Mostly no. Public customer orders take precedence over market maker and professional orders at the same price, and the remaining size is generally allocated pro-rata, in proportion to each resting order's size. Some exchanges add a priority overlay for whoever posted the price first.

What does paying the natural mean on an options order?

The natural is the price already displayed on your side of the market: the ask when you are buying, the bid when you are selling. An order at the natural is executable against the current quote, while an order at the mid waits for the other side to improve.

Is it normal for an option with zero volume to never fill?

Yes. Most listed strikes go untraded on most days, and a resting order on one of them competes for flow that is not arriving. The quote shown there is typically a market maker's obligation, and the fill turns on whether that price is one they want at that moment.

Every panel above carries the exact SQL beneath it. To run the same measurements on a contract you follow, ask the question in plain English on the Strasmore terminal.