book
Checkout our new book! Hands on AI Trading with Python, QuantConnect, and AWS Learn More arrow

TickData

International Futures

Introduction

The International Futures dataset by TickData provides Futures data, including price, volume, open interest, and expiry. The data covers the 3 contracts, FESX, HSI, and NKD, starting in July 1998 and is delivered on any frequency from tick to daily. This dataset is created by TickData, which negotiates directly with exchanges for their official archive and partners with real-time data providers with direct exchange connections and multiple redundant ticker plants.

This dataset also depends on the US Futures Security Master because the US Futures Security Master dataset contains information to construct continuous Futures.

For more information about the International Futures dataset, including CLI commands and pricing, see the dataset listing.

About the Provider

TickData was founded by a futures broker and a programmer in 1984 as the first company in the world to offer historical tick-by-tick prices on the futures and index markets. TickData provides access to comprehensive and detailed market data and analytics products in the financial industry covering Equities, Futures, Options, cash FOREX, and Cash Indices.

Getting Started

The following snippet demonstrates how to request data from the International Futures dataset:

Select Language: 
hsi = self.add_future(Futures.Indices.HANG_SENG, Resolution.MINUTE).symbol            # "HSI"
fesx = self.add_future(Futures.Indices.EURO_STOXX_50, Resolution.MINUTE).symbol       # "FESX"
nkd = self.add_future(Futures.Indices.NIKKEI_225_DOLLAR, Resolution.MINUTE).symbol    # "NKD"

Data Summary

The following table describes the dataset properties:

PropertyValue
Start DateJuly 1998, see Supported Assets below for details
Coverage3 Contracts
Data DensityDense
ResolutionMinute, Hour, & Daily
TimezoneVarious, refer to Supported Assets below
Market HoursRegular and Extended

Example Applications

The International Futures dataset enables you to design Futures strategies accurately. Examples include the following strategies:

  • Buying the Futures contract with the most open interest to reduce slippage and market impact
  • Trade speculation on an International Index
  • Trading bull calendar spreads to reduce volatility and margin requirements

For more example algorithms, see Examples.

Supported Assets

The following table shows the available Futures:

TickerFutureStart DateTime ZoneCurrency
HSIHang Seng Index FuturesJan 2010Asia/Hong KongHKD
FESXEURO STOXX 50 Index FuturesJul 1998Europe/BerlinEUR
NKDNikkei 225 Index FuturesJan 2007America/ChicagoUSD

Volume Discrepancies

For Futures contracts trading in the US, for example, NKD, see US Futures.

Data Point Attributes

The International Futures dataset provides Future, FuturesChain, and OpenInterest objects. To configure the continuous Future settings, use the DataNormalizationMode and DataMappingMode enumerations.

Future Attributes

Future objects have the following attributes:

