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

Crypto Futures

Requesting Data

Introduction

Request Crypto Futures data in your algorithm to receive a feed of asset prices in the on_data method. For more information about the specific datasets we use for backtests, see the Binance Crypto Future Price Data dataset listing. To trade Crypto Futures live, you can use the QuantConnect data provider.

Create Subscriptions

To create a Crypto Futures subscription, in the initialize method, call the add_crypto_future method. The add_crypto_future method returns a CryptoFuture object, which contains a symbol property. Save a reference to the symbol so you can use it in on_data to access the security data in the Slice.

Select Language: 
self._symbol = self.add_crypto_future("BTCUSD").symbol

The add_crypto_future method creates a subscription for a single Crypto Futures asset and adds it to your user-defined universe.

To view the supported assets in the Crypto Futures dataset, see Supported Assets.

Resolutions

The following table shows the available resolutions and data formats for Crypto Futures contract subscriptions:

ResolutionTradeBarQuoteBarTrade TickQuote Tick
TICKgreen checkgreen check
SECONDgreen checkgreen check
MINUTEgreen checkgreen check
HOURgreen checkgreen check
DAILYgreen checkgreen check

The default resolution for Crypto Futures subscriptions is Resolution.MINUTE. To change the resolution, pass a resolution argument to the add_crypto_future method.

Select Language: 
self._symbol = self.add_crypto_future("BTCUSD", Resolution.DAILY).symbol

To create custom resolution periods, see Consolidating Data.

Supported Markets

The following Market enumeration members are available for Cryptofuture:

Market Select Language:
    Binance
  • BINANCE: string
    • Bybit
  • BYBIT: string
Select Language: 
self._symbol = self.add_crypto_future("BTCUSD", market=Market.BINANCE).symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice, LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fill_forward argument to false when you create the security subscription.

Select Language: 
self._symbol = self.add_crypto_future("BTCUSD", fill_forward=False).symbol

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. The amount of leverage available to you depends on the brokerage you use. To change the amount of leverage you can use for a security, pass a leverage argument to the add_crypto_future method.

Select Language: 
self._symbol = self.add_crypto_future("BTCUSD", leverage=3).symbol

For more information about the leverage each brokerage provides, see Brokerages.

Data Normalization

The data normalization mode doesn't affect the data that LEAN passes to on_data or the data from history request. If you change the data normalization mode, it won't change the outcome.

Properties

The add_crypto_future method returns a CryptoFuture object, which have the following properties:

CryptoFuture Select Language:
    Gets the currency acquired by going long this currency pair
  • base_currency: Cash
    • 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
    • Gets or sets whether or not this security should be considered tradable
  • is_tradable: 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

Examples

The following examples demonstrate some common practices for requesting Crypto Futures data.

Example 1: Respect Lot Sizes

Like Futures, Crypto Futures contracts have a fixed discrete lot size to trade instead of fractional like spot Crypto pairs. The following algorithm demonstrates how to place orders that respect the lot size to avoid rounding errors.

Select Language: 
class CryptoFutureAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 4, 1)
        # Set brokerage and account type to match your brokerage environment for accurate fee and margin behavior.
        self.set_brokerage_model(BrokerageName.BINANCE, AccountType.MARGIN)
        # In the Binance brokerage, you can't trade with USD.
        # Set the account currency as USDT and add the starting cash.
        self.set_account_currency("USDT", 10000)
        # Subscribe to the BTCUSDT perpetual Future contract.
        self._symbol = self.add_crypto_future("BTCUSDT").symbol
        
    def on_data(self, slice: Slice) -> None:
        # Only place orders when market is open since market on open orders aren't supported.
        if not self.portfolio.invested and self.is_market_open(self._symbol):
            # Get the lot size from the symbol properties. Placing an order that respects the lot size 
            # ensures the order is valid and allows accurate profit and risk calculations for the whole portfolio.
            lot_size = self.securities[self._symbol].symbol_properties.lot_size
            # This example demonstrates an initial desired order size of 2.5 contracts, which will be rounded 
            # to 2 contracts since the lot size is 1.
            quantity = 2.5 // lot_size * lot_size
            self.market_order(self._symbol, quantity)

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: