---
title: "Short Iron Butterfly"
description: "The Short Iron Butterfly is the inverse of an iron butterfly."
canonical: https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/option-strategies/short-iron-butterfly
markdown: https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/option-strategies/short-iron-butterfly.md
language: python
source: https://github.com/QuantConnect/Documentation/tree/master/03%20Writing%20Algorithms/22%20Trading%20and%20Orders/08%20Option%20Strategies/16%20Short%20Iron%20Butterfly
modified: 2026-10-31
index: https://www.quantconnect.com/llms.txt
---

# Short Iron Butterfly

[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) > Short Iron Butterfly

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

## Introduction

The **Short Iron Butterfly** is an option strategy which involves four Option contracts. All the contracts have the same underlying stock and expiration, but the order of strike prices for the four contracts is $A>B>C$. The following table describes the strike price of each contract:

| Position | Strike |
| --- | --- |
| 1 OTM call | $A$ |
| -1 ATM call | $B$ |
| -1 ATM put | $B$ |
| 1 OTM put | $C=B-(A-B)$ |

The short call butterfly consists of buying an OTM call, buying an OTM put, selling an ATM call, and selling an ATM put. This strategy profits from an increase in price movement (implied volatility) and from time decay value since ATM options decay sharper.

## Implementation

Follow these steps to implement the short iron butterfly strategy:

1. In the `initialize` method, set the start date, end date, cash, and [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.iron_butterfly(30, 5));
   ```
   The `iron_butterfly` filter narrows the universe down to just the four contracts you need to form a short iron butterly.
2. In the `on_data` method, select the contracts in the strategy legs.
   ```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 expiry
       expiry = max([x.expiry for x in chain])

       # Separate the call and put contracts
       calls = [i for i in chain if i.right == OptionRight.CALL and i.expiry == expiry]
       puts = [i for i in chain if i.right == OptionRight.PUT and i.expiry == expiry]
       if not calls or not puts:
           return

       # Get the ATM and OTM strike prices
       atm_strike = sorted(calls, key = lambda x: abs(chain.underlying.price - x.strike))[0].strike
       otm_put_strike = min([x.strike for x in puts])
       otm_call_strike = 2 * atm_strike - otm_put_strike
   ```
3. In the `on_data` method, select the contracts and place the orders.
   **Approach A:** Call the `OptionStrategies.short_iron_butterfly` method with the details of each leg and then pass the result to the `buy` method.
   ```python
   short_iron_butterfly = OptionStrategies.short_iron_butterfly(self._symbol, otm_put_strike, atm_strike, otm_call_strike, expiry)
   self.buy(short_iron_butterfly, 2)
   ```
   **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
   # Select the contracts
   atm_call = [x for x in calls if x.strike == atm_strike][0]
   atm_put = [x for x in puts if x.strike == atm_strike][0]
   otm_call = [x for x in calls if x.strike == otm_call_strike][0]
   otm_put = [x for x in puts if x.strike == otm_put_strike][0]

   legs = [
       Leg.create(atm_call.symbol, 1),
       Leg.create(atm_put.symbol, 1),
       Leg.create(otm_call.symbol, -1),
       Leg.create(otm_put.symbol, -1)
   ]
   self.combo_market_order(legs, 1)
   ```

## Strategy Payoff

The short iron butterfly is a limited-reward-limited-risk strategy. The payoff is

$$ \begin{array}{rcll} C^{OTM}_T & = & (S_T - K^C_{OTM})^{+}\\ C^{ATM}_T & = & (S_T - K^C_{ATM})^{+}\\ P^{OTM}_T & = & (K^P_{OTM} - S_T)^{+}\\ P^{ATM}_T & = & (K^P_{ATM} - S_T)^{+}\\ P_T & = & (C^{ATM}_T + P^{ATM}_T - C^{OTM}_T - P^{OTM}_T - C^{ATM}_0 - P^{ATM}_0 + C^{OTM}_0 + P^{OTM}_0)\times m - fee \end{array} $$ $$ \begin{array}{rcll} \textrm{where} & C^{OTM}_T & = & \textrm{OTM call value at time T}\\ & C^{ATM}_T & = & \textrm{ATM call value at time T}\\ & P^{OTM}_T & = & \textrm{OTM put value at time T}\\ & P^{ATM}_T & = & \textrm{ATM put value at time T}\\ & S_T & = & \textrm{Underlying asset price at time T}\\ & K^C_{OTM} & = & \textrm{OTM call strike price}\\ & K^C_{ATM} & = & \textrm{ATM call strike price}\\ & K^P_{OTM} & = & \textrm{OTM put strike price}\\ & K^P_{ATM} & = & \textrm{ATM put strike price}\\ & P_T & = & \textrm{Payout total at time T}\\ & C^{OTM}_0 & = & \textrm{OTM call value at position opening (credit received)}\\ & C^{ATM}_0 & = & \textrm{ATM call value at position opening (debit paid)}\\ & P^{OTM}_0 & = & \textrm{OTM put value at position opening (credit received)}\\ & P^{ATM}_0 & = & \textrm{ATM put value at position opening (debit paid)}\\ & m & = & \textrm{Contract multiplier}\\ & T & = & \textrm{Time of expiration} \end{array} $$

In this example, the underlying stock price at expiration is $843.25. You traded an OTM call at $855.00 for $2.35, an OTM put at $810.00 for $2.75, an ATM call at $832.50 for $8.10, and an ATM put at $832.50 for $7.40.

The following chart shows the payoff at expiration:

![Short Iron Butterfly strategy payoff at expiration](https://cdn.quantconnect.com/docs/i/writing-algorithms/trading-and-orders/option-strategies/short-iron-butterfly.png)

The maximum profit is $K^C_{OTM} - K^C_{ATM} - C^{ATM}_0 - P^{ATM}_0 + C^{OTM}_0 + P^{OTM}_0$. It occurs when the underlying price is below the OTM put strike price or above the OTM call strike price at expiration.

The maximum loss is the net debit paid, $C^{OTM}_0 + P^{OTM}_0 - C^{ATM}_0 - P^{ATM}_0$. It occurs when the underlying price stays the same as when you opened the trade.

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 contracts you sell.

## Example

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

| Asset | Price ($) | Strike ($) |
| --- | --- | --- |
| OTM call | 2.35 | 855.00 |
| OTM put | 2.75 | 810.00 |
| ATM call | 8.10 | 832.50 |
| ATM put | 7.40 | 832.50 |
| Underlying Equity at expiration | 843.25 | - |

Therefore, the payoff is

$$ \begin{array}{rcll} C^{OTM}_T & = & (S_T - K^C_{OTM})^{+}\\ & = & (843.25-855.00)^{+}\\ & = & 0\\ C^{ATM}_T & = & (S_T - K^C_{ATM})^{+}\\ & = & (843.25-832.50)^{+}\\ & = & 10.75\\ P^{OTM}_T & = & (K^P_{OTM} - S_T)^{+}\\ & = & (810.00-843.25)^{+}\\ & = & 0\\ P^{ATM}_T & = & (K^P_{ATM} - S_T)^{+}\\ & = & (832.50.00-843.25)^{+}\\ & = & 0\\ P_T & = & (C^{OTM}_T + P^{OTM}_T - C^{ATM}_T - P^{ATM}_T - C^{OTM}_0 - P^{OTM}_0 + C^{ATM}_0 + P^{ATM}_0)\times m - fee\\ & = & (0+0-10.75-0-2.35-2.75+8.10+7.40)\times100-1\times4\\ & = & -39 \end{array} $$

So, the strategy losses $39.

The following algorithm implements a short iron butterfly Option strategy:

```python
class ShortButteflyOptionStrategy(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(100000)

        option = self.add_option("GOOG", Resolution.MINUTE)
        self._symbol = option.symbol

        # set our strike/expiry filter for this option chain
        option.set_filter(lambda x: x.iron_butterfly(30, 5))

    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 expiry
        expiry = max([x.expiry for x in chain])

        # Separate the call and put contracts
        calls = [i for i in chain if i.right == OptionRight.CALL and i.expiry == expiry]
        puts = [i for i in chain if i.right == OptionRight.PUT and i.expiry == expiry]
        if not calls or not puts:
            return

        # Get the ATM and OTM strike prices
        atm_strike = sorted(calls, key = lambda x: abs(x.strike - chain.underlying.price))[0].strike
        otm_put_strike = min([x.strike for x in puts])
        otm_call_strike = 2 * atm_strike - otm_put_strike

        short_iron_butterfly = OptionStrategies.short_iron_butterfly(self._symbol, otm_put_strike, atm_strike, otm_call_strike, expiry)
        self.buy(short_iron_butterfly, 1)
```