---
title: "US Future Options"
description: "US Future Options dataset from AlgoSeek."
canonical: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/algoseek/us-future-options
markdown: https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/algoseek/us-future-options.md
language: python
source: https://github.com/QuantConnect/Documentation/tree/master/03%20Writing%20Algorithms/14%20Datasets/03%20AlgoSeek/03%20US%20Future%20Options
modified: 2026-10-31
index: https://www.quantconnect.com/llms.txt
---

# US Future Options

[Documentation](https://www.quantconnect.com/docs/v2.md) > [Writing Algorithms](https://www.quantconnect.com/docs/v2/writing-algorithms.md) > Datasets > [AlgoSeek](https://www.quantconnect.com/docs/v2/writing-algorithms/datasets/algoseek.md) > US Future Options

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

## Introduction

The US Future Options dataset by AlgoSeek provides Option data on US Future contracts, including prices, strikes, and expires. The data covers 15 Monthly Future contracts, starts in January 2012, and is delivered on a minute frequency. This dataset is created by monitoring the trading activity on the CME, CBOT, NYMEX, and COMEX markets.

This dataset depends on the following datasets:

- [US Future Option Universe](https://www.quantconnect.com/datasets/quantconnect-us-future-option-universe) - data on the available US Future Options contracts and their current Open Interest.
- [US Futures Security Master](https://www.quantconnect.com/datasets/quantconnect.com/datasets/quantconnect-us-futures-security-master) - data to construct continuous Futures.
- [US Future Universe](https://www.quantconnect.com/datasets/quantconnect-us-future-universe) - data on the available US Future contracts, their daily trading volume, and Open Interest.
- [US Futures](https://www.quantconnect.com/datasets/quantconnect.com/datasets/algoseek-us-futures) - data on the underlying Futures contracts, including price, volume, Open Interest, and expiry.

For more information about the US Future Options dataset, including CLI commands and pricing, see the [dataset listing](https://www.quantconnect.com/datasets/algoseek-us-future-options).

## About the Provider

AlgoSeek is a leading historical intraday US market data provider offering the most comprehensive and detailed market data and analytics products in the financial industry covering equities, futures, options, cash forex, and cryptocurrencies. AlgoSeek data is built for quantitative trading and machine learning. For more information about AlgoSeek, visit [algoseek.com](https://www.algoseek.com).

## Getting Started

The following snippet demonstrates how to request data from the US Future Options dataset:

```python
future = self.add_future(Futures.Metals.GOLD, Resolution.MINUTE)
future.set_filter(0, 90)
self.add_future_option(future.symbol, lambda universe: universe.strikes(-5, +5))
```

## Data Summary

The following table describes the dataset properties:

| Property | Value |
| --- | --- |
| Start Date | January 2012 |
| Asset Coverage | 15 Monthly Future Contracts. Standard expires only*. |
| Data Density | Dense |
| Resolution | Minute, Hourly, & Daily |
| Timezone | New York |
| Market Hours | [Regular and Extended](https://www.quantconnect.com/docs/v2/writing-algorithms/securities/asset-classes/future-options/market-hours.md) |

* No weeklies or 0DTE contracts.

## Requesting Data

To add US Future Options data to your algorithm, call the `add_future_option` method.

```python
class FutureOptionDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 1, 28)
        self.set_end_date(2020, 6, 1)
        self.set_cash(100000)
        self.universe_settings.asynchronous = True
        future = self.add_future(Futures.Metals.GOLD, Resolution.MINUTE)
        future.set_filter(0, 90)
        self.add_future_option(future.symbol, lambda universe: universe.strikes(-5, +5))
```

The Future resolution must be less than or equal to the Future Option resolution. For example, if you set the Future resolution to minute, then the Future Option resolution must be minute, hour, or daily.

For more information about creating Future Options subscriptions, see [Requesting Data](https://www.quantconnect.com/docs/v2/writing-algorithms/securities/asset-classes/future-options/requesting-data.md) or [Future Options Universes](https://www.quantconnect.com/docs/v2/writing-algorithms/universes/future-options.md).

## Accessing Data

To get the current Future Options data, iterate through the `option_chains` property of the current [`Slice`](https://www.quantconnect.com/docs/v2/writing-algorithms/key-concepts/time-modeling/timeslices.md). Slice objects deliver unique events to your algorithm as they happen, but the `Slice` may not contain data for your Future Options at every time step.

```python
def on_data(self, slice: Slice) -> None:
    for canonical_fop_symbol, chain in slice.option_chains.items():
        for contract in chain:
            self.log(f"{contract.symbol} price at {slice.time}: {contract.last_price}")
```

You can also iterate through the `futures_chains` in the current `Slice` first.

```python
def on_data(self, slice: Slice) -> None:
    for continuous_future_symbol, futures_chain in slice.futures_chains.items():
        # Select a Future Contract and create its canonical FOP Symbol
        futures_contract = [contract for contract in futures_chain][0]
        canonical_fop_symbol = Symbol.create_canonical_option(futures_contract.symbol)
        option_chain = slice.option_chains.get(canonical_fop_symbol)
        if option_chain:
            for fop_contract in option_chain:
                 self.log(f"{fop_contract.symbol} price at {slice.time}: {fop_contract.last_price}")
```

For more information about accessing Future Options data, see [Handling Data](https://www.quantconnect.com/docs/v2/writing-algorithms/securities/asset-classes/future-options/handling-data.md).

## Historical Data

You can get historical US Future Options data in an algorithm and the Research Environment.

### Historical Data In Algorithms

To get historical US Future Options data in an algorithm, call the `history` method with the Future Option contract `Symbol`. If there is no data in the period you request, the history result is empty.

```python
# DataFrame of trade and quote data
history_df = self.history(contract.symbol, 100, Resolution.MINUTE)

# DataFrame of open interest data
history_oi_df = self.history(OpenInterest, contract.symbol, 100, Resolution.MINUTE)

# TradeBar objects
history_trade_bars = self.history[TradeBar](contract.symbol, 100, Resolution.MINUTE)

# QuoteBar objects
history_quote_bars = self.history[QuoteBar](contract.symbol, 100, Resolution.MINUTE)

# OpenInterest objects
history_oi = self.history[OpenInterest](contract.symbol, 100, Resolution.MINUTE)
```

For more information about historical data in algorithms, see [History Requests](https://www.quantconnect.com/docs/v2/writing-algorithms/historical-data/history-requests.md).

### Historical Data In Research

To get historical US Future Options data in the Research Environment, call the `history` or `option_history` method. The `history` method returns the price, volume, and open interest history for some given Future Option contract(s). The `option_history` method returns the price and volume history for the contracts that pass your daily universe filter.

```python
qb = QuantBook()
future = qb.add_future(Futures.Indices.SP_500_E_MINI)
start_date = datetime(2024, 1, 2)
future_contract_symbol = sorted(
    qb.future_chain_provider.get_future_contract_list(future.symbol, start_date),
    key=lambda s: s.id.date
)[0]
history = qb.option_history(
    future_contract_symbol, start_date, future_contract_symbol.id.date, Resolution.HOUR
)
history_df = history.data_frame
expiries = history.get_expiry_dates()
strikes = history.get_strikes()
```

To get historical data for arbitrary US Equity Option contracts instead of just the that pass your universe filter, call the `history` method like you would in an algorithm, but on the `QuantBook` object. For more information about historical data in the Research Environment, see [Key Concepts](https://www.quantconnect.com/docs/v2/research-environment/datasets/futures-options/key-concepts.md).

## Supported Assets

The following list shows the available (15) Futures Options:

- `Futures.Energy.CRUDE_OIL_WTI`: Crude Oil WTI Futures (NYMEX: LO | Underlying: CL)
- `Futures.Energy.GASOLINE`: Gasoline RBOB Futures (NYMEX: OB | Underlying: RB)
- `Futures.Energy.HEATING_OIL`: Heating Oil Futures (NYMEX: OH | Underlying: HO)
- `Futures.Energy.NATURAL_GAS`: Natural Gas Futures (NYMEX: ON | Underlying: NG)
- `Futures.Financials.Y_10_TREASURY_NOTE`: 10Y U.S. Treasury Note Futures (CBOT: OZN | Underlying: ZN)
- `Futures.Financials.Y_2_TREASURY_NOTE`: 2Y U.S. Treasury Note Futures (CBOT: OZT | Underlying: ZT)
- `Futures.Financials.Y_30_TREASURY_BOND`: 30Y U.S. Treasury Bond Futures (CBOT: OZB | Underlying: ZB)
- `Futures.Grains.CORN`: Corn Futures (CBOT: OZC | Underlying: ZC)
- `Futures.Grains.SOYBEANS`: Soybeans Futures (CBOT: OZS | Underlying: ZS)
- `Futures.Grains.WHEAT`: Default wheat contract is SRWWheat (CBOT: OZW | Underlying: ZW)
- `Futures.Indices.NASDAQ_100_E_MINI`: E-mini NASDAQ 100 Futures (CME: NQ)
- `Futures.Indices.SP_500_E_MINI`: E-mini S&P 500 Futures (CME: ES)
- `Futures.Metals.COPPER`: Copper Futures (COMEX: HXE | Underlying: HG)
- `Futures.Metals.GOLD`: Gold Futures (COMEX: OG | Underlying: GC)
- `Futures.Metals.SILVER`: Silver Futures (COMEX: SO | Underlying: SI)

## Downloading Data

You can download the US Future Options dataset to your local machine to run the LEAN engine locally with the [LEAN CLI](https://www.quantconnect.com/docs/v2/lean-cli.md). For the download commands, prerequisites, and pricing, see [Future Options](https://www.quantconnect.com/docs/v2/lean-cli/datasets/quantconnect/future-options.md) in the LEAN CLI documentation.

## Example Applications

The US Future Options dataset enables you to accurately design Future Option strategies. Examples include the following strategies:

- Selling out of the money Future Option contracts to collect the premium that the Option buyer pays
- Buying put Options to hedge against downward price movement in Future contracts you bought
- Exploiting arbitrage opportunities that arise when the price of Option contracts deviates from their theoretical value

### Classic Algorithm Example

The following example demonstrates a weekly-renewing [covered call](https://www.quantconnect.com/docs/v2/writing-algorithms/trading-and-orders/option-strategies/covered-call.md) strategy to collect credit of selling the option. It filters the ATM call contract that expires within the current week at week start using `set_filter` filtering function.

```python
from AlgorithmImports import *

class FutureOptionExampleAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(5_000_000)
        # Subscribe the underlying since the updated price is needed for filtering
        self.underlying = self.add_future(Futures.Indices.SP_500_E_MINI,
            extended_market_hours=True,
            data_mapping_mode=DataMappingMode.OPEN_INTEREST,
            data_normalization_mode=DataNormalizationMode.BACKWARDS_RATIO,
            contract_depth_offset=0)
        # Filter the underlying continuous Futures to narrow the FOP spectrum
        self.underlying.set_filter(0, 182)
        # Filter for the current-week-expiring calls to formulate a covered call that expires at the end of week
        self.add_future_option(self.underlying.symbol, lambda u: u.calls_only().expiration(0, 5))

    def on_data(self, slice: Slice) -> None:
        # Create canonical symbol for the mapped future contract, since option chains are mapped by canonical symbol
        symbol = Symbol.create_canonical_option(self.underlying.mapped)

        # Get option chain data for the mapped future, as both the underlying and FOP have the highest liquidity among all other contracts
        chain = slice.option_chains.get(symbol)
        if not self.portfolio.invested and chain:
            # Obtain the ATM call that expires at the end of week, such that both underlying and the FOP expires the same time
            expiry = max(x.expiry for x in chain)
            atm_call = sorted([x for x in chain if x.expiry == expiry],
                key=lambda x: abs(x.strike - x.underlying_last_price))[0]

            # Use abstraction method to order a covered call to avoid manual error
            option_strategy = OptionStrategies.covered_call(symbol, atm_call.strike,expiry)
            self.buy(option_strategy, 1)

    def on_securities_changed(self, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            if security.type == SecurityType.FUTURE_OPTION:
                # Historical data
                history = self.history(security.symbol, 10, Resolution.MINUTE)
```

### Framework Algorithm Example

The following example demonstrates a daily renewing speculation trade on upward movement of Gold with FOP using algorithm framework. Using FOP, traders can achieve lower cost to get similar absolute profit, given the FOP is selected to be deep ITM with high Delta value.

```python
from AlgorithmImports import *

class USFuturesDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(100000)
        # Override an option universe selection model to select the FOPs
        self.set_universe_selection(GoldFOPUniverseSelectionModel(self))
        # Handle the FOP trading logic in an alpha model
        self.add_alpha(ConstantFutureOptionsAlphaModel())
        # To order a single contract per insight, use a custom portfolio construction model
        self.set_portfolio_construction(SingleSharePortfolioConstructionModel())

class GoldFOPUniverseSelectionModel(OptionUniverseSelectionModel):

    # Daily renewed universe since option contract list is updated on a daily basis
    def __init__(self, algorithm) -> None:
        self._algorithm = algorithm
        super().__init__(timedelta(1), self.select_fop_symbols)

    def select_fop_symbols(self, utc_time: datetime) -> List[Symbol]:
        #  Create the underlying symbol to get the FOP contracts later
        future_symbol = Symbol.create(Futures.Metals.GOLD, SecurityType.FUTURE, Market.COMEX)
        # Get all gold FOP contracts of the front month gold contract expiring within 3 months, since their liquidity is the highest
        future_contract_list = self._algorithm.future_chain_provider.get_future_contract_list(future_symbol, self._algorithm.time)
        return [Symbol.create_canonical_option(x) for x in future_contract_list
                    if x.id.date <= self._algorithm.time + timedelta(90)]

    def filter(self, option_filter_universe: OptionFilterUniverse) -> OptionFilterUniverse:
        # Filter for the ATM calls that expires latest (same expiry as the underlying)
        # +/-5 strike range buffer for price movement
        return option_filter_universe.back_month().strikes(-5, +5).calls_only()

class ConstantFutureOptionsAlphaModel(AlphaModel):

    # A dictionary to cache the mapped FOP of the underlying Future for filtering wanted option chain data and check if invested
    option_contract_by_future_underlying_contract = {}

    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        insights = []

        for kvp in slice.option_chains:
            # Liquidate underlying Future contract after Option assignment
            underlying_future_contract = kvp.key.underlying
            if algorithm.portfolio[underlying_future_contract].invested:
                algorithm.insights.cancel([underlying_future_contract])
                del self.option_contract_by_future_underlying_contract[underlying_future_contract]

            # Do not repeatly invest in the same underlying's FOP
            chain = [contract for contract in kvp.value if algorithm.securities[contract.symbol].is_tradable]
            if not chain or underlying_future_contract in self.option_contract_by_future_underlying_contract:
                continue

            # Select the Option contract with the lowest strike price to speculate trade the underlying with lowest cost and highest delta
            contract = sorted(chain, key=lambda x: x.strike)[0]
            insights.append(Insight.price(contract.symbol, contract.expiry + timedelta(1), InsightDirection.UP))
            self.option_contract_by_future_underlying_contract[underlying_future_contract] = contract

        return insights

class SingleSharePortfolioConstructionModel(PortfolioConstructionModel):

    def create_targets(self, algorithm: QCAlgorithm, insights: List[Insight]) -> List[PortfolioTarget]:
        targets = []
        for insight in insights:
            if algorithm.securities[insight.symbol].is_tradable:
                # Use integer target to create a portfolio target to trade a single contract
                targets.append(PortfolioTarget(insight.symbol, insight.direction))
        return targets
```

## Data Point Attributes

The US Future Options dataset provides `TradeBar`, `QuoteBar`, and `OpenInterest` objects.

### TradeBar Attributes

`TradeBar` objects have the following attributes:

*Members of `QuantConnect.Data.Market.TradeBar` (JSON): https://www.quantconnect.com/services/inspector?type=T:QuantConnect.Data.Market.TradeBar&language=python*

### QuoteBar Attributes

`QuoteBar` objects have the following attributes:

*Members of `QuantConnect.Data.Market.QuoteBar` (JSON): https://www.quantconnect.com/services/inspector?type=T:QuantConnect.Data.Market.QuoteBar&language=python*

### OpenInterest Attributes

`OpenInterest` objects have the following attributes:

*Members of `QuantConnect.Data.Market.OpenInterest` (JSON): https://www.quantconnect.com/services/inspector?type=T:QuantConnect.Data.Market.OpenInterest&language=python*