Download By Ticker

US Equity algorithms require the US Equity Security Master and some data from the US Equities dataset. The following table shows the cost of an annual subscription to the US Equity Security Master for each organization tier:

The US Equities dataset is available is several resolutions. The resolution you need depends on the US Equity subscriptions you create in your algorithm and the resolution of data you get in history requests. The following table describes the file format and costs of each resolution:

If you add universes to your algorithm, the following table shows the additional datasets you need:

For example, the following algorithm creates a dollar volume universe with 100 securities and then subscribes to minute resolution data for each US Equity in the universe:

namespace QuantConnect.Algorithm.CSharp
{
    public class USEquityDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2021, 1, 1);
            UniverseSettings.Asynchronous = true;
            AddUniverse(Universe.DollarVolume.Top(100));
        }
    }
}

class USEquityDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.universe_settings.asynchronous = True
        self.add_universe(self.universe.dollar_volume.top(100))

The following table shows the data cost of the preceding algorithm on the Quant Researcher tier:

The preceding table assumes you download trade and quote data, but you can run backtests with only trade data.

Equity Option algorithms require the following data:

• US Equity Security Master
• US Equity Option Universe
• Some data from the US Equity Options dataset
• Data for the underlying US Equity universes and assets

The following table shows the cost of an annual subscription to the US Equity Security Master for each organization tier:

The file format of the US Equity Option Universe data is one file per underlying Equity and each file costs 100 QCC = $1 USD.

The US Equity Options dataset is available is several resolutions. The resolution you need depends on the US Equity Option subscriptions you create in your algorithm and the resolution of data you get in history requests. The following table describes the file format and costs of each resolution:

For example, the following algorithm subscribes to minute resolution data for an Equity Option and its underlying asset:

namespace QuantConnect.Algorithm.CSharp
{
    public class USEquityOptionsDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2021, 1, 1);
            UniverseSettings.Asynchronous = true;
            var underlying = AddEquity("GOOG").Symbol;
            AddOption(underlying);
        }
    }
}

class USEquityOptionsDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.universe_settings.asynchronous = True
        underlying = self.add_equity("GOOG").symbol
        self.add_option(underlying)

The following table shows the data cost of the preceding algorithm on the Quant Researcher tier:

The preceding table assumes you download trade, quote, and open interest data. However, you can run backtests with only trade data.

Crypto algorithms require at least one of the CoinAPI datasets. The CoinAPI datasets are available is several resolutions. The resolution you need depends on the Crypto subscriptions you create in your algorithm and the resolution of data you get in history requests. The following table describes the file format and costs of each resolution:

If you add universes to your algorithm, you also need CryptoUniverse data. The file format of CryptoUniverse data is one file per day per brokerage and each file costs 100 QCC = $1 USD.

For example, the following algorithm creates a universe of 100 Cryptocurrencies and then subscribes to minute resolution data for each one in the universe:

namespace QuantConnect.Algorithm.CSharp
{
    public class CryptoDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2021, 1, 1);
            UniverseSettings.Asynchronous = true;            
            AddUniverse(CryptoUniverse.Coinbase(universeDay => universeDay.OrderByDescending(cf => cf.VolumeInUsd).Take(100).Select(x => x.Symbol))
            );
        }
    }
}

class CryptoDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.universe_settings.asynchronous = True
        self.add_universe(CryptoUniverse.coinbase(self.universe_filter))

    def universe_filter(self, universe_day: List[CryptoUniverse]) -> List[Symbol]:
        sorted_by_dollar_volume = sorted(universe_day, key=lambda cf: cf.volume_in_usd, reverse=True)
        return [cf.symbol for cf in sorted_by_dollar_volume[:100]]

The following table shows the data cost of the preceding algorithm:

The preceding table assumes you download trade and quote data, but you can run backtests with only trade data.

Forex algorithms require some data from the FOREX dataset. The FOREX dataset is available is several resolutions. The resolution you need depends on the Forex subscriptions you create in your algorithm and the resolution of data you get in history requests. The following table describes the file format and costs of each resolution:

For example, the following algorithm subscribes to minute resolution data for one Forex pair:

namespace QuantConnect.Algorithm.CSharp
{
    public class ForexDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2021, 1, 1);
            AddForex("USDCAD");
        }
    }
}

class ForexDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.add_forex("USDCAD")

The following table shows the data cost of the preceding algorithm:

Futures algorithms require some data from the US Futures dataset. The US Futures dataset is available in several resolutions. The resolution you need depends on the US Future subscriptions you create in your algorithm and the resolution of data you get in history requests. The following table describes the file format and costs of each resolution:

If you want continuous contracts in your algorithm, you also need the US Futures Security Master dataset. The following table shows the cost of an annual subscription to the US Futures Security Master for each organization tier:

For example, the following algorithm subscribes to minute resolution data for a universe of ES Futures contracts and creates a continuous contract:

namespace QuantConnect.Algorithm.CSharp
{
    public class USFuturesDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2021, 1, 1);
            var future = AddFuture(Futures.Indices.SP500EMini,
                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
                dataMappingMode: DataMappingMode.OpenInterest,
                contractDepthOffset: 0
            );
            future.SetFilter(0, 90);
        }
    }
}

class USFuturesDataAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        future = self.add_future(Futures.Indices.SP500E_MINI,
                                data_normalization_mode = DataNormalizationMode.BACKWARDS_RATIO,
                                data_mapping_mode = DataMappingMode.OPEN_INTEREST,
                                contract_depth_offset = 0)
        future.set_filter(0, 90)

The following table shows the data cost of the preceding algorithm on the Quant Researcher tier:

The preceding table assumes you download trade, quote, and open interest data. However, you can run backtests with only trade data.

Index Options algorithms require the US Index Option Universe dataset and some data from the US Index Options dataset. The file format of the US Equity Option Universe data is one file per underlying Equity and each file costs 100 QCC = $1 USD. The US Index Options dataset is available in several resolutions. The resolution you need depends on the US Index Option subscriptions you create in your algorithm and the resolution of data you get in history requests. The following table describes the file format and costs of each resolution:

For example, the following algorithm subscribes to minute resolution data for a universe of VIX Index Option contracts:

namespace QuantConnect.Algorithm.CSharp
{
    public class USIndexOptionsDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2021, 1, 1);
            AddIndexOption("VIX");
        }
    }
}

class USIndexOptionsDataAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.add_index_option("VIX")

The following table shows the data cost of the preceding algorithm:

The preceding table assumes you download trade, quote, and open interest data. However, you can run backtests with only trade data.

CFD algorithms require some data from the CFD dataset. The CFD dataset is available is several resolutions. The resolution you need depends on the CFD subscriptions you create in your algorithm and the resolution of data you get in history requests. The following table describes the file format and costs of each resolution:

For example, the following algorithm subscribes to minute resolution data for one CFD contract:

namespace QuantConnect.Algorithm.CSharp
{
    public class CFDDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2021, 1, 1);
            AddCfd("XAUUSD");
        }
    }
}

class CFDDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.add_cfd("XAUUSD")

The following table shows the data cost of the preceding algorithm:

Algorithms that use alternative data require some data from the associated alternative dataset. To view the cost of each alternative dataset, open a dataset listing in the Dataset Market and then click the Pricing tab.