Welcome

Welcome to QuantConnect. We are an open source, community driven algorithmic trading platform. Our trading engine is powered by LEAN, a cross platform, multi-asset technology which brings cutting edge finance to the open source community. We support C#, Python and F# programming languages making us a truly open platform.

Our Mission

We believe the future of finance is automated and we plan to be the quantitative trading infrastructure of the future. We believe algorithmic trading is a powerful tool and we want to open it up to all investors.

Security & Privacy

You own all your intellectual property and your code. Your code is private by default unless you explicitly share it with the community in the forums or with another team member via collaboration. You are creating valuable intellectual property and we respect this, and wish to make it easier.Only two QuantConnect staff members have access to the database. If we ever need access to your algorithm for the purpose of debugging, we only explicitly request permission first. Please see our terms and conditions.

Data Library

We provide an enormous library of data for your backtesting roughly 14TB in size. This library includes:

More information on the data library and its symbols can be found at the Data Library.

Business Model

QuantConnect makes backtesting available for free and charges a small monthly fee to cover live algorithm trading. This offsets our costs and aligns our interests with yours - our client. We also work with brokerages to make your live trading free.

Coding Your Algorithm

Write code in project files and then press the Build button to compile your algorithm. Build errors will be displayed in the console and highlighted with red-lines.

You can add, rename and delete files in your project in the Projects tab. You can create a virtual folder for your project by placing a slash ("/") into the name of your file.

public class BasicTemplateAlgorithm : QCAlgorithm
{
	public override void Initialize() {
		// Setup algorithm requirements: cash, dates and securities.
                // Initialize is called once at the start of the algorithm.
	}

	public override void OnData(Slice data) {
               // Data requested is then piped into event handlers like this one.
	}
}

Backtesting Your Algorithm

Once you've got an algorithm compiling you can click the Play button to launch a backtest. You can launch as many backtests as want in parallel and results are shown in the result drop-down.

University Algorithms

The QuantConnect University "QCU" is a collection of videos and algorithms to demonstrate the API. There are 50+ algorithms covering all aspects of the API and common questions users have raised over time.

Data Manager

The Data Manager is a searchable database of the QuantConnect Data Library. Each asset details are accessible including the start date, delist date, source of the data, resolutions available and the exchange the asset is traded.

API Help Documentation

The Help Tab details the classes and API of the underlying LEAN engine so you can see the methods and class infrastructure. It includes an indicator reference table to see all the indicators available.

Shortcut Keys

Here are some keyboard short-cuts built into the IDE to make coding easier.

The full list of short cuts can be found on at the ACE Editor open source project.

QuantConnect's LEAN engine manages your portfolio and data feeds letting you focus on your algorithm strategy and execution. Data is piped into your strategy via event handlers, upon which you can place trades. We provide basic portfolio management and fill modelling underneath the hood automatically. This is provided by the QCAlgorithm base class.

All algorithms extend QCAlgorithm, which provides some key helper properties for you to use: Security Manager, Portfolio Manager, Transactions Manager, Notification Manager and Scheduling Manager. Along with hundreds of helper methods to make the API easy to use. We'll go into more detail on those below, but its important for you to know the basic infrastructure around your algorithm.

The Securities property get_Securities() method is a dictionary of Security objects. Each asset (equity, forex pair etc) in your algorithm has a security object. All the models for a security live on these objects: e.g. Securities["IBM"].FeeModel or Securities["IBM"].Price. get_Securities().get_Item("SPY").get_Price()

Portfolio is a dictionary of SecurityHolding classes. These classes track the individual portfolio items profit and losses, fees and quantity held. e.g. Portfolio["IBM"].LastTradeProfitDecimal profit = get_Portfolio().get_Item("IBM").get_LastTradeProfit();.

Other helpers like Transactions, Schedule, Notify, and Universe have their own helper methods which we'll explain below.

All algorithms must have an Initialize() method to setup your strategy. Once setup most algorithms have OnData event handlers to process market data and make trading decisions.

The Initialize method is called to setup your strategy. Here you can request data, set starting cash or warm up periods.

Setting Cash

In backtests you can set your starting capital using the SetCash(decimal cash)self.SetCash(decimal cash)this.SetCash(decimal cash) method. In live trading this is ignored and your brokerage cash is used instead. In paper trading we set the cash to a fictional $100,000 USD (you can override the paper trading equity by clicking the "Live Algorithm Equity" button in your project tab).

Setting Dates

Backtesting uses the SetStartDate(int year, int month, int day) self.SetStartDate(int year, int month, int day) this.SetStartDate(int year, int month, int day) and SetEndDate(int year, int month, int day) self.SetEndDate(int year, int month, int day) this.SetEndDate(int year, int month, int day) methods to configure the backtest time range. If unspecified the end date defaults to yesterday. In .NET languages you can also use a DateTime object to set the dates.

Selecting Asset Data

Algorithms can manually subscribe to data for specific assets they need, or use universes to choose groups of assets based on filtering criteria (e.g. all stocks with volumes greater than $10M/day). See more about Universes here.

To manually subscribe to a specific asset you can call the AddEquity(), AddForex(), AddCfd() and AddOption() methods in your Initialize() method. You can subscribe to 500 minute resolution datafeeds, 100 second resolutions feeds and 10 tick resolution datafeeds.

QuantConnect supports international trading across multiple timezones and markets. Markets are used to distinguish between the same tickers on different exchanges (e.g. FXCM and Oanda both offer EURUSD, but have different rates).

QuantConnect provides 40TB of US Equities, US Options, FXCM FX and Oanda FX data. Check out more information about our data in our data library.

We provide data in tick, second, minute, hour or daily resolutions. These are specified by the Resolution enum.

If there is a gap in the data (e.g. because there are no trades), by default the data is still pumped into your strategy on each time step. This behavior is called "fillForward" and defaults to true. You can disable this by setting fillForward to false.

By default data in QuantConnect is Split and Dividend adjusted backwards in time to give smooth continuous prices. This allows easy use for indicators. Some algorithms need raw or partially adjusted price data. You can control this with the SetDataNormalizationMode() method. The DataNormalizationMode enum has the values Adjusted (default), Raw, SplitAdjusted, and TotalReturn.

If you have your own custom data you'd like to backtest against, check out the custom data section.

Setting Warm Up Period

Often algorithms need some historical data to prime technical indicators, or populate historical data arrays. Using the SetWarmUp(TimeSpan period) or SetWarmUp(int barCount) methods you can specify a warm up period for your algorithm which pumps data in from before the start date. During the warm up period you cannot place a trade.

Algorithms can use the bool IsWarmingUp property to determine if the warm up period has completed.

See more about using historical data in the History section.

Cash and Brokerage Models

US Equity brokerage accounts are either Cash or Margin based accounts. Cash accounts do not allow leveraged trading, whereas Margin accounts support 2-4x leverage on your account value. You can set your brokerage account type in your initialization with SetBrokerageModel(BrokerageName broker, AccountType account);.

The BrokerageName enum supports values of Default, TradierBrokerage, InteractiveBrokersBrokerage, FxcmBrokerage and OandaBrokerage. When setting the brokerage name we also set the trading fee structures for that brokerage.

The AccountType enum supports values of Cash and Margin. When using cash leverage is disabled by default, and the cash settlement period is set to 3 days. Margin accounts are settled immediately and have a leverage of 2.

Margin accounts with more than $25,000 in equity are eligible for pattern day trading margin limits. This increases your available leverage to 4x while the market is open and 2x overnight. To model this behavior in your algorithm you must set your security MarginModel a PatternDayTradingMarginModel class.

See more about brokerage models in the Reality Modelling section.

Requested data is passed into event handlers for you to use to make trading decisions. The primary event handler, Slice, groups all data types together at a single moment in time in the OnData(Slice data) handler. Slice is short for "time slice" - representing a slice of time and values of the data at that time. C# and F# also allow you to receive data with dedicated event handlers for each data type e.g OnData(TradeBars data).Python only supports the Slice event handlers.

All data uses DataDictionary objects to group data by symbol and provide easy access to information. The plural of the type denotes the collection of objects e.g. the TradeBars DataDictionary is made up of TradeBar objects. You can access individual data points in the dictionary through its string or symbol dictionary index. For example var ibmTradeBar = tradebars["IBM"].

Time Slices

The Slice event handler combine all of the data together into a single method. It represents the data at a point in time. The Slice object contains many helpers for accessing your data. The Slice objects arrive to the OnData(Slice data) event handler.

The Slice object gives you three ways to access your data:

1. Dynamic string/symbol indexer which returns a dynamic object of your type slice["IBM"].
2. Statically typed properties (slice.Bars[], slice.QuoteBars[]).
3. Statically typed Get<T>() helper

Strongly typed access gives you compile time safety but dynamic types can sometimes simplify coding. We recommend static types as they are easier to debug.

Python is dynamically typed so does not have the Get method. Primary Slice data access is through the string/symbol indexer.

Slice is the recommended method for data access in your algorithm.

Slice has the following internal structure:

class Slice : IEnumerable<KeyValuePair<Symbol, BaseData>>
{
    TradeBars Bars;
    QuoteBars QuoteBars;
    Ticks Ticks;
    OptionChains OptionChains;
    FuturesChains FuturesChains;
    Splits Splits;
    Dividends Dividends;
    Delistings Delistings;
    SymbolChangedEvents SymbolChangedEvents;
}

It contains all the data for a given moment of time. TradeBars and QuoteBars are symbol/string indexed dictionaries so you can easily access the data. Ticks is a symbol-list dictionary with a list of ticks for that moment of time.

To make accessing the data easier the Slice object itself can also be indexed. e.g. slice["IBM"] will return a TradeBar for IBM. slice["EURUSD"] will return a QuoteBar for EURUSD.

Event Handlers

In C#/F# data is also piped into dedicated event handlers for each data type. To use data this way you need to put an event handler in your algorithm which follows the pattern: public void OnData(TradeBars data) {}. LEAN automatically detects the method exists and sends data to it. Python does not support dedicated event data handlers. Slice is the preferred way to access data for your strategy.

When working with Ticks they can occur at the same moment of time across different exchanges. Because of this we provide the ticks as a list. In backtesting this moment is stepped each second and you will get many ticks per second; in live trading it is stepped as fast as possible and you will probably get 1 tick per event. The public void OnData(Ticks data) {} event handler captures these events. To understand the event handlers you should click on each class object link below to see its structure.

Data Formats

There are six financial data types: TradeBars, Ticks, Delistings, SymbolChangedEvents, Splits and Dividends.

All data extends from BaseData - the core data class which provides Symbol, Time and Value properties.

TradeBar events contains Open, High, Low, Close and Volume properties for a given period of time.

Dividend events are triggered on payment of a dividend. It provides the Distribution per share.

Split events are triggered on a share split or reverse split event. It provides a SplitFactor and ReferencePrice.

SymbolChangedEvent provide notice of new ticker names for stocks, or mergers of two tickers into one. It provides the OldSymbol and NewSymbol tickers.

Delisting events provide notice an asset is no longer trading on the exchange.

Ticks is a string indexed dictionary of lists of ticks.

These data types all have dedicated event handlers which follow the pattern above (public void OnData(Type data) {}); and are also passed into the OnData(Slice data) event handler.

LEAN supports backtesting almost any external custom data source. To use this feature you need to add the data during initialize using AddData<T>() and instruct your algorithm how to read your data. We provide helpers for popular data sources like Quandl, but if you are using your own format / server you'll need to create a custom type.

Initializing Custom Data

During initialize your algorithm must use AddData<T>(string ticker, Resolution resolution = Resolution.Daily). This gives LEAN the T-type factory to create the objects, the name of the data and the resolution at which to poll the data to check for updates.

The framework checks for new data every as instructed by the Resolution period, i.e. Resolution.Tick polls constantly, Resolution.Second polls every second, and Resolution.Minute every minute. Hourly and Daily Resolutions are polled every 30 minutes to prevent skipping a day if the data was emitted late.

Creating and Reading Custom Data

You must create a custom type to instruct LEAN where to get your data, and how to read it. We support many different data types and formats. You can even change source locations for backtesting and live modes. All data must extend from BaseData and override the Reader and GetSource methods.

GetSource instructs LEAN where to find your data. It must return a SubscriptionDataSource object containing the string Url to find your data, and the format of the data (SubscriptionTransportMedium RemoteFile or Rest). When the source returned changes URL the data is downloaded again. This allows LEAN to cache large files and only download new data when requested. This also allows you to break up large intraday data into smaller daily files, speeding up the backtest.

When using SubscriptionTransportMedium.Rest the url provided is polled at each Resolution time step and is assumed to be sufficient for 1-data point. This is generally intended for live data sources.

