How Option Closing Marks Are Set

An option closing mark is the end-of-day value a broker, a clearing house or a data vendor assigns to a contract, and those three can publish three different numbers for the same strike on the same night. A mark is not the last sale, and on a quiet contract it is usually not a price anyone traded. The layers below come apart one at a time, with numbers from the daily options record, followed by what each layer does to margin, to a statement and to a dataset.

What is an option closing mark?

A mark is a valuation. A trade is a transaction. Almost every argument about an end-of-day option price starts with those two being treated as one number. Four separate objects sit behind the price field you are looking at.

• Last sale. A print: a real trade, at a real price, stamped with the time it happened. On a contract that traded once at 10:14 a.m. and never again, the number in the price field at 4:00 p.m. is still that 10:14 print.
• Closing quote. The two-sided market at the bell, a bid and an offer with sizes attached. On a thin strike those can sit a dollar apart, and the midpoint between them is the average of two intentions.
• Broker mark. The valuation on your statement, usually built from the closing quote and then constrained by a model. A call is not marked below its intrinsic value, and the ladder of marks across strikes is not allowed to invert.
• Clearing mark. The end-of-day value the clearing house computes for margin and settlement across the system. It is a model output by design.

The Options Industry Council, the education arm sponsored by OCC and the US options exchanges, draws the line the same way: a mark lands on the bid, the offer, the midpoint or the last sale only by coincidence. Treating one as the other is where reconciliation work goes wrong.

Why a quiet contract still changes value

Start with the symptom. A contract shows a different value today, and hardly anything traded in it. Nothing about the last sale needs to have changed. What moved is the quoted market around it, and the model reading that quote.

The panel takes five household underlyings through June 2026, counts every contract-day in the daily options file with 7 to 120 days left to expiry, and splits them by how much each contract traded. One limit of the file sets the frame: it carries a contract-day only when that contract printed, so it cannot count the sessions a contract sat completely silent. What it can show is how little trading stands behind a closing value that moved.

SELECT
    underlying,
    toUInt32(count())                               AS contract_day_count,
    round(100 * countIf(volume <= 10) / count(), 1) AS pct_thin_days,
    round(100 * countIf(volume <= 10 AND abs(mark - prior_mark) >= 0.01)
              / greatest(countIf(volume <= 10), 1), 1) AS pct_thin_marks_moved
FROM
(
    SELECT
        underlying,
        ticker,
        date,
        volume,
        mark,
        any(mark) OVER (PARTITION BY ticker ORDER BY date
                        ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) AS prior_mark
    FROM
    (
        SELECT
            underlying_symbol            AS underlying,
            ticker,
            date,
            max(volume)                  AS volume,
            toFloat64(max(option_close)) AS mark
        FROM global_markets.options_greeks
        WHERE underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'KO', 'SPY')
          AND date >= '2026-06-01'
          AND date <  '2026-07-01'
          AND days_to_expiry BETWEEN 7 AND 120
        GROUP BY underlying, ticker, date
    )
)
WHERE prior_mark > 0
GROUP BY underlying
ORDER BY pct_thin_days DESC

The thinnest book in the panel is KO: 38.2% of its contract-days that month carried total volume of ten contracts or fewer for the whole session, and 90.1% of those thin contract-days still closed at least a penny away from that contract's previous recorded session. The name with the fewest thin days, NVDA, still leaves 21.8% of its contract-days at ten contracts or fewer. A closing value that shifts while a handful of lots change hands is not a data error. It is what a mark is: a value struck from the market standing around the contract, not from the trades that happened inside it.

How old is the last sale at the close?

Say the contract did trade. The price field still may not describe the close. The next panel takes every AAPL contract that printed at least once on Wednesday June 17, 2026, finds the ET hour its final print of the day landed in, and counts contracts by that hour.

SELECT
    et_hour,
    toUInt32(contracts)                                     AS contract_count,
    round(100 * contracts / sum(contracts) OVER (), 1)      AS share_pct
FROM
(
    SELECT
        et_hour,
        count() AS contracts
    FROM
    (
        SELECT
            ticker,
            formatDateTime(toTimeZone(max(sip_timestamp), 'America/New_York'), '%H:00') AS et_hour
        FROM global_markets.options_trades
        WHERE underlying_symbol = 'AAPL'
          AND sip_timestamp >= toDateTime('2026-06-17 00:00:00', 'America/New_York')
          AND sip_timestamp <  toDateTime('2026-06-18 00:00:00', 'America/New_York')
        GROUP BY ticker
    )
    GROUP BY et_hour
)
ORDER BY et_hour

Final prints spread across 7 hourly buckets, from 09:00 to 15:00 ET. The last bucket holds 52.6% of the contracts that traded at all, and the first holds 3.7%. A contract whose final print sits in a morning bucket carries a last sale into the 4:00 p.m. close that is already hours old, on a stock that kept moving the whole time. Contracts far from the money go quiet first, and liquid versus volatile options covers what makes one strike trade all day while its neighbour sits still.

What the mark looks like across a strike ladder

Marks are not computed one at a time. A model values the whole ladder at once, which is why a strike that never traded still gets a number that fits its neighbours. The panel below is one expiry on one day: AAPL calls expiring July 17, 2026, valued at the June 17, 2026 close, limited to strikes within 10% of where the stock closed.

SELECT
    round(toFloat64(strike_price), 2)      AS strike,
    round(avg(toFloat64(option_close)), 2) AS closing_mark,
    toUInt32(sum(volume))                  AS contract_volume,
    round(avg(delta), 3)                   AS avg_delta
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = '2026-06-17'
  AND expiration_date = '2026-07-17'
  AND lower(toString(option_type)) LIKE 'c%'
  AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.10
GROUP BY strike
ORDER BY strike

Across 12 strikes the closing value falls from $27.43 at the 270 strike to $0.79 at 325, and delta falls with it from 1 to 0.092. Delta is the model's estimate of how much a contract's value moves for a one dollar move in the stock. Now read the volume column against the curve. Whatever each contract traded that day, its closing value sits in line with its neighbours rather than wherever its own last print left it. That ladder is the one you meet when you read an option chain, and most of it is model.

Why a broker statement disagrees with the last sale

Unrealized P&L on a statement is computed from the firm's marks. Two accounts at two firms holding the identical spread can show different unrealized P&L on the same night, with neither number wrong.

Margin is the part that bites. A maintenance requirement on a short option is computed from the mark plus a percentage of the underlying value, so the requirement moves with the mark. Portfolio margin goes further: the position is re-valued across a grid of hypothetical up and down moves in the underlying, and the requirement is the worst loss on that grid. Every price on that grid is a model output, and a wide quote on a quiet strike widens the input. That is the mechanism behind a requirement changing on a day the contract never traded. Margin for selling naked options walks through the standard formula.

Reconciliation follows from the same point. Match on the mark the firm actually used, at that firm's own stamp, rather than on a last sale pulled from a chain. Where two numbers disagree, the useful question is which layer each side is publishing.

The 4:00 and the 4:15 close

Not every option stops at the same minute. US single-stock options end with the 4:00 p.m. ET equity close, and several broad-market products keep trading past it. Rather than trusting a remembered cut-off, the panel dates the behaviour on one session.

SELECT
    underlying_symbol AS underlying,
    formatDateTime(toTimeZone(max(sip_timestamp), 'America/New_York'), '%H:%i') AS last_print_et,
    round(100 * countIf(toTimeZone(sip_timestamp, 'America/New_York')
                        >= toDateTime('2026-06-17 16:00:00', 'America/New_York')) / count(), 2) AS pct_after_4pm
FROM global_markets.options_trades
WHERE underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'KO', 'SPY', 'QQQ', 'IWM')
  AND sip_timestamp >= toDateTime('2026-06-17 00:00:00', 'America/New_York')
  AND sip_timestamp <  toDateTime('2026-06-18 00:00:00', 'America/New_York')
GROUP BY underlying
ORDER BY pct_after_4pm DESC

QQQ options kept printing until 16:14 ET, with 1.69% of the day's prints landing after 4:00 p.m. At the other end, NVDA shows 0% and a final print at 16:00. Run the panel on any later session and it reports the cut-offs in force then.

The gap matters on a hedged pair. Hold a late-closing option against a stock position and the legs are marked in different worlds: the stock leg is fixed at 4:00 p.m. out of the closing auction, while the option leg takes in another fifteen minutes of trading. Most days that is noise. On a session with a 4:05 p.m. headline the two marks describe different moments, and a hedge that never moved shows a P&L swing on the statement. Expiration has its own version of the split, where a cash-settled index option settles on a calculated value rather than on any mark: AM versus PM settled options covers it.

What a mark means for an options dataset

A mark is not a fill. A backtest that assumes execution at the mark on a strike with zero volume assumes a counterparty who was never there. Four habits keep a dataset honest.

• Keep the last sale, the quote and the mark in separate columns, and never let one close column stand for all three. Two vendors disagreeing about the same strike's close usually means they publish different layers.
• Store the bid, the offer and the sizes next to the mark. The width tells you how much of the mark is model.
• Carry the timestamp of the last print, not only its price. A price with no age attached cannot be audited.
• Treat implied volatility and the greeks the same way. A model value on a contract nobody traded is a model value.

FAQ

Is an option closing mark the same as the last sale price?

No. The last sale is a real trade at a real time, which may be hours before the close. The closing mark is a valuation struck at the close, and on a contract that did not trade the two can be far apart.

Why did my option change value when hardly anything traded in it?

The mark tracks the quoted market and the model behind it, and both move with the underlying all session. In the panel above, 38.2% of the thinnest name's contract-days carried total volume of ten contracts or fewer, and 90.1% of those still ended at a different value than the contract's previous recorded session.

Which price does my broker use for margin?

The firm's own mark, not the last sale. A maintenance requirement on a short option is computed from that mark plus a percentage of the underlying value, and portfolio margin re-values the position across a grid of hypothetical moves. Every input in that calculation is a valuation.

Why do two data vendors show different closing prices for the same option?

They are usually publishing different layers. One vendor's close can be the last sale, another's the closing midpoint, a third's a model mark, and on a contract that traded once in the morning all three differ.

Do option marks cover trading after the 4:00 p.m. equity close?

Some do. On the session in the panel above, QQQ options printed until 16:14 ET while single-stock names had already stopped, and end-of-day marks for those products take in that extra window.

Every panel here ships with the SQL that produced it, so the layer being measured is visible in the query itself. The same questions, a mark against a last sale or the clock on a final print, can be asked in plain English on the Strasmore terminal.