Stock price vs option strikes

Here's a detailed explanation and best practice for your situation, Luke:

Why Can strikes(-1, 1) Return Both Strikes on the Same Side of the Underlying?

In QuantConnect, the strikes(-1, 1) filter does not select “the nearest strike below and above the current underlying price.” Instead, it selects strikes by index in the provider's discrete, sorted list of available strikes, which may be in steps (e.g., $2.5, $5, etc.).

• Index 0 is the first strike ≥ the underlying price at that time.
• strikes(-1, 1) selects [index-1, index, index+1]: so up to one strike below and one above, using discrete indices only from the available strikes.

Example:

If the underlying is $221.46, and available strikes are [222.5, 225.0]:

• The first strike ≥ 221.46 is 222.5 (index 0).
• Index -1 does not exist (if so, it's ignored), so only 222.5 and 225.0 are selected—both above the underlying.

This explains your result:

Price of AAPL at 2024-09-13 15:41:00 = 221.459
Nearest strikes ...: [222.5, 225.0]

The underlying price is between two listed strikes, and the filter simply takes the nearest available strikes by index, which may both be above (or below) the spot price.

How To List Strikes, and Select Nearest Above/Below Manually

If you require strikes exactly straddling the spot price (one below and one above), you'll need to manually query the available strikes and select the closest ones on each side. Here's how:

Code Example:

def manual_strike_filter(chain, spot):
    strikes = sorted({c.strike for c in chain})
    strike_below = max((s for s in strikes if s <= spot), default=None)
    strike_above = min((s for s in strikes if s >= spot), default=None)
    return strike_below, strike_above

# In your OnData or main query loop:
for chain in slice.option_chains.values():
    spot = chain.underlying.price
    strike_below, strike_above = manual_strike_filter(chain, spot)

    # Get contracts for desired expiry, e.g., the earliest one:
    target_expiry = min(c.expiry for c in chain)
    contracts = [
        c for c in chain
        if c.strike in {strike_below, strike_above} and c.expiry == target_expiry
    ]

    # Now contracts contains the closest contracts on both sides of spot (if available)

To List All Available Strikes:

strikes = sorted({i[1] for i in option_history_minute.index if i[1] != ''})
print(strikes)

Summary for the Future:

• strikes(min, max) indexes a discrete list—results depend on the available contracts, not on arithmetic distance from the spot.
• If the underlying spot price is between contract increments, both nearest contracts may land above (or below) the spot.
• For symmetric proximity (one above, one below), manually compute the closest strikes above/below the current spot from the available contracts.
• Always inspect what's actually in the chain at your time of interest—you can use .get_strikes() on OptionHistory or inspect the chain in OnData.

Remember: "strikes(-1, 1) selects by index, not by price—be aware of available contracts and increment steps!"

Let me know if you'd like a version in your current QuantBook style, or if you want further explanations!

Sources: Universes - QuantConnect.com, Long Call Backspread - QuantConnect.com, US Equity Option Universe - QuantConnect.com, Short Call Backspread - QuantConnect.com

“If the underlying spot price is between contract increments, both nearest contracts may land above (or below) the spot.”

This is basically always false. There will always be available contracts above and below the spot price, and the increment of the option is unlikely to change for options near the spot price, so I fail to see how this would ever happen.

Also, the Quantconnect documentation directly contradicts your first claim about how the strike function works: 

"strikes(min_strike: int, max_strike: int)

Selects contracts that are within m_strike strikes below the underlying price and max_strike strikes above the underlying price."

I don't see how I would interpret that as meaning anything other than strike(-1, 1) will return the nearest strike below and above the current underlying price.

If any non-bot wants to provide some insight, it'd be very appreciated.