Universes

public class BasicOptionAlgorithm : QCAlgorithm
{
    private Symbol _symbol;
    
    public override void Initialize()
    {
        UniverseSettings.Asynchronous = true;
        var option = AddOption("SPY");
        option.SetFilter(Filter);
        _symbol = option.Symbol;
    }

    private OptionFilterUniverse Filter(OptionFilterUniverse universe)
    {
        return universe.IncludeWeeklys().Expiration(0, 7).Delta(0.35m, 0.75m);
    } 

    public override void OnData(Slice data)
    {
        if (data.OptionChains.TryGetValue(_symbol, out var chain))
        {
            var contract = chain.OrderBy(x => x.Greeks.Delta).FirstOrDefault();   
        } 
    }
}

class BasicOptionAlgorithm(QCAlgorithm):
    
    def initialize(self):
        self.universe_settings.asynchronous = True
        option = self.add_option("SPY")
        option.set_filter(self._filter)
        self._symbol = option.symbol

    def _filter(self, universe):
        return universe.include_weeklys().expiration(0, 7).delta(0.35, 0.75)

    def on_data(self, data):
        chain = data.option_chains.get(self._symbol)
        if chain:
            contract = sorted(chain, key=lambda x: (x.expiry, x.greeks.delta))[0]

// Example 1: Select a Straddle
option.SetFilter(optionFilterUniverse => optionFilterUniverse.Straddle(30, 5, 10));

// Example 2: Select the contracts (including weeklys) that expire in the next 30 days that form an Iron Condor
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().Strikes(-20, 20).Expiration(0, 30).IronCondor(30, 5, 10));

// Example 3: Select the 0DTE contracts that form an Strangle
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().Expiration(0, 0).Strangle(30, 5, -10));

# Example 1: Select a Straddle
option.set_filter(lambda option_filter_universe: option_filter_universe.straddle(30, 5, 10))

# Example 2: Select the contracts (including weeklys) that expire in the next 30 days that form an Iron Condor
option.set_filter(lambda option_filter_universe: option_filter_universe.include_weeklys().strikes(-20, 20).expiration(0, 30).iron_condor(30, 5, 10))

# Example 3: Select the 0DTE contracts that form an Strangle
option.set_filter(lambda option_filter_universe: option_filter_universe.include_weeklys().expiration(0, 0).strangle(30, 5, -10))

// Example 1: Select the contracts with delta between 0.25 and 0.75
option.SetFilter(optionFilterUniverse => optionFilterUniverse.Delta(0.25m, 0.75m));

// Example 2: Select the contracts (including weeklys) that expire in the next 90 days with implied volatility below 20% 
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().IV(0, 20).Expiration(0, 90));

// Example 3: Select the contracts (including weeklys) that expire in the next 30 days with implied volatility below 20% that forms an Iron Condor
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().IV(0, 20).Expiration(0, 30).IronCondor(30, 5, 10));

# Example 1: Select the contracts with delta between 0.25 and 0.75
option.set_filter(lambda option_filter_universe: option_filter_universe.delta(0.25, 0.75))

# Example 2: Select the contracts (including weeklys) that expire in the next 90 days with implied volatility below 20% 
option.set_filter(lambda option_filter_universe: option_filter_universe.include_weeklys().iv(0, 20).expiration(0, 90))

# Example 3: Select the contracts (including weeklys) that expire in the next 30 days with implied volatility below 20% that forms an Iron Condor
option.set_filter(lambda option_filter_universe: option_filter_universe.include_weeklys().iv(0, 20).expiration(0, 30).iron_condor(30, 5, 10))

// Select the put contracts with the lowest strike price.
option.SetFilter(Selector);
    
private OptionFilterUniverse Selector(OptionFilterUniverse optionFilterUniverse)
{
    return universe
        .Delta(0.5m, 1.5m)
        .Gamma(0.0001m, 0.0006m)
        .Vega(0.01m, 1.5m)
        .Theta(-2.0m, -0.5m)
        .Rho(0.5m, 3.0m)
        .ImpliedVolatility(1.0m, 3.0m)
        .OpenInterest(100, 500);
}

# Select the put contracts with the lowest strike price.
option.set_filter(self._contract_selector)
    
def _contract_selector(self, option_filter_universe: OptionFilterUniverse) -> OptionFilterUniverse:
    return option_filter_universe \
        .delta(0.5, 1.5) \
        .gamma(0.0001, 0.0006) \
        .vega(0.01, 1.5) \
        .theta(-2.0, -0.5) \
        .rho(0.5, 3.0) \
        .implied_volatility(1, 3) \
        .open_interest(100,500)

// Select contracts that have a strike price within 1 strike level above and below the underlying price
option.SetFilter(minStrike: -1, maxStrike: 1);

// Select contracts that expire within 30 days
option.SetFilter(minExpiry: TimeSpan.FromDays(0), maxExpiry: TimeSpan.FromDays(30));

// Select contracts that have a strike price within 1 strike level and expire within 30 days
option.SetFilter(minStrike: -1, maxStrike: 1, minExpiry: TimeSpan.FromDays(0), maxExpiry: TimeSpan.FromDays(30));

// Select call contracts
option.SetFilter(optionFilterUniverse => optionFilterUniverse.CallsOnly());

# Select contracts that have a strike price within 1 strike level above and below the underlying price
option.set_filter(min_strike=-1, max_strike=1)

# Select contracts that expire within 30 days
option.set_filter(min_expiry=timedelta(days=0), maxExpiry=timedelta(days=30))

# Select contracts that have a strike price within 1 strike level and expire within 30 days
option.set_filter(min_strike=-1, max_strike=1, min_expiry=timedelta(days=0), maxExpiry=timedelta(days=30))

# Select call contracts
option.set_filter(lambda option_filter_universe: option_filter_universe.calls_only())

// Example 1: Select the front month call contracts
option.SetFilter(optionFilterUniverse => optionFilterUniverse.CallsOnly().FrontMonth());

// Example 2: Select the contracts (including weeklys) that expire in the next 90 days
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().Strikes(-20, 20).Expiration(0, 90));

// Example 3: Select the contracts (including weeklys) that expire in the next 30 days that form an Iron Condor
option.SetFilter(optionFilterUniverse => optionFilterUniverse.IncludeWeeklys().Strikes(-20, 20).Expiration(0, 30).IronCondor(30, 5, 10));

# Example 1: Select the front month call contracts
option.set_filter(lambda option_filter_universe: option_filter_universe.calls_only().front_month())

# Example 2: Select the contracts (including weeklys) that expire in the next 90 days
option.set_filter(lambda option_filter_universe: option_filter_universe.include_weeklys().strikes(-20, 20).expiration(0, 90))

public override void OnData(Slice slice)
{
    // Try to get the OptionChain using the canonical symbol
    if (slice.OptionChains.TryGetValue(_symbol, out var chain))
    {
        // Example: Find 5 put contracts that are closest to at-the-money (ATM) and have the farthest expiration
        var contracts = chain
            .Where(x => x.Right == OptionRight.Put)
            .OrderByDescending(x => x.Expiry)
            .ThenBy(x => Math.Abs(chain.Underlying.Price - x.Strike))
            .Take(5);

        // Select the contract with the delta closest to -0.5
        var contract = contracts.OrderBy(x => Math.Abs(-0.5m - x.Greeks.Delta)).FirstOrDefault();
    }
}

def on_data(self, slice: Slice) -> None:
    # Try to get the OptionChain using the canonical symbol
    chain = slice.option_chains.get(self._symbol)
    if chain:
        # Example: Find 5 put contracts that are closest to at-the-money (ATM) and have the farthest expiration
        contracts = [x for x in chain if x.right == OptionRight.PUT]
        contracts = sorted(sorted(contracts, \
            key = lambda x: abs(chain.underlying.price - x.strike)), \
            key = lambda x: x.expiry, reverse=True)[:5]
    
        # Select the contract with the delta closest to -0.5
        contract = sorted(contracts, key=lambda x: abs(-0.5 - x.greeks.delta))[0]

public override void OnData(Slice slice)
{
    // Iterate all received Canonical Symbol-OptionChain key-value pairs
    foreach (var kvp in slice.OptionChains)
    {
        var canoncialSymbol = kvp.Key;
        var chain = kvp.Value;
        var contracts = chain.Contracts;
    }
}

def on_data(self, slice: Slice) -> None:
    # Iterate all received Canonical Symbol-OptionChain key-value pairs
    for canonical_symbol, chain in slice.option_chains.items():
        contracts = chain.contracts

// In the initialize method, create a Scheduled Event to get the Option 
// chain and rebalance the portfolio.
Schedule.On(DateRules.WeekStart(_symbol), TimeRules.AfterMarketOpen(_symbol, 1), Rebalance);

public void Rebalance()
{
    foreach (var optionUniverse in OptionChain(_symbol)) 
    {
        var close = optionUniverse.Close;
        var oi = optionUniverse.OpenInterest;
        var delta = optionUniverse.Greeks.Delta;
    }
}

# In the initialize method, create a Scheduled Event to get the Option 
# chain and rebalance the portfolio.
self.schedule.on(
    self.date_rules.week_start(self._symbol), 
    self.time_rules.after_market_open(self._symbol, 1), 
    self._rebalance
  )

# Define the method.
def _rebalance(self):
    daily_option_chain = self.option_chain(self._symbol)

    # Get the DataFrame format.
    df = daily_option_chain.data_frame
    delta_by_symbol = df.delta
    
    # Get the OptionUniverse objects format.
    for option_universe in daily_option_chain:
        close = option_universe.close
        oi = option_universe.open_interest
        delta = option_universe.greeks.delta

public override void Initialize()
{
    var option = AddOption("SPY");
    option.SetFilter(universe => universe.IncludeWeeklys().Delta(0.3m, 0.7m).Expiration(0, 7);
}

def initialize(self):
    option = self.add_option("SPY")
    option.set_filter(lambda universe: universe.include_weeklys().delta(0.3, 0.7).expiration(0,7))

// Set PriceModel property to use the Crank-Nicolson finite-difference model to price the Options.
option.PriceModel = OptionPriceModels.CrankNicolsonFD();

// Set price_model field to use the Crank-Nicolson finite-difference model to price the Options.
option.price_model = OptionPriceModels.crank_nicolson_fd()

public class OptionHistoryAlgorithm : QCAlgorithm
{       
    public override void Initialize()
    {
        SetStartDate(2020, 1, 1);
        var option = AddOption("SPY");
        var history = History<OptionUniverse>(option.Symbol, 5);
        foreach (var chain in history)
        {
            var endTime = chain.EndTime;
            var filteredContracts = chain.Data
                .Select(contract => contract as OptionUniverse)
                .Where(contract => contract.Greeks.Delta > 0.3m);
            foreach (var contract in filteredContracts)
            {
                var price = contract.Price;
                var iv = contract.ImpliedVolatility;
            }
        }
    }
}

class OptionHistoryAlgorithm(QCAlgorithm):

    def initialize(self):
        self.set_start_date(2020, 1, 1)
        option = self.add_option('SPY')
        history = self.history[OptionUniverse](option.symbol, 5)
        for chain in history:
            end_time = chain.end_time
            filtered_contracts = [c for c in chain if c.greeks.delta > 0.3]
            for contract in filtered_contracts:
                symbol = contract.symbol
                expiry = contract.id.date
                strike = contract.id.strike_price
                price = contract.close
                iv = contract.implied_volatility

public class ZeroDTEOptionUniverseAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        var option = AddOption("SPY");
        option.SetFilter(u => u.IncludeWeeklys().Expiration(0, 0).Strikes(-3, 3));
    }
}

class ZeroDTEOptionUniverseAlgorithm(QCAlgorithm):

    def initialize(self):
        option = self.add_option('SPY')
        option.set_filter(lambda u: u.include_weeklys().expiration(0, 0).strikes(-3, 3))