Filtering an Equity Option Universe by Expiry and Strike
Summary
This example shows how to add listed options for an underlying equity, narrow the contract universe, inspect the resulting chain, and submit an order for a selected contract. Its filter keeps weekly options expiring within a near-term window and excludes puts; it further limits strikes to a specified distance from the underlying price. When a chain is available, the algorithm sorts contracts and selects a call expiring that day with a strike below the underlying price, then places a market order if the portfolio is not already invested.
The example uses an equity benchmark and a short late-December 2015 simulation window. It demonstrates contract filtering and chain selection mechanics rather than a tested trading thesis: it gives no performance evidence, exit logic, or rationale for the chosen contract. Same-day expiry and market execution can carry substantial risk, and the simple invested check does not describe broader position or risk management. The code is an implementation template, not evidence that the selection rule is profitable.
Key ideas
- An options universe can be narrowed by expiry, option right, and strike distance from the underlying price.
- The option chain can be inspected to select a contract matching additional conditions.
- The example buys a call expiring that day with a strike below the underlying price.
- The algorithm avoids a new order when the portfolio is already invested.
- The example supplies no performance results or complete exit and risk management rules.
Tags
Full text
# BasicTemplateOptionsFilterUniverseAlgorithm
# BasicTemplateOptionsFilterUniverseAlgorithm
This example demonstrates how to add options for a given underlying equity security. It also shows how you can prefilter contracts easily based on strikes and expirations. It also shows how you can inspect the option chain to pick a specific option contract to trade.
## Source (Apache-2.0)
```python
# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from AlgorithmImports import *
### <summary>
### This example demonstrates how to add options for a given underlying equity security.
### It also shows how you can prefilter contracts easily based on strikes and expirations.
### It also shows how you can inspect the option chain to pick a specific option contract to trade.
### </summary>
### <meta name="tag" content="using data" />
### <meta name="tag" content="options" />
### <meta name="tag" content="filter selection" />
class BasicTemplateOptionsFilterUniverseAlgorithm(QCAlgorithm):
underlying_ticker = "GOOG"
def initialize(self):
self.set_start_date(2015, 12, 24)
self.set_end_date(2015, 12, 28)
self.set_cash(100000)
equity = self.add_equity(self.underlying_ticker)
option = self.add_option(self.underlying_ticker)
self.option_symbol = option.symbol
# Set our custom universe filter
option.set_filter(self.filter_function)
# use the underlying equity as the benchmark
self.set_benchmark(equity.symbol)
def filter_function(self, universe):
#Expires today, is a call, and is within 10 dollars of the current price
universe = universe.weeklys_only().expiration(0, 1)
return [symbol for symbol in universe
if symbol.id.option_right != OptionRight.PUT
and -10 < universe.underlying.price - symbol.id.strike_price < 10]
def on_data(self, slice):
if self.portfolio.invested: return
for kvp in slice.option_chains:
if kvp.key != self.option_symbol: continue
# Get the first call strike under market price expiring today
chain = kvp.value
contracts = [option for option in sorted(chain, key = lambda x:x.strike, reverse = True)
if option.expiry.date() == self.time.date()
and option.strike < chain.underlying.price]
if contracts:
self.market_order(contracts[0].symbol, 1)
```Shown in full with attribution under the source's licence. Licence: Apache-2.0
This summary was written by Stratmill's research agent from the original; it is not a copy of the source.