Reader takes one line of data provided by the source, and parses it into one of your custom objects (e.g. Yahoo in the code snippet). In addition to setting your custom type properties, you should also take care to set three required properties:

1. Symbol - Should always be set to config.Symbol
2. Time - Required synchronization of custom data
3. Value - Required for purchasing and portfolio calculations

When there is no usable data in a line, your type should return null.

Consolidators are used to combine smaller data points into larger bars. Commonly this is used to create 5, 10 or 15 minute bars from minute data. We provide tick, second, minute, hour and daily resolution bars which can be consolidated into any form you wish.

To use consolidators you create the consolidator class and then register it to receive data. Once you've registered the class it automatically gets data updates. Once it has aggregated the desired data it emits an event on the DataConsolidated event handler. You setup the consolidator and bind to this event handler once from inside your Initialize() method to prevent your algorithm from running out of memory.

TradeBars vs QuoteBars

The specific consolidator you should use depends on the data and assets you're requesting. TradeBars should be consolidated with a TradeBarConsolidator ; QuoteBars with a QuoteBarConsolidator and Ticks with a TickConsolidator . Quote tick data must be consolidated by the TickQuoteBarConsolidator .

For each asset class and the data we provide please see the data library. It is a little confusing but here is the summary of QuantConnect provided data:

• Equities - trade data only. For Resolution.Tick use the TickConsolidator, for all other resolutions use the TradeBarConsolidator.
• Forex and CFD - quote data only. For Resolution.Tick use the TickQuoteBarConsolidator, for all other resolutions use the QuoteBarConsolidators.
• Options- trade and quote data, at Resolution.Minute only. For consolidating options data use the TradeBarConsolidator or the QuoteBarConsolidator (depending on if you're consolidating trades or quotes).
• Futures - trade and quote data, at all resolutions!

Consolidators & Indicators

If you'd like to have an indicator updated using a specific resolution of data; e.g. 30-period, 15-minute EMA; then you should ideally use the helper methods which come with the indicators. Most indicators handle setting up these resolution periods for you. See Indicators for more information.

You may have a custom indicator which doesn't have this helper. In this case you should register your indicator with the RegisterIndicator function which will automatically create a consolidator and pipe the data into your Indicator class.

In very rare cases you may want to update your indicator manually. You can do this by passing each data point into your indicator.Update() method from your consolidator DataConsolidated event handler.

Algorithms have a Securities property which stores a Security object for each asset in your algorithm. Security objects hold the models (backtesting behaviors) and properties of an asset. Each security can be completely customized to behave as you'd like. Securities is a Dictionary<Symbol, Security> so you can access your Security objects with their ticker Securities["IBM"].Price.

// Popular Securities Property Values:
Securities["IBM"].HasData           // Security has data 
                 .Invested          // Have holdings
                 .LocalTime         // Time on the asset exchange
                 .Holdings          // Portfolio object
                 .Exchange          // Exchange information
                 .FeeModel;         // Fee model setter

Security objects also carry all the models for creating realistic backtests. These models are set via the public security properties and then used in LEAN to improve your backtest realism.

The Portfolio property is a collection of SecurityHolding objects to provide easy access to the holding properties. The Portfolio class is a Dictionary<Symbol, SecurityHolding> so can be accessed via ticker index: Portfolio["IBM"].IsLong

// Popular Portfolio Property Values:
Portfolio["IBM"].Invested 
                .IsLong            // IsLong, IsShort Holdings.
                .Quantity          // Shares held.
                .UnrealizedProfit; // Holdings profit/loss
                .TotalFees         // Fees incurred since backtest start
                .Price;            // Asset price

Detailed information on these classes can be found in LEAN documentation. Check out the Security class (Securities objects), and SecurityHolding (Portfolio objects) classes.

Key Concepts

Algorithms can place an order through calling the appropriate method in the API. Going long is denoted with a ordering positive number, and short a negative one. LEAN does not support hedging (long and short at the same time).

Placing an order generates an OrderTicket which you can use to update, cancel or check the status of your order.

To update an order can call the Update method on the OrderTicket. The Update method takes an UpdateOrderFields object which defines what properties of the order should be updated. In the same way you can cancel your order with the OrderTicket Cancel method.

The OrderTicket Status property can be used to determine if the order is filled. The OrderStatus enum has the values Submitted, PartiallyFilled, Filled, Cancelled or Invalid.

The Transactions property is a helper that provides easy access to current and past orders and order tickets.

// Popular Transactions methods:
Transactions
            .CancelOpenOrders(Symbol symbol)
            .CancelOrder(int orderId, string orderTag = null)
            .GetOpenOrders()
            .GetOpenOrders(Symbol symbol)
            .GetOrderById(int orderId)
            .GetOrders(Func filter)
            .GetOrderTicket(int orderId)
            .GetOrderTickets(Func filter = null)

Set Holdings Helper

Often portfolio based algorithms want to set the portfolio based on percentage weighting. We provide a helper method to perform this weighting for you called SetHoldings .

SetHoldings(Symbol symbol, double percentage, bool liquidateExistingHoldings = false)

When liquidate existing holdings is set to true any existing holdings will first be sold. This may be useful when you're rebalancing to a new set of stocks. The Liquidate method can achieve the same affect.

Liquidate(Symbol symbolToLiquidate = null)

SetHoldings sets a fraction of unlevered equity. e.g. If you have 2x available leverage, and SetHoldings to 1.0 the algorithm will use 1.0 of your available buying power. To maximize buying power in this case you would make the SetHoldings fractions total 2.0.

Order Types

We support many different order types. In live trading some of these order types may be simulated depending on your brokerage (for more information on this see Live Trading).

MarketOrder(Symbol symbol, int quantity, bool asynchronous = false, string tag = "")

MarketOnCloseOrder(Symbol symbol, int quantity, string tag = "")

MarketOnOpenOrder(Symbol symbol, int quantity, string tag = "")

StopMarketOrder(Symbol symbol, int quantity, decimal stopPrice, string tag = "")

LimitOrder(Symbol symbol, int quantity, decimal limitPrice, string tag = "")

StopLimitOrder(Symbol symbol, int quantity, decimal stopPrice, decimal limitPrice, string tag = "")

Order Events

Orders create lots of events you can use to track their status. These events are passed into the OnOrderEvent event handler with the relevant order.

Scheduled events allow you to trigger code to run at specific times of day. This happens regardless of your data events. The schedule API requires a date and time rule to specify when the event is fired.

Scheduled events need a DateRules and TimeRules pair to set a specific time. When the event is triggered the action block is executed.

Date/Time Rules

DateRules.On(2013, 10, 7)

DateRules.EveryDay("SPY")

DateRules.EveryDay()

DateRules.Every(DayOfWeek.Monday, DayOfWeek.Friday)

TimeRules.At(13, 10)

TimeRules.AfterMarketOpen("SPY", 10)

TimeRules.BeforeMarketClose("SPY", 10)

TimeRules.Every(TimeSpan.FromMinutes(10))

We provide more than 100 technical indicators for you to use in your algorithm. These are provided in two ways; through helper short cut methods, and as class objects. Indicators created through the short cut methods have already been wired up to receive data and are "ready to use". A full list of the indicators and their properties can be found in the reference table below.

One key indicator to learn is the Identity indicator which simply returns the value of the asset. This can be useful for combining indicators together. For example:

var pep = Identity("PEP");    // Pepsi ticker
var coke = Identity("KO");    // Coke ticker
var delta = pep.Minus(coke);  // Difference between them

Reference Table

Indicator Extensions

Indicators are composable - meaning they can be chained together to create unique combinations much like lego blocks. We support several indicator extensions as outlined below:

Plotting Indicators

A helper method makes plotting indicators simple. Further information about the charting API can be found in the documentation below.

Plot<T>(string chart, params IndicatorBase<T>[] indicators) where T : BaseData

Often you may want to rotate securities in your algorithm based on filter criteria. You may only want equities above their 200 day EMA, or to only follow stocks on your custom list of symbols. This is possible using our universe selection API.

Universes are how LEAN organizes collections of data subscriptions under the hood. Each security and its data is controlled by a universe. When no universes are asking for data, the asset is removed from your algorithm. If your algorithm has open orders or holdings in a security we will not remove it from your subscriptions.

Every algorithm has a hidden "user-defined-universe". The assets in this universe are set by the AddEquity / AddForex methods. These assets are fixed and never removed from your algorithm.

Universes are refreshed every day by default, but can be refreshed as often as required. This is controlled in the algorithm.UniverseSettings variable which we'll describe in more detail below.

Basic Universe API

Adding Universes
Universes are added using the AddUniverse() method API. They are a type of data subscription which control what subscriptions are requested; and as such you can create custom universe data types. Depending on what type of universe you are adding there are many helper methods to make it easier. AddUniverse() methods take function filters as parameters, these filters must return an enumerable of Symbol objects.

Universe Settings
If you do not pass in a full universe object the UniverseSettings property is used to fill in the blanks. Changing the UniverseSettings algorithm property can be helpful to simplify adding universes. Universes have 4 key properties:

    //Popular universe settings:
    UniverseSettings.Resolution      // What resolution should added assets use
                    .Leverage        // What leverage should assets use in the universe?
                    .Fillforward     // Should asset data fill forward?
                    .MinimumTimeInUniverse // Minimum time assets should be in universe
                    .ExtendedMarketHours  // Should assets also feed extended market hours?

Once added universes are stored in the IDictionary<string, Universe> UniverseManager.

Universe Events
When universe contents are changed (securities are added or removed from the algorithm) we generate an OnSecuritiesChanged event. This allows your algorithm to know the changes in the universe state. The event passes in the SecurityChanges object containing references to the Added and Removed securities.

Coarse Universe Selection

Coarse Universe selection is the built in universe data provided by QuantConnect. Using financial data we generate a few key properties for each symbol and allow you to filter the universe of 16,400+ symbols to receive the symbols matching your filter criteria. It uses the CoarseFundamental type.

Coarse fundamental has the following properties you can use to perform rough filtering.

class CoarseFundamental {
    public long Volume;          // Traded shares
    public decimal DollarVolume; // Traded shares x Price
    public decimal Price;        // Yesterday close price
    public Symbol Symbol;        // Asset symbol
}

Coarse filtering allows you to select an unlimited universe of symbols to analyse. You are only limited by practical memory and speed limits and may quickly run out of memory if you backtest too many symbols in parallel. These limits can be increased with a subscription.

Fundamentals Selection

Custom Universe Selection

Custom universes allow using an external data source as the security filtering source. Like normal custom data sources, custom universes are provided by extending BaseData. With this system you can define data formats to filter and select the data.

Each BaseData of the custom universe is 1 line of the source file. The Reader method will be called repeatedly until the date/time advances or the end of file is reached. This way you the engine can group universe data together, and pass it as a single collection into the filter function.

Option Universes

Future Universes

Historical data can be provided in a batch request, or by "warming up" your algorithm. Batch requests feed requested data back as an enumerable you can use to manually prime your algorithm. The warm up feature feeds data to your event handlers from before your start date for a fixed period.

In live mode the history API can return data up to 5 seconds before the present moment.

Historical Data Requests

Batch history API is often easier to understand as you can manually feed data into your components which need it. If Resolution of the data request is not specified the history API uses the resolution of data you've specified with AddSecurity() or your Universe, similarly if the Symbol is not specified then history for all symbols is returned for the period.

Batch data returned as IEnumerable<Slice> slices or IEnumerable<TradeBar> slices has all the normal slice helpers - to assist using the data in your strategy, for example:

//From slice -> tradebars, or slice -> decimals.  
IEnumerable<Slice> slices = History(TimeSpan.FromDays(7), Resolution.Minute);
IEnumerable<TradeBar> bars = slices.Get("SPY"); // Bars 
IEnumerable<decimal> decimals = slices.Get("SPY", Field.Close); // Close from slice

// Many math libraries need double arrays, decimals -> double[]
double[] doubleArray = decimals.ToDoubleArray();

Warming Your Algorithm

Warming up your algorithm causes data from before the algorithm starts to be fed into the conventional data event handlers. This system of warm up lends itself to stream style algorithms.

The data flowing to your algorithm will seamlessly pass from historical to live data. The flag bool IsWarmingUp can be used to monitor this transition.

During the warm up period you cannot submit orders. Warm up also does not support universe selection while the algorithm is warming up.

Models can be used to improve the accuracy of your backtesting. We provide basic default models which assume you are trading on highly liquid assets, but if you are trading high volumes, or on low volume assets you should update these models to be more realistic.

All models are set on a per security basis. To set a model first fetch the security object and apply your model.

//Set IBM to have a constant $1 transaction fee. 
Securities["IBM"].FeeModel = new ConstantFeeTransactionModel(1); 

All models should be setup in your Initialize() method.

Brokerage Models

We provide a shortcut to set common models and properties relating to each of the brokerages we support. These brokerage models set fees, fill models, slippage models and trading markets for a brokerage. In addition they validate it is possible to submit trades to the brokerage (e.g. submitting equity trades to a forex only brokerage).

• Transaction fees models
• Supported markets
• Slippage model
• Validate orders and updates before they are submitted
• Default account type (margin or cash account)
• Support for extended market hours
• How splits and dividends are applied to open order tickets
• Default leverage for assets
• Default settlement models

In addition to our default brokerage model ( DefaultBrokerageModel ), we provide brokerage models for Interactive Brokers ( InteractiveBrokersBrokerageModel ) , FXCM ( FxcmBrokerageModel ), Oanda ( OandaBrokerageModel ) and Tradier ( TradierBrokerageModel ).

Brokerage models override any other models you may set for a security.

Transaction Fee Models

Transaction fee models set the fees for each order. We provide customized transaction models for all brokerages, but you can also set your own. Like all models they must be set on a security by security basis.

Transaction models implement the ISecurityTransactionModel interface. If you wish to implement your own transaction model you can start with the SecurityTransactionModel and override methods you wish to change.

Slippage Models

Slippage is the difference in price between your last reported quote and the real price the trade filled at. This difference can be positive or negative, as sometimes the price can slip in your favor. In volatile markets you are likely to experience more slippage.

Slippage models implement the ISlippageModel interface. We provide the SpreadSlippageModel for forex based securities, and the ConstantSlippageModel for Equities.

Advanced users may wish to implement their own volatility based slippage model - increasing the accuracy of your backtests in volatile markets.

Fill Models

Fill models give you control over order fills. Each supported order type is passed through a dedicated method and returns an OrderEvent object. OrderEvents are used to carry information about order partial fills or errors.

The Fill Models implement the IFillModel interface. They have the following key methods:

public interface IFillModel {
    OrderEvent MarketFill(Security asset, MarketOrder order);
    OrderEvent StopMarketFill(Security asset, StopMarketOrder order);
    OrderEvent StopLimitFill(Security asset, StopLimitOrder order);
    OrderEvent LimitFill(Security asset, LimitOrder order);
    OrderEvent MarketOnOpenFill(Security asset, MarketOnOpenOrder order);
    OrderEvent MarketOnCloseFill(Security asset, MarketOnCloseOrder order);
}

Margin Models

Margin models control how much buying power your algorithm has to make trades. Margin calculations can be very complex and depends on many factors including the brokerage or even time of day.

Margin model implement the ISecurityMarginModel interface and default to the SecurityMarginModel class. We also provide the PatternDayTradingMarginModel to model intraday pattern day trading for US equities.

Settlement Models

After a trade is made brokerages settle the cash depending on the markets and account type. This is managed by our Settlement Models. The most common settlement type is immediate - where the funds are available for trading immediately. This is handled by the ImmediateSettlementModel . US Equities trading with cash accounts is typically settled 3 days after the transaction occurred. This is managed by the DelayedSettlementModel .

Settlement models implement the ISettlementModel interface. You can create your own settlement model by implementing this method. Most users will not need to create their own settlement model and can use one of the ones provided above.

Portfolio Models

Portfolio models control how order fills are applied to your portfolio. They take an OrderEvent , Security and SecurityPortfolioManager object and update the holdings to reflect the new final position. You should only need to update your portfolio model when you are create a new asset type.

Portfolio models implement the ISecurityPortfolioModel interface.

Volatility Model

The volatility model is a property of a security. Exactly how volatility is calculated varies a lot between strategies so we've provided an override point here. Volatility models get updated with data each time step and are expected to be updated immediately. This is primarily require for options backtesting.

Volatility models implement the IVolatilityModel interface. We default to the NullVolatilityModel which returns 0 volatility at all times. As a helper we also provide the RelativeStandardDeviationVolatilityModel which calculates the volatility based on standard deviation.

We provide a powerful charting API which can be build many chart types. At its simplest it can be used with a single line of code:

Plot("Series Name", value);

Plot("Series Name", value)

With this code a line-graph is added underneath your Strategy Equity chart and your requested values are displayed over time. To create a new chart (new tab) you should also specify the chart name in your request:

Plot("My Indicators", "EMA", ema);

Behind the scenes these methods create a new Chart object and add it to your algorithm, and then add a new Series object to that chart. A chart is made from many series. You can also initialize your charts manually to get more control over their look and feel.

Manually Creating Charts

In your initialize method you can use the AddChart(Chart obj) method to insert a new chart. Each chart object has an internal collection of Series objects.

In creating Series objects you must specify the name of the series, the SeriesType and the index the series operates on. The series index refers to its position in the chart - for example; if all the series are index 0, they will lay on top of each other. If each series has its own index, it will be have several mini-charts stack next to each other.

The picture below shows an EMA cross chart with both EMA series set to the same index: Using different indexes the chart looks as follows:

Supported Series Types

The charting API supports the follow series types. Nothing special is required to use these series, simply specify them for your series when creating your chart.

   SeriesType.Line
             .Scatter
             .Candle
             .Bar
             .Flag

Charting Limitations

Intensive charting generates hundreds of megabytes (200MB) of data which is far too much to stream online or display in a web browser. Because of this we limit the number of points a chart can have to 4000. If you see an error Exceeded maximum points per chart, data skipped you have hit this limit and should reduce your sampling frequency.

Debug Messages

Algorithms can send debug messages to the console using the Debug(string message) method. Debug messages are capped at 200 characters long. If multiple identical messages are sent within 1 second we rate limit the messages to avoid crashing your browser.

Errors Messages

Algorithms can send error messages to the console using the Error(string message) method. Error messages appear red in the console so you can see them easily. Like debug messages, error messages are rate limited to avoid flooding your browser.

Logging

Algorithms can save more detailed messaging to log files for later analysis using Log(string message). At the end of the backtest a link will be presented to view your results. In live trading a log viewer lets you view log results while the algorithm is running. Because of data vendor limitations price information cannot be recorded in logs.

Because of vendor limitations free users are capped to 10kb of logs per backtest, with a maximum of 3Mb per day. Users with a subscription can generate up to 100kb of logs per backtest.

Supported Brokerages

Algorithms designed in QuantConnect can be seamlessly live traded on your brokerage accounts. We send the algorithm signals to your brokerage and track the algorithm state. Algorithms can be deployed immediately at any time of the day or night. A subscription is required for live trading however many brokerages sponsor live trading for their clients.

Notifications

In live trading mode we allow sending Email, SMS and Web-Hook notifications to notify you of significant events. You can send up to 20 notifications per hour. These are only sent during live trading.

Runtime Statistics

Runtime statistics are custom defined banner statistics displayed across the top of your live algorithm.

You can add your own runtime-statistics using the SetRuntimeStatistic(string name, string value); method. In the image above the user displays the current value of BTC: SetRuntimeStatistic("BTC", data["BTC"].Close);

For a full list of Frequently Asked Questions please see the FAQ page.

Runtime Error: 'AAPL' wasn't found in the TradeBars object

You're attempting to access data which is not in the TradeBars dictionary. There are two key reasons for this:
1. You have not requested data for this security in the Initialize method.
2. The data has gaps because it is not filling forward, or you're accessing the data after-hours when there won't be any price information.

Backtest Error: Error initializing algorithm: Date Invalid

You may have accidentally put invalid start and end dates into your algorithm. Or potentially you pressed backtest before the algorithm was fully saved. Please Ctrl+S to save the document, wait for its confirmation, and then click Backtest again.

Local Development

We recommend using Visual Studio Community Edition as your programming environment. The community edition has the full power of Visual Studio and enables programming in C#, F#, VB and Python. If you're running on Mac or Linux you can also use MonoDevelop or Xamarin Studio.

If you prefer coding locally, you can run LEAN inside Visual Studio. The LEAN installation takes about 5 minutes and allows you to backtest locally and copy-paste your algorithms into QuantConnect.com. Check out the LEAN-Getting Started Tutorial for more information.

Learning Programming

We aim to make it as easy as possible to use QuantConnect but you still need to be able to program. We've provided some links below to get you started:

Introduction to the IDE

The best source for example algorithms are shared community discussions. However we provide the example video tutorials below to help get you started with QuantConnect.

There are hundreds of code snippets and example algorithms in the QuantConnect University accessible through the Terminal.