---
title: "Protective Collar"
description: "A Protective Collar is an Options strategy that consists of a covered call and a long put with a lower strike price than the short call contract."
canonical: https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/option-strategies/protective-collar
markdown: https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/option-strategies/protective-collar.md
language: python
source: https://github.com/QuantConnect/Documentation/tree/master/03%20Writing%20Algorithms/22%20Trading%20and%20Orders/08%20Option%20Strategies/23%20Protective%20Collar
modified: 2026-10-31
index: https://www.quantconnect.com/llms.txt
---

# Protective Collar

[Documentation](https://www.quantconnect.com/docs/v2.md) > [Writing Algorithms](https://www.quantconnect.com/docs/v2/writing-algorithms.md) > Trading and Orders > [Option Strategies](https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/option-strategies.md) > Protective Collar

> Code examples are shown in Python. Append `?lang=csharp` to this URL for the C# version of this page.

## Introduction

A **Protective Collar** is an Options strategy that consists of a [covered call](https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/option-strategies/covered-call.md) and a long put ([protective put](https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/option-strategies/protective-put.md)) 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 `initialize` method, set the start date, set the end date, [subscribe to the underlying Equity](https://www.quantconnect.com/docs/v2/writing-algorithms/securities/asset-classes/us-equity/requesting-data.md#02-Create-Subscriptions), and create an [Option universe](https://www.quantconnect.com/docs/v2/writing-algorithms/universes/equity-options.md).
   ```python
   def initialize(self) -> None:
       self.set_start_date(2024, 9, 1)
       self.set_end_date(2024, 12, 31)
       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.protective_collar(30, -1, -10))
   ```
   The `protective_collar` filter narrows the universe down to just the two contracts you need to form a protective collar.
2. In the `on_data` method, select the Option contracts.
   ```python
   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 `on_data` method, select the contracts and place the orders.
   **Approach A:** Call the `OptionStrategies.protective_collar` method with the details of each leg and then pass the result to the `buy` method.
   ```python
   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_order](https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/order-types/combo-market-orders.md), [combo_limit_order](https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/order-types/combo-limit-orders.md), or [combo_leg_limit_order](https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/order-types/combo-leg-limit-orders.md) method.
   ```python
   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} $$

In this example, the underlying stock traded at $833.17 at expiration. You held the underlying, bought a put at a strike of $822.50 for $6.00, and sold a call at a strike of $845.00 for $2.85.

The following chart shows the payoff at expiration:

![Protective Collar strategy payoff at expiration](https://cdn.quantconnect.com/docs/i/writing-algorithms/trading-and-orders/option-strategies/protective-collar.png)

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](https://www.quantconnect.com/docs/v2/writing-algorithms/reality-modeling/options-models/assignment.md) on the contract you sell.

## Example

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

| Asset | Price ($) | Strike ($) |
| --- | --- | --- |
| Call | 2.85 | 845.00 |
| Put | 6.00 | 822.50 |
| Underlying Equity at position opens | 833.17 | - |
| Underlying Equity at expiration | 843.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:

```python
class ProtectiveCollarOptionStrategy(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        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.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}")
```