Universes

Index Options

Introduction

An Index Option universe lets you select a basket of Option contracts on an Index.

Create Universes

To add a universe of Index Option contracts, in the Initializeinitialize method, call the AddIndexOptionadd_index_option method. This method returns an Option object, which contains the canonical Symbolsymbol. You can't trade with the canonical Option Symbolsymbol, but save a reference to it so you can easily access the Option contracts in the OptionChain that LEAN passes to the OnDataon_data method. The method to create the universe depends on if the Index Options you want require a target ticker.

Create Non-Standard Universes

Non-standard Option contracts are popular among Option traders. To create a universe of non-standard Index Options like weekly VIX contracts, pass the index Symbol and target Option ticker to the AddIndexOptionadd_index_option method.

Select Language:

public class WeeklyIndexOptionAlgorithm : QCAlgorithm
{
    private Symbol _symbol;
    public override void Initialize()
    {
        var underlying = AddIndex("VIX").Symbol;
        var option = AddIndexOption(underlying, "VIXW");
        option.SetFilter(universe => universe.IncludeWeeklys().Expiration(0, 7).Delta(0.35m, 0.75m));
        _symbol = option.Symbol;
    }

    public override void OnData(Slice data)
    {
        if (data.OptionChains.TryGetValue(_symbol, out var chain))
        {
            var contract = chain.OrderBy(x => x.Expiry).ThenBy(x => x.Greeks.Delta).FirstOrDefault();
        }
    }
}

class WeeklyIndexOptionAlgorithm(QCAlgorithm):

    def initialize(self):
        underlying = self.add_index("VIX").symbol
        option = self.add_index_option(underlying, "VIXW")
        option.set_filter(lambda universe: universe.include_weeklys().expiration(0, 7).delta(0.35, 0.75))
        self._symbol = option.symbol

    def on_data(self, data):
        chain = data.option_chains.get(self._symbol)
        if chain:
            contract = sorted(chain, key=lambda x: (x.expiry, x.greeks.delta))[0]

The following table describes the AddIndexOptionadd_index_option method arguments for non-standard universes:

Argument	Data Type	Description	Default Value
`underlying`	`Symbol`	The underlying Index `Symbol`. To view the supported indices, see Supported Assets.
`targetOptiontarget_option`	`stringstr`	The target Option ticker. To view the supported target Options, see Supported Assets.
`resolution`	`Resolution?Resolution/NoneType`	The resolution of the market data. To view the supported resolutions, see Resolutions. The Index resolution must be less than or equal to the Index Option resolution. For example, if you set the Index resolution to minute, then you must set the Index Option resolution to minute, hour, or daily.	`Nonenull`
`market`	`stringstr`	The Index Option market.	`Market.USA`
`fillForwardfill_forward`	`bool`	If true, the current slice contains the last available data even if there is no data at the current time.	`Truetrue`

If you add an Option universe for an underlying Index that you don't have a subscription for, LEAN automatically subscribes to the underlying Index.

Create Standard Universes

To create a universe of Index Options based on an index like VIX, SPX, or NDX, pass the index ticker to the AddIndexOptionadd_index_option method.

Select Language:

var option = AddIndexOption("SPX");
option.SetFilter(universe => universe.Expiration(0, 60).Delta(0.35m, 0.75m););
 _symbol = option.Symbol;

option = self.add_index_option("SPX")
option.set_filter(lambda universe: universe.expiration(0, 60).delta(0.35, 0.75))
self._symbol = option.symbol

The following table describes the AddIndexOptionadd_index_option method arguments for standard universes:

Argument	Data Type	Description	Default Value
`ticker`	`stringstr`	The underlying Index ticker. To view the supported indices, see Supported Assets.
`resolution`	`Resolution?Resolution/NoneType`	The resolution of the market data. To view the supported resolutions, see Resolutions.	`Nonenull`
`market`	`stringstr`	The Index Option market.	`Market.USA`
`fillForwardfill_forward`	`bool`	If true, the current slice contains the last available data even if there is no data at the current time.	`Truetrue`

If you add an Option universe for an underlying Index that you don't have a subscription for, LEAN automatically subscribes to the underlying Index and sets its fill forward property to match that of the Index Option universe.

Filter by Investment Strategy

Options trading strategies consist of simultaneously buying or selling one or more Option contracts on the same underlying Index, but with different features.

Select Language:

// Example 1: Select a Straddle
option.SetFilter(optionFilterUniverse => optionFilterUniverse.Straddle(30, 5, 10));

// Example 2: Select the contracts (including weeklys) that expire in the next 30 days that form an Iron Condor
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().Strikes(-20, 20).Expiration(0, 30).IronCondor(30, 5, 10));

// Example 3: Select the 0DTE contracts that form an Strangle
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().Expiration(0, 0).Strangle(30, 5, -10));

# Example 1: Select a Straddle
option.set_filter(lambda option_filter_universe: option_filter_universe.straddle(30, 5, 10))

# Example 2: Select the contracts (including weeklys) that expire in the next 30 days that form an Iron Condor
option.set_filter(lambda option_filter_universe: option_filter_universe.include_weeklys().strikes(-20, 20).expiration(0, 30).iron_condor(30, 5, 10))

# Example 3: Select the 0DTE contracts that form an Strangle
option.set_filter(lambda option_filter_universe: option_filter_universe.include_weeklys().expiration(0, 0).strangle(30, 5, -10))

The following table describes the filter methods of the OptionFilterUniverse class that select contracts for Option strategies:

naked_call(min_days_till_expiry: int, strike_from_atm: float)

Selects a call contract to form Naked Call, Covered Call, or Protective Call Option strategies.

naked_put(min_days_till_expiry: int, strike_from_atm: float)

Selects a put contract to form Naked Put, Covered Put, or Protective Put Option strategies.

call_spread(min_days_till_expiry: int, higher_strike_from_atm: float, lower_strike_from_atm: float)

Selects two call contracts to form Bull Call Spread or Bear Call Spread Option strategies.

put_spread(min_days_till_expiry: int, higher_strike_from_atm: float, lower_strike_from_atm: float)

Selects two put contracts to form Bull Put Spread or Bear Put Spread Option strategies.

call_calendar_spread(strike_from_atm: int, min_near_days_till_expiry: int, min_far_days_till_expiry: int)

Selects two call contracts to form Long Call Calendar Spread or Short Call Calendar Spread Option strategies.

put_calendar_spread(strike_from_atm: int, min_near_days_till_expiry: int, min_far_days_till_expiry: int)

Selects two put contracts to form Long Put Calendar Spread or Short Put Calendar Spread Option strategies.

strangle(min_days_till_expiry: int, higher_strike_from_atm: float, lower_strike_from_atm: float)

Selects two contracts to form Long Strangle or Short Strangle Option strategies.

straddle(min_days_till_expiry: int)

Selects two contracts to form Long Straddle or Short Straddle Option strategies.

protective_collar(min_days_till_expiry: int, higher_strike_from_atm: float, lower_strike_from_atm: float)

Selects two contracts to form Protective Collar Option strategies.

conversion(min_days_till_expiry: int, strike_from_atm: float)

Selects two contracts to form Conversion or Reverse Conversion Option strategies.

call_butterfly(min_days_till_expiry: int, strike_spread: float)

Selects three contracts to form Long Call Butterfly or Short Call Butterfly Option strategies.

put_butterfly(min_days_till_expiry: int, strike_spread: float)

Selects three contracts to form Long Put Butterfly or Short Put Butterfly Option strategies.

iron_butterfly(min_days_till_expiry: int, strike_spread: float)

Selects four contracts to form Long Iron Butterfly or Short Iron Butterfly Option strategies.

iron_condor(min_days_till_expiry: int, near_strike_spread: float, far_strike_spread: float)

Selects four contracts to form Long Iron Condor or Short Iron Condor Option strategies.

box_spread(min_days_till_expiry: int, strike_spread: float)

Selects four contracts to form Box Spread or Short Box Spread Option strategies.

jelly_roll(strike_from_atm: float, min_near_days_till_expiry: int, min_far_days_till_expiry: int)

Selects four contracts to form Jelly Roll or Short Jelly Roll Option strategies.

call_ladder(min_days_till_expiry: int, higher_strike_from_atm: float, middle_strike_from_atm: float, lower_strike_from_atm: float)

Selects four contracts to form Bear Call Ladder or Bull Call Ladder Option strategies.

put_ladder(min_days_till_expiry: int, higher_strike_from_atm: float, middle_strike_from_atm: float, lower_strike_from_atm: float)

Selects four contracts to form Bear Put Ladder or Bull Put Ladder Option strategies.

The preceding methods return an OptionFilterUniverse, so you can chain the methods together.

Filter by Implied Volatility and Greeks

Option price models compute the theoretical price of Option contracts, their implied volatility, and their Greek values. Theoretical prices can help you detect undervalued and overvalued contracts, implied volatility can provide you insight into the upcoming volatility of the underlying security, and Greek values can help you hedge your portfolio.

Select Language:

// Example 1: Select the contracts with delta between 0.25 and 0.75
option.SetFilter(optionFilterUniverse => optionFilterUniverse.Delta(0.25m, 0.75m));

// Example 2: Select the contracts (including weeklys) that expire in the next 90 days with implied volatility below 20% 
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().IV(0, 20).Expiration(0, 90));

// Example 3: Select the contracts (including weeklys) that expire in the next 30 days with implied volatility below 20% that forms an Iron Condor
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().IV(0, 20).Expiration(0, 30).IronCondor(30, 5, 10));

# Example 1: Select the contracts with delta between 0.25 and 0.75
option.set_filter(lambda option_filter_universe: option_filter_universe.delta(0.25, 0.75))

# Example 2: Select the contracts (including weeklys) that expire in the next 90 days with implied volatility below 20% 
option.set_filter(lambda option_filter_universe: option_filter_universe.include_weeklys().iv(0, 20).expiration(0, 90))

# Example 3: Select the contracts (including weeklys) that expire in the next 30 days with implied volatility below 20% that forms an Iron Condor
option.set_filter(lambda option_filter_universe: option_filter_universe.include_weeklys().iv(0, 20).expiration(0, 30).iron_condor(30, 5, 10))

The following table describes the filter methods of the OptionFilterUniverse class that select contract for a range of implied volatility, Greek values, and open interest:

iv(min: float, max: float)
implied_volatility(min: float, max: float)

Selects a contract with implied volatility within the range you set.

d(min: float, max: float)
delta(min: float, max: float)

Selects a contract with delta within the range you set.

g(min: float, max: float)
gamma(min: float, max: float)

Selects a contract with gamma within the range you set.

r(min: float, max: float)
rho(min: float, max: float)

Selects a contract with rho within the range you set.

v(min: float, max: float)
vega(min: float, max: float)

Selects a contract with vega within the range you set.

t(min: float, max: float)
theta(min: float, max: float)

Selects a contract with theta within the range you set.

oi(min: int, max: int)
open_interest(min: float, max: float)

Selects a contract with open interest within the range you set.

The preceding methods return an OptionFilterUniverse, so you can chain the methods together.

To perform thorough filtering on the OptionFilterUniverse, define an isolated filter method.

Select Language:

// Select the put contracts with the lowest strike price.
option.SetFilter(Selector);
    
private OptionFilterUniverse Selector(OptionFilterUniverse optionFilterUniverse)
{
    return universe
        .Delta(0.5m, 1.5m)
        .Gamma(0.0001m, 0.0006m)
        .Vega(0.01m, 1.5m)
        .Theta(-2.0m, -0.5m)
        .Rho(0.5m, 3.0m)
        .ImpliedVolatility(1.0m, 3.0m)
        .OpenInterest(100, 500);
}

# Select the put contracts with the lowest strike price.
option.set_filter(self._contract_selector)
    
def _contract_selector(self, option_filter_universe: OptionFilterUniverse) -> OptionFilterUniverse:
    return option_filter_universe \
        .delta(0.5, 1.5) \
        .gamma(0.0001, 0.0006) \
        .vega(0.01, 1.5) \
        .theta(-2.0, -0.5) \
        .rho(0.5, 3.0) \
        .implied_volatility(1, 3) \
        .open_interest(100,500)

Filter by Other Contract Properties

To set a contract filter, in the Initializeinitialize method, call the SetFilterset_filter method of the Option object.

Select Language:

// Select contracts that have a strike price within 1 strike level above and below the underlying price
option.SetFilter(minStrike: -1, maxStrike: 1);

// Select contracts that expire within 30 days
option.SetFilter(minExpiry: TimeSpan.FromDays(0), maxExpiry: TimeSpan.FromDays(30));

// Select contracts that have a strike price within 1 strike level and expire within 30 days
option.SetFilter(minStrike: -1, maxStrike: 1, minExpiry: TimeSpan.FromDays(0), maxExpiry: TimeSpan.FromDays(30));

// Select call contracts
option.SetFilter(optionFilterUniverse => optionFilterUniverse.CallsOnly());

# Select contracts that have a strike price within 1 strike level above and below the underlying price
option.set_filter(min_strike=-1, max_strike=1)

# Select contracts that expire within 30 days
option.set_filter(min_expiry=timedelta(days=0), maxExpiry=timedelta(days=30))

# Select contracts that have a strike price within 1 strike level and expire within 30 days
option.set_filter(min_strike=-1, max_strike=1, min_expiry=timedelta(days=0), maxExpiry=timedelta(days=30))

# Select call contracts
option.set_filter(lambda option_filter_universe: option_filter_universe.calls_only())

The following table describes the available filter techniques:

set_filter(minStrike: int, maxStrike: int)

Selects the contracts that have a strike price within a minimum and maximum strike level relative to the underlying price. For example, say the underlying price is $302 and there are strikes at every $5. If you set minStrikem_strike to -1 and maxStrikemax_strike to 1, LEAN selects the contracts that have a strike of $300 or $305. This filter runs asynchronously by default.

set_filter(minExpiry: timedelta, maxExpiry: timedelta)

Selects the contracts that expire within the range you set. This filter runs asynchronously by default.

set_filter(minStrike: int, maxStrike: int, minExpiry: timedelta, maxExpiry: timedelta)

Selects the contracts that expire and have a strike within the range you set. This filter runs asynchronously by default.

set_filter(universeFunc: Callable[[OptionFilterUniverse], OptionFilterUniverse])

Selects the contracts that a function selects.

The following table describes the filter methods of the OptionFilterUniverse class:

strikes(min_strike: int, max_strike: int)

Selects contracts that are within minStrikem_strike strikes below the underlying price and maxStrikemax_strike strikes above the underlying price.

calls_only()

Selects call contracts.

puts_only()

Selects put contracts.

standards_only()

Selects standard contracts.

include_weeklys()

Selects non-standard weeklys contracts.

weeklys_only()

Selects weekly contracts.

front_month()

Selects the front month contract.

back_months()

Selects the non-front month contracts.

back_month()

Selects the back month contracts.

expiration(min_expiryDays: int, max_expiryDays: int)

Selects contracts that expire within a range of dates relative to the current day.

contracts(contracts: list[Symbol])

Selects a list of contracts.

contracts(contract_selector: Callable[[list[Symbol]], list[Symbol]])

Selects contracts that a selector function selects.

The preceding methods return an OptionFilterUniverse, so you can chain the methods together.

Select Language:

// Example 1: Select the front month call contracts
option.SetFilter(optionFilterUniverse => optionFilterUniverse.CallsOnly().FrontMonth());

// Example 2: Select the contracts (including weeklys) that expire in the next 90 days
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().Strikes(-20, 20).Expiration(0, 90));

// Example 3: Select the contracts (including weeklys) that expire in the next 30 days that form an Iron Condor
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().Strikes(-20, 20).Expiration(0, 30).IronCondor(30, 5, 10));

# Example 1: Select the front month call contracts
option.set_filter(lambda option_filter_universe: option_filter_universe.calls_only().front_month())

# Example 2: Select the contracts (including weeklys) that expire in the next 90 days
option.set_filter(lambda option_filter_universe: option_filter_universe.include_weeklys().strikes(-20, 20).expiration(0, 90))

Some of the preceding filter methods only set an internal enumeration in the OptionFilterUniverse that it uses later on in the filter process. This subset of filter methods don't immediately reduce the number of contract Symbol objects in the OptionFilterUniverse.

Default Filter

By default, LEAN subscribes to the Option contracts that have the following characteristics:

Standard type (exclude weeklys)
Within 1 strike price of the underlying asset price
Expire within 35 days

To adjust the universe of contracts, set a filter. The filter usually runs at the first bar of every day. When the filter selects a contract that isn't currently in your universe, LEAN adds the new contract data to the next Slice that it passes to the OnDataon_data method.

Navigate Intraday Option Chains

OptionChain objects represent an entire chain of Option contracts for a single underlying security.

To get the OptionChain, index the OptionChainsoption_chains property of the Slice with the canonical Symbolsymbol. After you get the OptionChain, you can sort and filter the Option contracts in the chain.

Select Language:

public override void OnData(Slice slice)
{
    // Try to get the OptionChain using the canonical symbol
    if (slice.OptionChains.TryGetValue(_symbol, out var chain))
    {
        // Example: Find 5 put contracts that are closest to at-the-money (ATM) and have the farthest expiration
        var contracts = chain
            .Where(x => x.Right == OptionRight.Put)
            .OrderByDescending(x => x.Expiry)
            .ThenBy(x => Math.Abs(chain.Underlying.Price - x.Strike))
            .Take(5);

        // Select the contract with the delta closest to -0.5
        var contract = contracts.OrderBy(x => Math.Abs(-0.5m - x.Greeks.Delta)).FirstOrDefault();
    }
}

def on_data(self, slice: Slice) -> None:
    # Try to get the OptionChain using the canonical symbol
    chain = slice.option_chains.get(self._symbol)
    if chain:
        # Example: Find 5 put contracts that are closest to at-the-money (ATM) and have the farthest expiration
        contracts = [x for x in chain if x.right == OptionRight.PUT]
        contracts = sorted(sorted(contracts, \
            key = lambda x: abs(chain.underlying.price - x.strike)), \
            key = lambda x: x.expiry, reverse=True)[:5]
    
        # Select the contract with the delta closest to -0.5
        contract = sorted(contracts, key=lambda x: abs(-0.5 - x.greeks.delta))[0]

You can also loop through the OptionChainsoption_chains property to get each OptionChain.

Select Language:

public override void OnData(Slice slice)
{
    // Iterate all received Canonical Symbol-OptionChain key-value pairs
    foreach (var kvp in slice.OptionChains)
    {
        var canoncialSymbol = kvp.Key;
        var chain = kvp.Value;
        var contracts = chain.Contracts;
    }
}

def on_data(self, slice: Slice) -> None:
    # Iterate all received Canonical Symbol-OptionChain key-value pairs
    for canonical_symbol, chain in slice.option_chains.items():
        contracts = chain.contracts

OptionChain objects have the following properties:

Navigate Daily Option Chains

To get the daily, pre-calculated Greeks and implied volaility of all the currently tradable contracts, call the OptionChainoption_chain method. This method returns a DataHistory[OptionUniverse] object, which you can format into a DataFrame or iterate through. Each row in the DataFrame and each OptionUniverse object represents a single contract. The data this method returns contains information on all the currently tradable contracts, not just the contracts that pass your filter.

Select Language:

// In the initialize method, create a Scheduled Event to get the Option 
// chain and rebalance the portfolio.
Schedule.On(DateRules.WeekStart(_symbol), TimeRules.AfterMarketOpen(_symbol, 1), Rebalance);

public void Rebalance()
{
    foreach (var optionUniverse in OptionChain(_symbol)) 
    {
        var close = optionUniverse.Close;
        var oi = optionUniverse.OpenInterest;
        var delta = optionUniverse.Greeks.Delta;
    }
}

# In the initialize method, create a Scheduled Event to get the Option 
# chain and rebalance the portfolio.
self.schedule.on(
    self.date_rules.week_start(self._symbol), 
    self.time_rules.after_market_open(self._symbol, 1), 
    self._rebalance
  )

# Define the method.
def _rebalance(self):
    daily_option_chain = self.option_chain(self._symbol, flatten=True)

    # Get the DataFrame format.
    df = daily_option_chain.data_frame
    delta_by_symbol = df.delta
    
    # Get the OptionUniverse objects format.
    for option_universe in daily_option_chain:
        close = option_universe.close
        oi = option_universe.open_interest
        delta = option_universe.greeks.delta

The OptionChainoption_chain method was previously known as the OptionChainProvider.GetOptionContractListoption_chain_provider.get_option_contract_list method.

OptionUniverse objects have the following properties:

Greeks and Implied Volatility

There are several ways to get the implied volatility and Greeks of contracts.

The Greeks and IV values in the filter function are the daily, pre-calculated values based on the end of the previous trading day.

Select Language:

public override void Initialize()
{
    var option = AddIndexOption("SPX");
    option.SetFilter(universe => universe.IncludeWeeklys().Delta(0.3m, 0.7m).Expiration(0, 7));
}

def initialize(self):
    option = self.add_index_option("SPX")
    option.set_filter(lambda universe: universe.include_weeklys().delta(0.3, 0.7).expiration(0,7))

To calculate the values, we use our implementation of the Black-Scholes pricing model, which accounts for the interest rate and dividend payments when applicable. For example, VIX doesn't have dividends. We use SPY for SPX and QQQ for NDX.

You can't customize the Greeks and IV values that the filter function receives. However, you can create indicators to customize how the Greeks and IV are calculated for the contracts already in your universe.

To override the default pricing model of the Option, set a pricing model. If you set a price model, it sets the price model of the individual contracts in the universe.

Select Language:

// Set PriceModel property to use the Crank-Nicolson finite-difference model to price the Options.
option.PriceModel = OptionPriceModels.CrankNicolsonFD();

// Set price_model field to use the Crank-Nicolson finite-difference model to price the Options.
option.price_model = OptionPriceModels.crank_nicolson_fd()

To override the initial guess of implied volatility, set and warm up the underlying volatility model.

Historical Data

To get historical chains for an Index Option, call the History<OptionUniverse>history[OptionUniverse] method with the canonical Option Symbol. This method returns the entire Option chain for each trading day, not the subset of contracts that pass your universe filter.

Select Language:

public class OptionHistoryAlgorithm : QCAlgorithm
{       
    public override void Initialize()
    {
        SetStartDate(2020, 1, 1);
        var option = AddIndexOption("SPX");
        var history = History<OptionUniverse>(option.Symbol, 5);
        foreach (var chain in history)
        {
            var endTime = chain.EndTime;
            var filteredContracts = chain.Data
                .Select(contract => contract as OptionUniverse)
                .Where(contract => contract.Greeks.Delta > 0.3m);
            foreach (var contract in filteredContracts)
            {
                var price = contract.Price;
                var iv = contract.ImpliedVolatility;
            }
        }
    }
}

class OptionHistoryAlgorithm(QCAlgorithm):

    def initialize(self):
        self.set_start_date(2020, 1, 1)
        option = self.add_index_option('SPX');
        # DataFrame example:
        history_df = self.history(option.symbol, 5, flatten=True)
        # OptionUniverse objects example:
        history = self.history[OptionUniverse](option.symbol, 5)
        for chain in history:
            end_time = chain.end_time
            filtered_contracts = [c for c in chain if c.greeks.delta > 0.3]
            for contract in filtered_contracts:
                symbol = contract.symbol
                expiry = contract.id.date
                strike = contract.id.strike_price
                price = contract.close
                iv = contract.implied_volatility

The Greeks and IV values that you get from a history request of the Option universe are the daily, pre-calculated values based on the end of the previous trading day. To get the intraday values or to customize the Greeks and IV calculations, create some Option indicators.

The History<OptionUniverse> method represents each contract with an OptionUniverse object, which have the following properties:

Selection Frequency

By default, Index Option universes run at the first time step of each day to select their contracts.

Examples

The following examples demonstrate some common Index Option universes.

Example 1: 0DTE Contracts

0DTE Options are Option contracts that expire on the same day you trade them. The following algorithm selects 0DTE Option contracts for the SPX Index that fall within 3 strikes of the underlying price.

Select Language:

public class ZeroDTEIndexOptionUniverseAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        var index = AddIndex("SPX");
        var indexOption = AddIndexOption(index.Symbol, "SPXW");
        indexOption.SetFilter(u => u.IncludeWeeklys().Expiration(0, 0).Strikes(-3, 3));
    }
}

class ZeroDTEIndexOptionUniverseAlgorithm(QCAlgorithm):

    def initialize(self):
        index = self.add_index('SPX')
        index_option = self.add_index_option(index.symbol, 'SPXW')
        index_option.set_filter(lambda u: u.include_weeklys().expiration(0, 0).strikes(-3, 3))

For trading full examples of Index Option Universe, please refer to the Securities > Index Options > Requesting Data > Universes page.

You can also see our Videos. You can also get in touch with us via Discord.

Did you find this page helpful?

Contribute to the documentation:

SIGN IN

Browse

Cloud Platform

Writing Algorithms

▶Key Concepts

Initialization

▶Securities

▶Portfolio

▶Universes

▶Datasets

▶Importing Data

▶Consolidating Data

▶Historical Data

▶Trading and Orders

▶Reality Modeling

Scheduled Events

▶Indicators

Object Store

▶Optimization

▶Machine Learning

▶Algorithm Framework

Charting

Logging

▶Statistics

▶Live Trading

Strategy Library

API Reference

▶Migrations

Research Environment

Local Platform

LEAN CLI

LEAN Engine

Hello

Universes

Index Options

Introduction

Create Universes

Create Non-Standard Universes

Create Standard Universes

Filter by Investment Strategy

Filter by Implied Volatility and Greeks

Filter by Other Contract Properties

Default Filter

Navigate Intraday Option Chains

Navigate Daily Option Chains

Greeks and Implied Volatility

Historical Data

Selection Frequency

Examples

Example 1: 0DTE Contracts

▶
Key Concepts

▶
Securities

▶
Portfolio

▶
Universes

▶
Datasets

▶
Importing Data

▶
Consolidating Data

▶
Historical Data

▶
Trading and Orders

▶
Reality Modeling

▶
Indicators

▶
Optimization

▶
Machine Learning

▶
Algorithm Framework

▶
Statistics

▶
Live Trading

▶
Migrations