Future Select Language:
    Gets or sets whether or not this security should be considered tradable
  • is_tradable: bool
    • Returns true if this is the future chain security, false if it is a specific future contract
  • is_future_chain: bool
    • Returns true if this is a specific future contract security, false if it is the future chain security
  • is_future_contract: bool
    • Gets the expiration date
  • expiry: DateTime
    • Specifies if futures contract has physical or cash settlement on settlement
  • settlement_type: SettlementType
    • Gets or sets the underlying security object.
  • underlying: Security
    • Gets or sets the currently mapped symbol for the security
  • mapped: Symbol
    • Gets or sets the contract filter
  • contract_filter: IDerivativeSecurityFilter<Symbol>
    • This securities QuantConnect.Interfaces.IShortableProvider
  • shortable_provider: IShortableProvider
    • Gets all the subscriptions for this security
  • subscriptions: List<SubscriptionDataConfig>
    • QuantConnect.Securities.Security.Symbol for the asset.
  • symbol: Symbol
    • Gets the Cash object used for converting the quote currency to the account currency
  • quote_currency: Cash
    • Gets the symbol properties for this security
  • symbol_properties: SymbolProperties
    • Type of the security.
  • type: SecurityType
    • There has been at least one datapoint since our algorithm started running for us to determine price.
  • has_data: bool
    • True if the security has been delisted from exchanges and is no longer tradable
  • is_delisted: bool
    • Data cache for the security to store previous price information.
  • cache: SecurityCache
    • Holdings class contains the portfolio, cash and processes order fills.
  • holdings: SecurityHolding
    • Exchange class contains the market opening hours, along with pre-post market hours.
  • exchange: SecurityExchange
    • Fee model used to compute order fees for this security
  • fee_model: IFeeModel
    • Fill model used to produce fill events for this security
  • fill_model: IFillModel
    • Slippage model use to compute slippage of market orders
  • slippage_model: ISlippageModel
    • Gets the portfolio model used by this security
  • portfolio_model: ISecurityPortfolioModel
    • Gets the buying power model used for this security
  • buying_power_model: IBuyingPowerModel
    • Gets the buying power model used for this security, an alias for QuantConnect.Securities.Security.BuyingPowerModel
  • margin_model: IBuyingPowerModel
    • Gets or sets the margin interest rate model
  • margin_interest_rate_model: IMarginInterestRateModel
    • Gets the settlement model used for this security
  • settlement_model: ISettlementModel
    • Gets the volatility model used for this security
  • volatility_model: IVolatilityModel
    • Customizable data filter to filter outlier ticks before they are passed into user event handlers. By default all ticks are passed into the user algorithms.
  • data_filter: ISecurityDataFilter
    • Customizable price variation model used to define the minimum price variation of this security. By default minimum price variation is a constant find in the symbol-properties-database.
  • price_variation_model: IPriceVariationModel
    • Provides dynamic access to data in the cache
  • data: object
    • Read only property that checks if we currently own stock in the company.
  • hold_stock: bool
    • Alias for HoldStock - Do we have any of this security
  • invested: bool
    • Local time for this market
  • local_time: DateTime
    • Get the current value of the security.
  • price: decimal
    • Leverage for this Security.
  • leverage: decimal
    • If this uses tradebar data, return the most recent high.
  • high: decimal
    • If this uses tradebar data, return the most recent low.
  • low: decimal
    • If this uses tradebar data, return the most recent close.
  • close: decimal
    • If this uses tradebar data, return the most recent open.
  • open: decimal
    • Access to the volume of the equity today
  • volume: decimal
    • Gets the most recent bid price if available
  • bid_price: decimal
    • Gets the most recent bid size if available
  • bid_size: decimal
    • Gets the most recent ask price if available
  • ask_price: decimal
    • Gets the most recent ask size if available
  • ask_size: decimal
    • Access to the open interest of the security today
  • open_interest: int
    • Gets the fundamental data associated with the security if there is any, otherwise null.
  • fundamentals: Fundamental
    • Gets or sets the specified custom property through the indexer. This is a wrapper around the QuantConnect.Securities.Security.Get``1(System.String) and QuantConnect.Securities.Security.Add(System.String,System.Object) methods.
  • item: object
    • The default time of day for settlement
  • DEFAULT_SETTLEMENT_TIME: TimeSpan
    • The default number of days required to settle a futures sale
  • DEFAULT_SETTLEMENT_DAYS: Int32

FuturesChain Attributes

FuturesChain objects have the following attributes:

FuturesChain Select Language:
    Gets the most recent trade information for the underlying. This may be a QuantConnect.Data.Market.Tick or a QuantConnect.Data.Market.TradeBar
  • underlying: BaseData
    • Gets all ticks for every futures contract in this chain, keyed by symbol
  • ticks: Ticks
    • Gets all trade bars for every futures contract in this chain, keyed by symbol
  • trade_bars: TradeBars
    • Gets all quote bars for every futures contract in this chain, keyed by symbol
  • quote_bars: QuoteBars
    • Gets all contracts in the chain, keyed by symbol
  • contracts: FuturesContracts
    • Gets the set of symbols that passed the QuantConnect.Securities.Future.Future.ContractFilter
  • filtered_contracts: HashSet<Symbol>
    • Market Data Type of this data - does it come in individual price packets or is it grouped into OHLC.
  • data_type: MarketDataType
    • True if this is a fill forward piece of data
  • is_fill_forward: bool
    • Current time marker of this data packet.
  • time: DateTime
    • The end time of this data. Some data covers spans (trade bars) and as such we want to know the entire time span covered
  • end_time: DateTime
    • Symbol representation for underlying Security
  • symbol: Symbol
    • Value representation of this data packet. All data requires a representative value for this moment in time. For streams of data this is the price now, for OHLC packets this is the closing price.
  • value: decimal
    • As this is a backtesting platform we'll provide an alias of value as price.
  • price: decimal

