QuantConnect and LEAN

01What it is, and a short history

QuantConnect dates LEAN to 2012.¹ The engine was released as open source on 12 January 2015, in a forum announcement by Jared Broad that described it as the result of three years of development; the repository’s first public commit carries that date.^2,3 It is licensed under Apache 2.0, so it can be run, modified and deployed privately without the hosted platform.³

The engine is written in C#. Python algorithms call the same engine through Python.NET, so a Python strategy uses the C# order, portfolio and data machinery rather than a separate reimplementation.^4,5 Since 2024 the Python API uses PEP 8 names (set_holdings, on_data), and the older CamelCase names remain valid; the announcement warns that attribute names of your own can now clash with API methods, which is why the examples below prefix theirs with an underscore.⁶The command-line tool’s first release on PyPI and its announcement are dated in the table.^7,1

02Architecture

One algorithm, two worlds

LEAN is event-driven. The documentation describes it as a streaming analysis system: data is fed to the algorithm one time slice at a time, in fast-forward during a backtest and in real time when live, so the same algorithm code runs in both.⁸ The engine achieves this by assembling itself from handlers chosen by configuration. The data feed, the transaction handler, the setup handler and the real-time clock each have a backtesting and a live implementation; the algorithm sees the same interface either way (Figure 1).⁹

The algorithm framework

A strategy can be written as a single class, or as five pluggable models that the framework runs in sequence: universe selection chooses the securities, the alpha model emits directional insights, portfolio construction turns insights into portfolio targets (a quantity for each security), risk management adjusts the targets, and execution places the orders that move the portfolio towards them.¹⁰ The separation is the same one this series uses: a signal (Field note 03 (Indicators, and the 200-day moving average)), sizing (Field note 02 (Volatility targeting)) and execution (Field note 05 (Execution: TWAP, slicing and jitter)) are different problems and are easier to test apart.

Around the algorithm, a brokerage model sets what a given broker allows and charges: fees, supported assets and order types, leverage and settlement, the fill, slippage and buying-power models that follow from them, and the validation of each order before it is sent.¹¹ Data arrives at tick, second, minute, hour or daily resolution; US equity subscriptions default to minute.¹²

03Using it

A first algorithm

The smallest useful algorithm sets a date range and starting cash, subscribes to a security and trades on data. This is LEAN’s own template, in the current Python naming:¹³

from AlgorithmImports import *


class BasicTemplateAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2013, 10, 7)
        self.set_end_date(2013, 10, 11)
        self.set_cash(100000)
        self.add_equity("SPY", Resolution.MINUTE)

    def on_data(self, data):
        if not self.portfolio.invested:
            self.set_holdings("SPY", 1)

A slightly larger example, Field note 03 (Indicators, and the 200-day moving average)’s trend rule, shows the pieces a real strategy uses: a built-in indicator registered with the engine, a warm-up period that fills it before trading starts, and an explicit guard while it warms up.¹⁴

from AlgorithmImports import *


class TrendOverlay(QCAlgorithm):
    """Hold the ETF while it is above its 200-day simple moving average; otherwise hold cash.

    Field note 03's rule, written for LEAN. With daily bars the signal is only known after the
    close, so read the market-order documentation for when the resulting order fills.
    """

    def initialize(self):
        self.set_start_date(2010, 1, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(100_000)
        # Leading underscores: in the PEP 8 API, `symbol` and `sma` are QCAlgorithm methods.
        self._symbol = self.add_equity("SPY", Resolution.DAILY).symbol
        self._trend = self.sma(self._symbol, 200, Resolution.DAILY)   # a registered indicator
        self.set_warm_up(200, Resolution.DAILY)                         # fill it before trading

    def on_data(self, data: Slice):
        if self.is_warming_up or not self._trend.is_ready:
            return
        price = self.securities[self._symbol].price
        above = price > self._trend.current.value
        if above and not self.portfolio.invested:
            self.set_holdings(self._symbol, 1.0)
        elif not above and self.portfolio.invested:
            self.liquidate(self._symbol)

Where the work is done

The hosted platform provides a browser IDE, research notebooks attached to the data library, cloud backtesting and live deployment.^16,17 The lean command-line tool brings the same workflow to a local editor: it runs the engine locally in Docker and can push projects to and pull them from the cloud. Its documentation states that using it requires membership of a paid organisation tier.^18,19

pip install --upgrade lean      # needs Docker for local runs
lean login                      # link the CLI to your QuantConnect account
lean init                       # set up a workspace in the current directory
lean create-project "Trend Overlay"
lean backtest "Trend Overlay"   # run LEAN locally in Docker
lean cloud backtest "Trend Overlay" --push   # or push and run in the cloud

04Data

The data library is one of the platform’s main assets: point-in-time, survivorship-bias-free US equities and a range of derivatives and alternative datasets, available in backtests and notebooks without separate licensing work. The documented coverage of the core price data:^{20,21,22,23,24,25}

Equity prices are split- and dividend-adjusted by default, and raw, split-adjusted and total-return modes can be chosen per subscription (a scaled-raw mode applies to history requests).¹² The choice matters: under the default adjusted mode a backtest also fills at adjusted prices, which differ from the prices a live order will see, so a strategy whose sizing, limit prices or cost model depends on the traded price may be better tested on raw data.

05Strengths and cautions

In our use the engine has been mature and dependable, and most problems we have met came from defaults and assumptions rather than from the engine itself. An honest summary:

Four habits make results from any backtesting engine, this one included, closer to what live trading will deliver:

1. Set the reality models explicitly. Choose the brokerage model for the broker you will use and a slippage model; do not rely on the defaults.^26,27
2. Backtest at the resolution you will trade. If live orders are sent intraday, backtest on minute data, so fills see the same prices and times.
3. Record the engine version and parameters with every result. The engine evolves; a backtest that cannot be rerun on the same code is an anecdote.
4. Reconcile live against backtest from the first day. Compare positions and fills, not only returns. Differences found in the first week are cheap; differences found after a year are not.

06Documentation

The official documentation is extensive. These pages are the useful entry points; every link was checked in September 2026.