VIX Call Calendar Spread and Hedges

Article Strategy library · Author: QuantConnect

Summary

This algorithm demonstrates a VIX weekly call calendar spread paired with short positions in VXZ and SPY. It selects an at-the-money strike, sells the nearest-expiring call, buys the furthest-expiring call in the filtered chain, and submits the option and ETF legs together as a combo order. The position size is based on portfolio value divided by the sum of the legs’ price exposures, with the index option contract multiplier included.

The example tracks the nearer call’s expiration and liquidates as it approaches, then waits until no leg is invested before seeking another spread. Its stated data covers a one-year period, but the document supplies no performance results, rationale for the two ETF hedge quantities, or evidence that the hedge offsets the spread’s risks. The code is an implementation example, not a validated trading recommendation; its sizing and expiry handling may need review for a live strategy.

Key ideas

The example sells a near-term at-the-money VIX call and buys a later-expiring call at the same strike.
It adds short VXZ and SPY legs to the option spread.
Position quantity is scaled using total portfolio value and the price exposure of all legs.
The algorithm liquidates near the shorter call’s expiration and waits for existing legs to clear before reopening.
No backtest performance or hedge rationale is provided.

Tags

Options Volatility Multi-asset Execution

Full text

# IndexOptionCallCalendarSpreadAlgorithm


# IndexOptionCallCalendarSpreadAlgorithm









## 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 *

class IndexOptionCallCalendarSpreadAlgorithm(QCAlgorithm):

    def initialize(self):
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.set_cash(50000)

        self.vxz = self.add_equity("VXZ", Resolution.MINUTE).symbol
        self.spy = self.add_equity("SPY", Resolution.MINUTE).symbol

        index = self.add_index("VIX", Resolution.MINUTE).symbol
        option = self.add_index_option(index, "VIXW", Resolution.MINUTE)
        option.set_filter(lambda x: x.strikes(-2, 2).expiration(15, 45))
        
        self.vixw = option.symbol
        self.multiplier = option.symbol_properties.contract_multiplier
        self.legs = []
        self.expiry = datetime.max

    def on_data(self, slice: Slice) -> None:
        # Liquidate if the shorter term option is about to expire
        if self.expiry < self.time + timedelta(2) and all([slice.contains_key(x.symbol) for x in self.legs]):
            self.liquidate()
        # Return if there is any opening position
        elif [leg for leg in self.legs if self.portfolio[leg.symbol].invested]:
            return

        # Get the OptionChain
        chain = slice.option_chains.get(self.vixw)
        if not chain: return

        # Get ATM strike price
        strike = sorted(chain, key = lambda x: abs(x.strike - chain.underlying.value))[0].strike
        
        # Select the ATM call Option contracts and sort by expiration date
        calls = sorted([i for i in chain if i.strike == strike and i.right == OptionRight.CALL], 
                        key=lambda x: x.expiry)
        if len(calls) < 2: return
        self.expiry = calls[0].expiry

        # Create combo order legs
        self.legs = [
            Leg.create(calls[0].symbol, -1),
            Leg.create(calls[-1].symbol, 1),
            Leg.create(self.vxz, -100),
            Leg.create(self.spy, -10)
        ]
        quantity = self.portfolio.total_portfolio_value // \
            sum([abs(self.securities[x.symbol].price * x.quantity * 
                 (self.multiplier if x.symbol.id.security_type == SecurityType.INDEX_OPTION else 1))
                 for x in self.legs])
        self.combo_market_order(self.legs, -quantity, asynchronous=True)
```

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.

VIX Call Calendar Spread with VXZ and SPY Hedges

Summary

Key ideas

Tags