OpenInterest Attributes

OpenInterest objects have the following attributes:

OpenInterest Select Language:
    Type of the Tick: Trade or Quote.
  • tick_type: TickType
    • Quantity exchanged in a trade.
  • quantity: decimal
    • Exchange code this tick came from QuantConnect.Exchanges
  • exchange_code: string
    • Exchange name this tick came from QuantConnect.Exchanges
  • exchange: string
    • Sale condition for the tick.
  • sale_condition: string
    • For performance parsed sale condition for the tick.
  • parsed_sale_condition: UInt32
    • Bool whether this is a suspicious tick
  • suspicious: bool
    • Bid Price for Tick
  • bid_price: decimal
    • Asking price for the Tick quote.
  • ask_price: decimal
    • Alias for "Value" - the last sale for this asset.
  • last_price: decimal
    • Size of bid quote.
  • bid_size: decimal
    • Size of ask quote.
  • ask_size: decimal
    • Market Data Type of this data - does it come in individual price packets or is it grouped into OHLC.
  • data_type: MarketDataType
    • True if this is a fill forward piece of data
  • is_fill_forward: bool
    • Current time marker of this data packet.
  • time: DateTime
    • The end time of this data. Some data covers spans (trade bars) and as such we want to know the entire time span covered
  • end_time: DateTime
    • Symbol representation for underlying Security
  • symbol: Symbol
    • Value representation of this data packet. All data requires a representative value for this moment in time. For streams of data this is the price now, for OHLC packets this is the closing price.
  • value: decimal
    • As this is a backtesting platform we'll provide an alias of value as price.
  • price: decimal

DataNormalizationMode Values

The DataNormalizationMode enumeration has the following values:

DataNormalizationMode Select Language:
    No modifications to the asset price at all. For Equities, dividends are paid in cash and splits are applied directly to your portfolio quantity. (0)
  • RAW: DataNormalizationMode
    • Splits and dividends are backward-adjusted into the price of the asset. The price today is identical to the current market price. (1)
  • ADJUSTED: DataNormalizationMode
    • Equity splits are applied to the price adjustment but dividends are paid in cash to your portfolio. This normalization mode allows you to manage dividend payments (e.g. reinvestment) while still giving a smooth time series of prices for indicators. (2)
  • SPLIT_ADJUSTED: DataNormalizationMode
    • Equity splits are applied to the price adjustment and the value of all future dividend payments is added to the initial asset price. (3)
  • TOTAL_RETURN: DataNormalizationMode
    • Eliminates price jumps between two consecutive contracts, adding a factor based on the difference of their prices. The first contract has the true price. Factor 0. (4)
  • FORWARD_PANAMA_CANAL: DataNormalizationMode
    • Eliminates price jumps between two consecutive contracts, adding a factor based on the difference of their prices. The last contract has the true price. Factor 0. (5)
  • BACKWARDS_PANAMA_CANAL: DataNormalizationMode
    • Eliminates price jumps between two consecutive contracts, multiplying the prices by their ratio. The last contract has the true price. Factor 1. (6)
  • BACKWARDS_RATIO: DataNormalizationMode
    • Splits and dividends are adjusted into the prices in a given date. Only for history requests. (7)
  • SCALED_RAW: DataNormalizationMode

DataMappingMode Values

The DataMappingMode enumeration has the following values:

DataMappingMode Select Language:
    The contract maps on the previous day of expiration of the front month (0)
  • LAST_TRADING_DAY: DataMappingMode
    • The contract maps on the first date of the delivery month of the front month. If the contract expires prior to this date, then it rolls on the contract's last trading date instead (1)
  • FIRST_DAY_MONTH: DataMappingMode
    • The contract maps when the following back month contract has a higher open interest that the current front month (2)
  • OPEN_INTEREST: DataMappingMode
    • The contract maps when any of the back month contracts of the next year have a higher volume that the current front month (3)
  • OPEN_INTEREST_ANNUAL: DataMappingMode

Requesting Data

To add International Futures data to your algorithm, call the add_future method. Save a reference to the Future so you can access the data later in your algorithm.

Select Language: 
class InternationalFuturesDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2013, 12, 20) 
        self.set_end_date(2014, 2, 20) 
        self.set_cash(1000000) 
        self.universe_settings.asynchronous = True
        # Request Hang Seng Index Futures data
        future = self.add_future(Futures.Indices.HANG_SENG) 
        # Set filter to obtain the contracts expire within 90 days
        future.set_filter(0, 90)
        self.future_symbol = future.symbol

For more information about creating Future subscriptions, see Requesting Data or Futures Universes.

Accessing Data

To get the current International Futures data, index the futures_chains property of the current Slice with the canonical Futures Symbol. Slice objects deliver unique events to your algorithm as they happen, but the Slice may not contain data for your Future at every time step.

Select Language: 
def on_data(self, slice: Slice) -> None:
    # Get future chain of the canonical symbol
    chain = slice.futures_chains.get(self.future_symbol)
    if chain:
        # Iterate each contract in the future chain
        for contract in chain:
            self.log(f"{contract.symbol} price at {slice.time}: {contract.last_price}")

You can also iterate through all of the FuturesChain objects in the current Slice.

Select Language: 
def on_data(self, slice: Slice) -> None:
    # Iterate all future chains
    for canonical_symbol, chain in slice.futures_chains.items():
        # Iterate each contract in the future chain
        for contract in chain:
            self.log(f"{contract.symbol} price at {slice.time}: {contract.last_price}")

For more information about accessing Futures data, see Handling Data.

Historical Data

You can get historical International Futures data in an algorithm and the Research Environment.

Historical Data In Algorithms

To get historical International Futures data in an algorithm, call the history method with the canonical Futures Symbol or a Futures contract Symbol. If there is no data in the period you request, the history result is empty.

Select Language: 
# DataFrame objects
contract_history_df = self.history(contract.symbol, 100, Resolution.MINUTE)
continuous_history_df = self.history(self.future_symbol,
    start=self.time - timedelta(days=15), 
    end=self.time, 
    resolution=Resolution.MINUTE, 
    fill_forward=False, 
    extended_market_hours=False,
    data_mapping_mode=DataMappingMode.OPEN_INTEREST, 
    data_normalization_mode=DataNormalizationMode.RAW, 
    contract_depth_offset=0)

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

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

# Tick objects
contract_history_ticks = self.history[Tick](contract.symbol, timedelta(seconds=10), Resolution.TICK)
continous_history_ticks = self.history[Tick](self.future_symbol, timedelta(seconds=10), Resolution.TICK)

For more information about historical data in algorithms, see History Requests. For more information about the price adjustments for continuous contracts, see Continous Contracts.

Historical Data In Research

To get historical International Futures data in the Research Environment for an entire Futures chain, call the future_history method with the canonical Future Symbol.

Select Language: 
qb = QuantBook()
future = qb.add_future(Futures.Indices.HANG_SENG) 
future.set_filter(0, 90)
history = qb.future_history(future.symbol, datetime(2020, 6, 1), datetime(2020, 6, 5))
history_df = history.data_frame
all_history = history.get_all_data()
expiries = history.get_expiry_dates()

To get historical data for a single International Futures contract or the continuous Futures contract, 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 Futures.

Example Applications

The International Futures dataset enables you to design Futures strategies accurately. Examples include the following strategies:

  • Buying the Futures contract with the most open interest to reduce slippage and market impact
  • Trade speculation on an International Index
  • Trading bull calendar spreads to reduce volatility and margin requirements

For more example algorithms, see Examples.

You can also see our Videos. You can also get in touch with us via Discord.

Did you find this page helpful?

Contribute to the documentation: