Equity Options

Before you can subscribe to an Option contract, you must configure the underlying Equity and get the contract Symbol.

Configure the Underlying Equity

If you want to subscribe to the underlying Equity in the Initialize method, set the Equity data normalization to DataNormalizationMode.Raw.

_symbol = AddEquity("SPY", dataNormalizationMode: DataNormalizationMode.Raw).Symbol;

self.symbol = self.AddEquity("SPY", dataNormalizationMode=DataNormalizationMode.Raw).Symbol

If your algorithm has a dynamic universe of Equities, before you add the Equity universe in the Initialize method, set the universe data normalization mode to DataNormalizationMode.Raw.

UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;

self.UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw

If you subscribe to an Equity Option contract but don't have a subscription to the underlying Equity, LEAN automatically subscribes to the underlying Equity with the following settings:

In this case, you still need the Equity Symbol to subscribe to Equity Option contracts. If you don't have access to it, create it.

_symbol = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);

self.symbol = Symbol.Create("SPY", SecurityType.Equity, Market.USA)

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

Get Contract Symbols

To subscribe to an Option contract, you need the contract Symbol. You can get the contract Symbol from the CreateOption method or from the OptionChainProvider. If you use the CreateOption method, you need to provide the details of an existing contract.

_contractSymbol = QuantConnect.Symbol.CreateOption(_symbol, Market.USA,
    OptionStyle.American, OptionRight.Call, 365, new DateTime(2022, 6, 17));

self.contract_symbol = Symbol.CreateOption(self.symbol, Market.USA,
    OptionStyle.American, OptionRight.Call, 365, datetime(2022, 6, 17))

Another way to get an Option contract Symbol is to use the OptionChainProvider. The GetOptionContractList method of OptionChainProvider returns a list of Symbol objects that reference the available Option contracts for a given underlying Equity on a given date. To filter and select contracts, you can use the following properties of each Symbol object:

var contractSymbols = OptionChainProvider.GetOptionContractList(_symbol, Time);
var expiry = contractSymbols.Select(symbol => symbol.ID.Date).Min();
var filteredSymbols = contractSymbols.Where(symbol => symbol.ID.Date == expiry && symbol.ID.OptionRight == OptionRight.Call);
_contractSymbol = filteredSymbols.OrderByDescending(symbol => symbol.ID.StrikePrice).Last();

contract_symbols = self.OptionChainProvider.GetOptionContractList(self.symbol, self.Time)
expiry = min([symbol.ID.Date for symbol in contract_symbols])
filtered_symbols = [symbol for symbol in contract_symbols if symbol.ID.Date == expiry and symbol.ID.OptionRight == OptionRight.Call]
self.contract_symbol = sorted(filtered_symbols, key=lambda symbol: symbol.ID.StrikePrice)[0]

Subscribe to Contracts

To create an Equity Option contract subscription, pass the contract Symbol to the AddOptionContract method. Save a reference to the contract Symbol so you can easily access the Option contract in the OptionChain that LEAN passes to the OnData method. This method returns an Option object. To override the default pricing model of the Option, set a pricing model.

var option = AddOptionContract(_contractSymbol);
option.PriceModel = OptionPriceModels.BinomialCoxRossRubinstein();

option = self.AddOptionContract(self.contract_symbol)
option.PriceModel = OptionPriceModels.BinomialCoxRossRubinstein()

The AddOptionContract method creates a subscription for a single Option contract and adds it to your user-defined universe. To create a dynamic universe of Option contracts, add an Equity Options universe or an Options Universe Selection model.

Warm Up Contract Prices

If you subscribe to an Option contract with AddOptionContract, you'll need to wait until the next Slice to receive data and trade the contract. To trade the contract in the same time step you subscribe to the contract, set the current price of the contract in a security initializer.

var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, seeder));

seeder = FuncSecuritySeeder(self.GetLastKnownPrices)
self.SetSecurityInitializer(BrokerageModelSecurityInitializer(self.BrokerageModel, seeder))

Supported Assets

To view the supported assets in the US Equities dataset, see the Data Explorer.

The following table shows the available resolutions and data formats for Equity Option contract subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick
Second
Minute
Hour
Daily

The default resolution for Option contract subscriptions is Resolution.Minute. To change the resolution, pass a resolution argument to the AddOptionContract method.

AddOptionContract(_contractSymbol, Resolution.Minute);

self.AddOptionContract(self.contract_symbol, Resolution.Minute)

To create custom resolution periods, see Consolidating Data.

LEAN groups all of the US Equity exchanges under Market.USA. You don't need to pass a Market argument to the AddOptionContract method because the contract Symbol already contains the market.

Fill forward means if there is no data point for the current slice, LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward argument to false when you create the security subscription.

AddOptionContract(_contractSymbol, fillForward: false);

self.AddOptionContract(self.contract_symbol, fillForward=False)

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. Options are already leveraged products, so you can't change their leverage.

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours argument when you create the security subscription.

AddOptionContract(_contractSymbol, extendedMarketHours: true);

self.AddOptionContract(self.contract_symbol, extendedMarketHours=True)

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

To view the schedule of regular and extended market hours, see Market Hours.

The data normalization mode doesn't affect the data that LEAN passes to OnData or the data from history request. By default, LEAN doesn't adjust Equity Options data for splits and dividends of their underlying. If you change the data normalization mode, it won't change the outcome.

If you hold an Option contract when a corporate action occurs for the underlying Equity, LEAN automatically closes your position.

To remove a contract subscription that you created with AddOptionContract, call the RemoveOptionContract method. This method is an alias for RemoveSecurity.

RemoveOptionContract(_contractSymbol);

self.RemoveOptionContract(self.contract_symbol)

The RemoveOptionContract method cancels your open orders for the contract and liquidates your holdings.

The AddOptionContract method returns an Option object, which have the following properties:

The Option object provides methods you can use for basic calculations. These methods require the underlying price. To get the Option object and the Security object for its underlying in any function, use the Option Symbol to access the value in the Securities object.

var option = Securities[_contractSymbol];
var underlying = Securities[_contractSymbol.Underlying];
var underlyingPrice = underlying.Price;

option = self.Securities[self.contract_symbol]
underlying = self.Securities[self.contract_symbol.Underlying]
underlying_price = underlying.Price

To get the Option payoff, call the GetPayOff method.

var payOff = option.GetPayOff(underlyingPrice);

pay_off = option.GetPayOff(underlying_price)

To get the Option intrinsic value, call the GetIntrinsicValue method.

var intrinsicValue = option.GetIntrinsicValue(underlyingPrice);

intrinsic_value = option.GetIntrinsicValue(underlying_price)

To get the Option out-of-the-money amount, call the OutOfTheMoneyAmount method.

var otmAmount = option.OutOfTheMoneyAmount(underlyingPrice);

otm_amount = option.OutOfTheMoneyAmount(underlying_price)

To check whether the Option can be automatic exercised, call the IsAutoExercised method.

var isAutoExercised = option.IsAutoExercised(underlyingPrice);

is_auto_exercised = option.IsAutoExercised(underlying_price)