Option Chain Filtering and Selection

Article Strategy library · Author: QuantConnect

Summary

This example shows how to add an equity option chain, restrict eligible contracts by strike distance and expiration, and select a contract from the resulting chain. The filter keeps standard contracts within two strikes of the underlying and with expirations from zero to 180 days. When the algorithm is not already invested and the market is open, it retrieves the chain and sorts contracts by proximity to the underlying price, expiration, and option right. It then submits a market order for one contract and a market-on-close order to sell one.

The example uses GOOG and sets the underlying equity as its benchmark; its configured date range is a single day in December 2015. It is an API usage demonstration, not an evaluated trading strategy: no selection rationale beyond the sorting rules, option valuation method, risk controls, or performance evidence is provided. The paired orders illustrate order submission, but actual fills and position behavior depend on data availability and platform execution semantics.

Key ideas

The example adds an option chain for an underlying equity and filters contracts by strike distance and expiration.
It retrieves the chain only when the algorithm is not invested and the option market is open.
Contracts are sorted using distance from at-the-money, expiration, and option right.
The selected contract receives a market buy order and a market-on-close sell order.
The example demonstrates platform mechanics and provides no evidence of a profitable selection strategy.

Tags

Options Equities Execution

Full text

# BasicTemplateOptionsAlgorithm


# BasicTemplateOptionsAlgorithm









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, and 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, and 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 BasicTemplateOptionsAlgorithm(QCAlgorithm):
    underlying_ticker = "GOOG"

    def initialize(self):
        self.set_start_date(2015, 12, 24)
        self.set_end_date(2015, 12, 24)
        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 strike/expiry filter for this option chain
        option.set_filter(lambda u: (u.standards_only().strikes(-2, +2)
                                     # Expiration method accepts TimeSpan objects or integer for days.
                                     # The following statements yield the same filtering criteria
                                     .expiration(0, 180)))
                                     #.expiration(TimeSpan.zero, TimeSpan.from_days(180))))

        # use the underlying equity as the benchmark
        self.set_benchmark(equity.symbol)

    def on_data(self, slice):
        if self.portfolio.invested or not self.is_market_open(self.option_symbol): return

        chain = slice.option_chains.get(self.option_symbol)
        if not chain:
            return

        # we sort the contracts to find at the money (ATM) contract with farthest expiration
        contracts = sorted(sorted(sorted(chain, \
            key = lambda x: abs(chain.underlying.price - x.strike)), \
            key = lambda x: x.expiry, reverse=True), \
            key = lambda x: x.right, reverse=True)

        # if found, trade it
        if len(contracts) == 0: return
        symbol = contracts[0].symbol
        self.market_order(symbol, 1)
        self.market_on_close_order(symbol, -1)

    def on_order_event(self, order_event):
        self.log(str(order_event))

```

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.

Selecting an At-the-Money Option by Expiration and Strike Filters

Summary

Key ideas

Tags