Equity · United States · futures · Daily · United States Free

VIX Put-Call Volume Ratio

Academic paper

The Information Content of the VIX Options Trading Volume

AuthorsChen Gu; Xu Guo; Alexander Kurov; Raluca Stan

Institute

Shanghai Business School
?Shanghai Business School - Research Center of Finance
Shenzhen University
?Shenzhen University - College of Economics
West Virginia University
?West Virginia University - College of Business & Economics
University of Minnesota, Duluth
?University of Minnesota Duluth

Paper linkhttps://papers.ssrn.com/sol3/papers.cfm?abstract_id=3975868

Strategy in a nutshell

The investment universe consists of nearby VIX futures contracts, with the next-to-maturity contract selected when its daily trading volume is higher. Volume data are sourced from CBOE, and futures data from Genesis Financial Technologies. First, compute the daily aggregated put-call volume ratio using the trading volume of VIX puts and calls initiated by buyers opening new positions. The ratio is calculated as put volume divided by the sum of put and call volumes. Next, calculate the z-score of the put-call ratio using an expanding timeframe (initial normalization performed after 600 days). If the z-score exceeds 0.75, take a short position in VIX futures, which is closed the following day.

Economic rationale

Research indicates that sophisticated and informed investors actively use options. Consistent with prior literature, the strategy assumes that informed traders use VIX options to express their market views. The aggregated trading volume of these traders reflects valuable information, allowing the put-call ratio to predict subsequent VIX movements. This predictive power remains robust even after controlling for economic and financial variables such as term spreads, credit spreads, T-bill spreads, or lagged S&P 500 returns. The effect is persistent, stronger when VIX levels are high, and holds across both recessionary and expansionary periods.

Backtest performance

Annualised return50.02%

Volatility43.8%

Sharpe ratio0.93

Sortino ratio0.049

Win rate48%

Full Python code

1from AlgorithmImports import *
2# endregion
3
4class VIXPutCallVolumeRatio(QCAlgorithm):
5
6def Initialize(self):
7self.SetStartDate(2015, 1, 1)
8self.SetCash(100000)
9
10self.min_expiry = 25
11self.max_expiry = 35
12
13self.period = 21 * 3                # need n daily volumes
14self.min_period_len = 14            # need at least m minute volumes to calculate daily volume
15self.max_missing_days = 5
16
17self.threshold = 0.75
18
19self.current_day = -1
20
21# subscribe to VIX
22security = self.AddIndex('VIX', Resolution.Minute)
23
24# change normalization to raw to allow adding etf contracts
25security.SetDataNormalizationMode(DataNormalizationMode.Raw)
26# set fee model and leverage
27security.SetFeeModel(CustomFeeModel())
28security.SetLeverage(5)
29
30self.vix_symbol = security.Symbol
31
32self.vix_data = SymbolData(self.period)
33self.subscribed_vix_contracts = None
34
35# subscribe to Quantpedia future vix contract
36security = self.AddData(QuantpediaFutures, 'CBOE_VX1', Resolution.Daily)
37security.SetFeeModel(CustomFeeModel())
38security.SetLeverage(5)
39
40self.last_quantpedia_VIX_date = None
41self.quantpedia_VIX_symbol = security.Symbol
42
43def OnData(self, data):
44curr_date = self.Time.date()
45
46# track quantpedia VIX data
47if self.quantpedia_VIX_symbol in data and data[self.quantpedia_VIX_symbol]:
48    self.last_quantpedia_VIX_date = curr_date
49
50# trade on open
51if self.current_day != self.Time.day:
52    self.Liquidate()
53
54    # options volumes data has to be ready and quantpedia VIX data has to be still coming
55    if self.vix_data.daily_volumes_ready() and (self.last_quantpedia_VIX_date - curr_date).days <= self.max_missing_days:
56        z_score = self.vix_data.z_score()
57
58        # short VIX, when z_score is above threshold
59        if z_score > self.threshold:
60            self.SetHoldings(self.quantpedia_VIX_symbol, -1)
61
62    self.current_day = self.Time.day
63
64if self.subscribed_vix_contracts is not None:
65    # check contracts expirations
66    if self.subscribed_vix_contracts.expiry_date - timedelta(days=1) <= self.Time.date():
67        # remove contracts from securities
68        for c in self.subscribed_vix_contracts.contracts:
69            self.RemoveOptionContract(c)
70        
71        # free
72        self.subscribed_vix_contracts.contracts.clear()
73        self.subscribed_vix_contracts = None
74
75    else:
76        option_contracts = self.subscribed_vix_contracts.contracts
77        # calculate option volume
78        options_volumes = [self.Securities[contract].Volume for contract in option_contracts if contract in data and data[contract]]
79        
80        # make sure all volumes were collected       
81        if len(options_volumes) == len(option_contracts):
82            self.vix_data.options_minute_volumes.append(sum(options_volumes))
83        
84        if self.Time.hour == 16 and self.Time.minute == 0 and self.vix_data.minute_volumes_ready(self.min_period_len):
85            self.vix_data.update_daily_volumes(curr_date, self.max_missing_days)
86
87# subscribe to new contracts
88else:
89    contracts = self.OptionChainProvider.GetOptionContractList(self.vix_symbol, self.Time)
90    # get current price for etf
91    underlying_price = self.Securities[self.vix_symbol].Price
92    
93    # get strikes from commodity future contracts
94    strikes = [i.ID.StrikePrice for i in contracts]
95    
96    # can't filter contracts, if there isn't any strike price
97    if len(strikes) > 0 and underlying_price != 0:
98        atm_strike = min(strikes, key=lambda x: abs(x-underlying_price))
99        itm_strike = min(strikes, key=lambda x: abs(x-(underlying_price*0.95)))
100        otm_strike = min(strikes, key=lambda x: abs(x-(underlying_price*1.05)))
101        
102        # filter calls and puts contracts with one month expiry
103        atm_calls, atm_puts = self.FilterContracts(atm_strike, contracts, underlying_price)
104        itm_calls, itm_puts = self.FilterContracts(itm_strike, contracts, underlying_price)
105        otm_calls, otm_puts = self.FilterContracts(otm_strike, contracts, underlying_price)
106        
107        # make sure, there is at least one call and put contract
108        if len(atm_calls) > 0 and len(atm_puts) > 0 and len(itm_calls) > 0 and len(itm_puts) > 0 and len(otm_calls) > 0 and len(otm_puts) > 0:
109            # sort by expiry
110            atm_call, atm_put = self.SortByExpiry(atm_calls, atm_puts)
111            itm_call, itm_put = self.SortByExpiry(itm_calls, itm_puts)
112            otm_call, otm_put = self.SortByExpiry(otm_calls, otm_puts)
113            
114            atm_call_subscriptions = self.SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(atm_call.Underlying)
115            
116            # check if stock's call and put contract was successfully subscribed
117            if atm_call_subscriptions:
118                selected_contracts = [atm_call, atm_put, itm_call, itm_put, otm_call, otm_put]
119                
120                for contract in selected_contracts:
121                    # add contract
122                    self.AddOptionContract(contract, Resolution.Minute)
123                    
124                # retrieve expiry date for contracts
125                expiry_date = atm_call.ID.Date.date() if atm_call.ID.Date.date() < atm_put.ID.Date.date() else atm_put.ID.Date.date()
126                # store contracts with expiry date
127                self.subscribed_vix_contracts = Contracts(expiry_date, underlying_price, selected_contracts)
128
129def FilterContracts(self, strike, contracts, underlying_price):
130''' filter call and put contracts from contracts parameter '''
131''' return call and put contracts '''
132
133calls = [] # storing call contracts
134puts = [] # storing put contracts
135
136for contract in contracts:
137    # check if contract has one month expiry
138    if self.min_expiry < (contract.ID.Date - self.Time).days < self.max_expiry:
139        # check if contract is call
140        if contract.ID.OptionRight == OptionRight.Call and contract.ID.StrikePrice == strike:
141            calls.append(contract)
142        # check if contract is put
143        elif contract.ID.OptionRight == OptionRight.Put and contract.ID.StrikePrice == strike:
144            puts.append(contract)
145
146# return filtered calls and puts with one month expiry
147return calls, puts
148
149def SortByExpiry(self, calls, puts):
150''' return option call and option put with farest expiry '''
151
152call = sorted(calls, key = lambda x: x.ID.Date, reverse=True)[0]
153put = sorted(puts, key = lambda x: x.ID.Date, reverse=True)[0]
154
155return call, put
156
157class SymbolData:
158def __init__(self, period):
159self.options_minute_volumes = []
160
161self.options_daily_volumes = RollingWindow[float](period)
162
163self.last_update_daily_volumes = None
164
165def update_daily_volumes(self, curr_date, max_missing_days):
166if self.last_update_daily_volumes != None and (curr_date - self.last_update_daily_volumes).days > max_missing_days:
167    # reset rollingwindow, when there is a big gap between storing daily volumes
168    self.options_daily_volumes.Reset()
169
170self.options_daily_volumes.Add(sum(self.options_minute_volumes))
171self.last_update_daily_volumes = curr_date
172self.options_minute_volumes.clear()
173
174def z_score(self):
175daily_volumes = [x for x in self.options_daily_volumes]
176
177last_daily_volumes = daily_volumes[0]
178
179return (last_daily_volumes - np.mean(daily_volumes)) / np.std(daily_volumes)
180
181def daily_volumes_ready(self):
182return self.options_daily_volumes.IsReady
183
184def minute_volumes_ready(self, period):
185return len(self.options_minute_volumes) >= period
186
187class Contracts():
188def __init__(self, expiry_date, underlying_price, contracts):
189self.expiry_date = expiry_date
190self.underlying_price = underlying_price
191self.contracts = contracts
192
193# Custom fee model
194class CustomFeeModel(FeeModel):
195def GetOrderFee(self, parameters):
196fee = parameters.Security.Price * parameters.Order.AbsoluteQuantity * 0.00005
197return OrderFee(CashAmount(fee, "USD"))
198
199# Quantpedia data.
200# NOTE: IMPORTANT: Data order must be ascending (datewise)
201class QuantpediaFutures(PythonData):
202def GetSource(self, config, date, isLiveMode):
203return SubscriptionDataSource("data.quantpedia.com/backtesting_data/futures/{0}.csv".format(config.Symbol.Value), SubscriptionTransportMedium.RemoteFile, FileFormat.Csv)
204
205def Reader(self, config, line, date, isLiveMode):
206data = QuantpediaFutures()
207data.Symbol = config.Symbol
208
209if not line[0].isdigit(): return None
210split = line.split(';')
211
212data.Time = datetime.strptime(split[0], "%d.%m.%Y") + timedelta(days=1)
213data['back_adjusted'] = float(split[1])
214data['spliced'] = float(split[2])
215data.Value = float(split[1])
216
217return data