book
Checkout our new book! Hands on AI Trading with Python, QuantConnect, and AWS Learn More arrow

Option Strategies

Protective Collar

Introduction

A Protective Collar is an Options strategy that consists of a covered call and a long put (protective put) with a lower strike price than the short call contract. In contrast to the covered call, the protective put component limits the drawdown of the strategy when the underlying price decreases too much.

Implementation

Follow these steps to implement the protective collar strategy:

  1. In the Initializeinitialize method, set the start date, set the end date, subscribe to the underlying Equity, and create an Option universe.
    2. private Symbol _symbol;

public override void Initialize()
{
    SetStartDate(2017, 4, 1);
    SetEndDate(2017, 4, 30);
    SetCash(100000);

    UniverseSettings.Asynchronous = true;
    var option = AddOption("GOOG", Resolution.Minute);
    _symbol = option.Symbol;
    option.SetFilter(universe => universe.IncludeWeeklys().ProtectiveCollar(30, -1, -10));
}
    def initialize(self) -> None:
    self.set_start_date(2017, 4, 1)
    self.set_end_date(2017, 4, 30)
    self.set_cash(100000)

    self.universe_settings.asynchronous = True
    option = self.add_option("GOOG", Resolution.MINUTE)
    self._symbol = option.symbol
    option.set_filter(lambda universe: universe.include_weeklys().protective_collar(30, -1, -10))

    The ProtectiveCollarprotective_collar filter narrows the universe down to just the two contracts you need to form a protective collar.

  2. In the OnDataon_data method, select the Option contracts.
    3. public override void OnData(Slice slice)
{
    if (Portfolio.Invested) return;

    // Get the OptionChain
    if (!slice.OptionChains.TryGetValue(_symbol, out var chain)) return;

    // Select an expiry date
    var expiry = chain.Max(x => x.Expiry);

    // Select the call and put contracts that expire on the selected date
    var calls = chain.Where(x => x.Expiry == expiry && x.Right == OptionRight.Call);
    var puts = chain.Where(x => x.Expiry == expiry && x.Right == OptionRight.Put);
    if (calls.Count() == 0 || puts.Count() == 0) return;

    // Select the OTM contracts
    var call = calls.OrderBy(x => x.Strike).Last();
    var put = puts.OrderBy(x => x.Strike).First();
    def on_data(self, slice: Slice) -> None:
    if self.portfolio.invested:
        return

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

    # Select an expiry date
    expiry = max([x.expiry for x in chain])

    # Select the call and put contracts that expire on the selected date
    calls = [x for x in chain if x.right == OptionRight.CALL and x.expiry == expiry]
    puts = [x for x in chain if x.right == OptionRight.PUT and x.expiry == expiry]
    if not calls or not puts:
        return

    # Select the OTM contracts
    call = sorted(calls, key = lambda x: x.strike)[-1]
    put = sorted(puts, key = lambda x: x.strike)[0]
  3. In the OnDataon_data method, select the contracts and place the orders.

    4. Approach A: Call the OptionStrategies.ProtectiveCollarOptionStrategies.protective_collar method with the details of each leg and then pass the result to the Buybuy method.

    var protectiveCollar = OptionStrategies.ProtectiveCollar(_symbol, call.Strike, put.Strike, expiry);
Buy(protectiveCollar, 1);
    protective_collar = OptionStrategies.protective_collar(self._symbol, call.strike, put.strike, expiry)
self.buy(protective_collar, 1)

    Approach B: Create a list of Leg objects and then call the Combo Market Ordercombo_market_order, Combo Limit Ordercombo_limit_order, or Combo Leg Limit Ordercombo_leg_limit_order method.

    var legs = new List<Leg>()
    {
        Leg.Create(call.Symbol, -1),
        Leg.Create(put.Symbol, 1),
        Leg.Create(chain.Underlying.Symbol, chain.Underlying.SymbolProperties.ContractMultiplier)
    };
ComboMarketOrder(legs, 1);
    legs = [
    Leg.create(call.symbol, -1),
    Leg.create(put.symbol, 1),
    Leg.create(chain.underlying.symbol, chain.underlying.symbol_properties.contract_multiplier)
]
self.combo_market_order(legs, 1)

Strategy Payoff

This is a limited-profit-limited-loss strategy. The payoff is

$$ \begin{array}{rcll} C_T & = & (S_T - K^{C})^{+}\\ P_T & = & (K^{P} - S_T)^{+}\\ Payoff_T & = & (S_T - S_0 - C_T + P_T + C_0 - P_0)\times m - fee \end{array} $$ $$ \begin{array}{rcll} \textrm{where} & C_T & = & \textrm{Call value at time T}\\ & P_T & = & \textrm{Put value at time T}\\ & S_T & = & \textrm{Underlying asset price at time T}\\ & K^{C} & = & \textrm{Call strike price}\\ & K^{P} & = & \textrm{Put strike price}\\ & Payoff_T & = & \textrm{Payout total at time T}\\ & S_0 & = & \textrm{Underlying asset price when the trade opened}\\ & C_0 & = & \textrm{Call price when the trade opened (credit received)}\\ & P_0 & = & \textrm{Put price when the trade opened (debit paid)}\\ & m & = & \textrm{Contract multiplier}\\ & T & = & \textrm{Time of expiration} \end{array} $$

The following chart shows the payoff at expiration:

protective collar strategy payoff

The maximum profit is $K^{C} - S_T + C_0 - P_0$. It occurs when the underlying price is at or above the strike price of the call at expiration.

The maximum profit is $S_T - K^{P} + C_0 - P_0$. It occurs when the underlying price is at or below the strike price of the put at expiration.

If the Option is American Option, there is a risk of early assignment on the contract you sell.

Example

The following table shows the price details of the assets in the algorithm:

AssetPrice ($)Strike ($)
Call2.85845.00
Put6.00822.50
Underlying Equity at position opens833.17-
Underlying Equity at expiration843.25-

Therefore, the payoff is

$$ \begin{array}{rcll} C_T & = & (S_T - K^{C})^{+}\\ & = & (843.365 - 845.00)^{+}\\ & = & 0\\ P_T & = & (K^{P} - S_T)^{+}\\ & = & (822.50 - 843.365)^{+}\\ & = & 0\\ Payoff_T & = & (S_T - S_0 - C_T + P_T + C_0 - P_0)\times m - fee\\ & = & (843.25 - 833.17 - 0 + 0 + 2.85 - 6.00)\times100-1.00\times3\\ & = & 690\\ \end{array} $$

So, the strategy gains $690.

The following algorithm implements a protective collar Option strategy:

public class ProtectiveCollarStrategy : QCAlgorithm
{
    private Symbol _equity;
    private Symbol _symbol;

    public override void Initialize()
    {
        SetStartDate(2017, 4, 1);
        SetEndDate(2017, 4, 23);
        SetCash(100000);

        _equity = AddEquity("GOOG", Resolution.Minute).Symbol;
        var option = AddOption("GOOG", Resolution.Minute);
        _symbol = option.Symbol;
        option.SetFilter(universe => universe.IncludeWeeklys().ProtectiveCollar(30, -1, -10));
    }

    public override void OnData(Slice slice)
    {
        if (Portfolio.Invested) return;

        // Get the OptionChain of the symbol
        var chain = slice.OptionChains.get(_symbol, null);
        if (chain == null || chain.Count() == 0) return;

        // sort the optionchain by expiration date and choose the furthest date
        var expiry = chain.OrderBy(x => x.Expiry).Last().Expiry;

        // filter the call and put options from the contracts expires on that date
        var calls = chain.Where(x => x.Expiry == expiry && x.Right == OptionRight.Call);
        var puts = chain.Where(x => x.Expiry == expiry && x.Right == OptionRight.Put);
        if (calls.Count() == 0 || puts.Count() == 0) return;

        // select the strike prices
        var callStrike = calls.OrderBy(x => x.Strike).Last().Strike;
        var putStrike = puts.OrderBy(x => x.Strike).First().Strike;
        
        var protectiveCollar = OptionStrategies.ProtectiveCollar(_symbol, callStrike, putStrike, expiry);
        Buy(protectiveCollar, 1);
    }

    public override void OnEndOfDay(Symbol symbol)
    {
        if (symbol.Value == "GOOG")
        {
            Log($"{Time}::{symbol}::{Securities[symbol].Price}");
        }
    }
}
class ProtectiveCollarOptionStrategy(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2017, 4, 1)
        self.set_end_date(2017, 4, 23)
        self.set_cash(100000)
        
        equity = self.add_equity("GOOG", Resolution.MINUTE)
        option = self.add_option("GOOG", Resolution.MINUTE)
        self.symbol = option.symbol
        option.set_filter(lambda universe: universe.include_weeklys().protective_collar(30, -1, -10))

    def on_data(self, data: Slice) -> None:
        # avoid extra orders
        if self.portfolio.invested: return

        # Get the OptionChain of the self.symbol
        chain = data.option_chains.get(self.symbol, None)
        if not chain: return

        # choose the furthest expiration date within 30 days from now on
        expiry = sorted(chain, key = lambda x: x.expiry)[-1].expiry
        # filter the call options contracts
        call = [x for x in chain if x.right == OptionRight.CALL and x.expiry == expiry]
        # filter the put options contracts
        put = [x for x in chain if x.right == OptionRight.PUT and x.expiry == expiry]

        if not call or not put: return

        # select the strike prices of call and put contracts
        call_strike = sorted(call, key = lambda x: x.strike)[-1].strike
        put_strike = sorted(put, key = lambda x: x.strike)[0].strike

        protective_collar = OptionStrategies.protective_collar(self.symbol, call_strike, put_strike, expiry)
        self.buy(protective_collar, 1)

    def on_end_of_day(self, symbol):
        if symbol.value == "GOOG":
            self.log(f"{self.time}::{symbol}::{self.securities[symbol].price}")

You can also see our Videos. You can also get in touch with us via Discord.

Did you find this page helpful?

Contribute to the documentation: