Requesting Data

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 class EquityOptionAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        var option = AddOption("SPY");
        // Filter for 0-DTE contracts within +/-10 strike range.
        // They have the highest volatility but low premium, providing sufficient liquidity and higher profit margin.
        option.SetFilter(u => u.IncludeWeeklys().Expiration(0, 0).Strikes(-10, 10));
    }
}

class EquityOptionAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        option = self.add_option("SPY")
        # Filter for 0-DTE contracts within +/-10 strike range.
        # They have the highest volatility but low premium, providing sufficient liquidity and higher profit margin.
        option.set_filter(lambda u: u.include_weeklys().expiration(0, 0).strikes(-10, 10))

public class EquityOptionAlgorithm : QCAlgorithm
{
    private Symbol _symbol;

    public override void Initialize()
    {
        var option = AddOption("SPY");
        _symbol = option.Symbol;
        // Using Staddle() method, it will only return the best-matched ATM call and put contracts expiring after 30 days.
        // It provides better accuracy in filtering, and subscribe only to the needed contracts to save computation resources.
        option.SetFilter(u => u.IncludeWeeklys().Straddle(30));
    }
    
    public override void OnData(Slice slice)
    {
        // Only wants the option chain of the selected symbol.
        if (!Portfolio.Invested &&
            slice.OptionChains.TryGetValue(_symbol, out var chain))
        {
            // There should only be 1 expiry and 1 strike from the 2 contracts returned, getting from either contract is fine.
            var expiry = chain.First().Expiry;
            var strike = chain.First().Strike;
    
            // Forms a long straddle option strategy using abstraction method ensure accuracy.
            var longStraddle = OptionStrategies.Straddle(_symbol, strike, expiry);
            Buy(longStraddle, 1);
        }
    }
}

class EquityOptionAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        option = self.add_option("SPY")
        self._symbol = option.symbol
        # Using straddle() method, it will only return the best-matched ATM call and put contracts expiring after 30 days.
        # It provides better accuracy in filtering, and subscribe only to the needed contracts to save computation resources.
        option.set_filter(lambda u: u.include_weeklys().straddle(30))
    
    def on_data(self, slice: Slice) -> None:
        # Only wants the option chain of the selected symbol.
        chain = slice.option_chains.get(self._symbol)
        if not self.portfolio.invested and chain:
            # There should only be 1 expiry and 1 strike from the 2 contracts returned, getting from either contract is fine.
            expiry = list(chain)[0].expiry
            strike = list(chain)[0].strike
        
            # Forms a long straddle option strategy using abstraction method ensure accuracy.
            long_straddle = OptionStrategies.straddle(self._symbol, strike, expiry)
            self.buy(long_straddle, 1)

public class EquityOptionAlgorithm : QCAlgorithm
{
    private Equity _underlying;
        
    public override void Initialize()
    {
        // Seed the price with last known price to ensure the underlying price data is available on initial option contract filtering.
        SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));
        // Subscribe to underlying data for ATM calculation using the update underlying price.
        // Set data normalization mode to raw is required to ensure strike price and underlying price is comparable.
        _underlying = AddEquity("SPY", dataNormalizationMode: DataNormalizationMode.Raw);
        // Subscribe to SPY option data.
        var option = AddOption(_underlying.Symbol);
        option.SetFilter(u => u.IncludeWeeklys().Contracts((contracts) =>
        {
            var selected = new List<Symbol>();
    
            // Select the best-match put contracts that expires 30 days later that is $5 below the current underlying price.
            // We should first filter the hard requirement, then sort the reminders for faster computation.
            var puts = contracts.Where(x =>
                    x.ID.OptionRight == OptionRight.Put &&
                    x.ID.Date >= Time.AddDays(30) &&
                    x.ID.StrikePrice <= _underlying.Price - 5m
                ).ToList();
            if (puts.Count > 0)
            {
                var put = puts.OrderBy(x => x.ID.Date)
                    .ThenByDescending(x => x.ID.StrikePrice)
                    .First();
                selected.Add(put);
            }
    
            // Select the best-match call contract that expires 60 days later that is $10 above the current underlying price.
            var calls = contracts.Where(x =>
                    x.ID.OptionRight == OptionRight.Call &&
                    x.ID.Date >= Time.AddDays(60) &&
                    x.ID.StrikePrice >= _underlying.Price + 10m
                ).ToList();
            if (calls.Count > 0)
            {
                var call = calls.OrderBy(x => x.ID.Date)
                    .ThenBy(x => x.ID.StrikePrice)
                    .First();
                selected.Add(call);
            }
    
            return selected;
        }));
    }
}

class EquityOptionAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        # Seed the price with last known price to ensure the underlying price data is available on initial option contract filtering.
        self.set_security_initializer(BrokerageModelSecurityInitializer(self.brokerage_model, FuncSecuritySeeder(self.get_last_known_prices)))
        self.underlying = self.add_equity("SPY", data_normalization_mode=DataNormalizationMode.RAW)
        # Subscribe to underlying data for ATM calculation using the update underlying price.
        # Set data normalization mode to raw is required to ensure strike price and underlying price is comparable.
        option = self.add_option(self.underlying.symbol)
        option.set_filter(lambda u: u.include_weeklys().contracts(self.selection))
    
    def selection(self, contracts: List[Symbol]) -> List[Symbol]:
        selected = []
    
        # Select the best-match put contracts that expires 30 days later that is $5 below the current underlying price.
        # We should first filter the hard requirement, then sort the reminders for faster computation.
        puts = [x for x in contracts
            if x.id.option_right == OptionRight.PUT and \
            x.id.date >= self.time + timedelta(30) and \
            x.id.strike_price <= self.underlying.price - 5
        ]
        if len(puts) > 0:
            expiry = min(x.id.date for x in puts)
            put = sorted([x for x in puts if x.id.date == expiry],
                key=lambda x: x.id.strike_price,
                reverse=True)[0]
            selected.append(put)
    
        # Select the best-match call contract that expires 60 days later that is $10 above the current underlying price.
        calls = [x for x in contracts
            if x.id.option_right == OptionRight.CALL and \
            x.id.date >= self.time + timedelta(60) and \
            x.id.strike_price >= self.underlying.price + 10
        ]
        if len(calls) > 0:
            expiry = min(x.id.date for x in calls)
            call = sorted([x for x in calls if x.id.date == expiry],
                key=lambda x: x.id.strike_price)[0]
            selected.append(call)
            
        return selected