Category: Coding (page 1 of 2)

Tracking and Managing Orders

Tracking and managing orders is an important part of an algorithmic trading strategy. Intelligent order management encourages discipline and a deep understanding of your algorithm. Through the QuantConnect API you can get order fields, update their values and cancel pending orders. This can be useful for lowering trading costs and improving order fills.

When you place a trade you receive an OrderTicket for you to access the order. This allows you to safely (asynchronously) update and cancel the order while in live trading. In live trading you cannot assume order updates are processed successfully as the brokerage may have already filled the trade.

You can place several types of orders including:

Supported Order Types
Market Order MarketOrder("SPY", 100);
Limit Order var ticket = LimitOrder("SPY", 100, 100.10m);
Stop Market Order var ticket = StopMarketOrder("SPY", 100, 100.10m);
Stop Limit Order var ticket = StopLimitOrder("SPY", 100, 100.12m, 99.5m);
Market On Open Order var ticket = MarketOnOpen("SPY", 100);
Market On Close Order var ticket = MarketOnClose("SPY", 100);


Once you have an order ticket you can use it to get order fields:

var currentStopPrice = _ticket.Get(OrderField.StopPrice);

Or update the order fields (LimitPrice, StopPrice, Tag or Quantity):

_ticket.Update(new UpdateOrderFields
    LimitPrice = newLongLimit,
    Tag = "Update #" + (longOrder.UpdateRequests.Count + 1)

You can also cancel your order if required:


In the video below we demonstrate putting it all together to create a moving take-profit order which gradually decreases its profit target as time passes.

Scheduled Events

Scheduled events allow you to trigger code blocks for execution at specific times according to rules you set. This feature helps coordinate your algorithm activities and perform analysis at regular intervals; while letting the trading engine take care of market holidays.

The scheduling is set with two rules: the DateRules and TimeRules classes. The schedule manager takes one of each and executes an action code block:

Schedule.On(DateRules.On(2013, 10, 7), TimeRules.At(13, 0), () => 
         Debug("Specific Time: Fired at : " + Time);

The date rules can be specified as below:

Scheduled Events Date Rules
DateRules.On(2013, 10, 7) On a specific date
DateRules.EveryDay("SPY") Every trading day for SPY
DateRules.Every(DayOfWeek.Monday, ...) On specific days of week
DateRules.EveryDay() Every day
DateRules.MonthStart("SPY") SPY trading start of each month

The time rules trigger specify when on the day the event should be triggered. They can be specified as below:

Scheduled Events Time Rules
TimeRules.At(13, 0) At a specific time, 1:00pm
TimeRules.AfterMarketOpen("SPY", 10) Run 10 minutes after market open for SPY
TimeRules.BeforeMarketClose("SPY", 10) Run 10 minutes before market close for SPY
TimeRules.Every(TimeSpan.FromMinutes(10)) Every 10 minutes during day specified

For a demonstration see the tutorial video below:

Desktop Charting with LEAN

With a few configuration changes you can get desktop charting in LEAN with a HTML5 interface very similar to the one you see in This gives you better visual feedback on your strategy and allows you to improve faster. This tutorial guides you through configuring a desktop charting environment with LEAN.

Local charting (and all local backtesting) requires you to have your own source of data. We provide a way to download FX and CFD data through our API. To get started make sure you have your data in your data folder. By default this is the /Data/ directory relative to your LEAN installation.

Two configuration changes are required for desktop charting to work:

  1. Change the “environment” field to use “backtesting-desktop”. This instructs LEAN to use the configuration settings block at the bottom of the config file.
      "environment": "backtesting-desktop",
  2. Insert your API token and user id into configuration file. This is required for chart streaming.
      // To get your api access token go to
      "job-user-id": "....",
      "api-access-token": "...........",

With those changes in place you can simply run the project and your backtesting chart will appear in a few seconds. For live trading; use the”live-desktop” configuration environment.

If you get the run-time exception “The port configured in config.json is either being used or blocked by a firewall”- This normally means you’ve left the user interface open (you should close it between each run). It can also be because another program is sharing that port. You can fix this by changing the port LEAN transmits the data with the "desktop-http-port" setting.

In the tutorial video below we demonstrate this feature on LEAN:

Collaborating in QuantConnect

Collaborating is a powerful feature of QuantConnect which allows up to 10 team members to work on a project at the same time. This can be useful when a team of specialists collaborates to build a great strategy.

The project creator holds the master copy of the project and can add team members and control the project permissions. To add a team member you just click the “Share” button in the project tab and search for the user by name or email address. Once the user is added you can control their permissions or remove them from the project.

Collaboration allows setting permissions on user by user level

Changes to shared projects are instantly shared between the collaborators and can be see by the colorful cursor representing the other team members.

Consolidating Data to Build Bars

Consolidators are used to combine data together from finer resolutions into larger ones. This can be useful for indicators with specific data requirements or to perform long term analysis in conjunction with short term signals.

Consolidators should be constructed and setup in your Initialize() method; this ensures they are only initialized once. There are three key steps to create and register a consolidator:

  1. Create the consolidator object.
  2. Bind an event handler to handle the new bars.
  3. Register it with the subscription manager to start receiving data.
public class ConsolidatorDemoAlgorithm : QCAlgorithm
	public override void Initialize() 
		// backtest parameters
		SetStartDate(2016, 1, 1);         
		// cash allocation
		//assets or universe selection
		AddEquity("SPY", Resolution.Minute);
		//create a consolidator object; for tradebars; for a timespan of 30 minutes
		var thirtyMinutes = new TradeBarConsolidator(TimeSpan.FromMinutes(30));

		//bind event handler to data consolidated event.
		thirtyMinutes.DataConsolidated += OnHalfHour;
		//register the consolidator for data.
		SubscriptionManager.AddConsolidator("SPY", thirtyMinutes);
	//event handler for data!
	public void OnHalfHour(object sender, TradeBar bar) {
		Debug(Time.ToString("u") + " " + bar);
	public override void OnData(Slice data) 
	{ }

The LEAN API also has other consolidator types to handle working with Ticks and RenkoBars:

// From tick data sources            
var tickConsolidator = new TickConsolidator(TimeSpan.FromMinutes(30)); 

//from renko bars
var renkoConsolidator = new RenkoConsolidator(TimeSpan.FromMinutes(30)); 

There are two key points to remember:

  1. Request a smaller resolution than what you want to produce.
  2. In backtesting we only know the bar is ready on the next data point; so it may appear like daily bars are triggered at odd times. In live trading they are scanned to be triggered every second at a minimum.

The raw data of QuantConnect is provided in Tick, Minute, Second, Hour or Daily bars. Using these building blocks you can combine data together to get any other resolution of data required.

Introducing The Co-Pilot: Your Coding Companion

We’re happy to announce the release of the Co-Pilot; a rich automated documentation generator built to give you relevant hints while you’re building your strategy. With deep API’s it is impossible to memorize all the methods available; and time consuming to constantly search the documentation. As a coding companion, the co-pilot can inspect the types you’re working on and provide the properties that are available.

The methods of the API are shown by the tables of code blocks, and detailed properties of the working variables are also available. We generate documentation from the reference text but also from the code API. These different documentation types are noted by the icons next to the results.

There are multiple documentation result types; text and code results.

Free Streaming Live Data with IEX – LEAN Release Notes v2.3.0.3

This releaseadds the IEXDataQueueHandler allowing LEAN users to stream free US equity trades to their strategy; along with numerous bug fixes to the OANDA and FXCM brokerage implementations. Additional regression algorithms were added to automate testing of daily data algorithms. The Interactive Brokersconnection logic was also made more intelligent to fail quickly when thereis an existing TWS connection open.There were no breaking changes in regression tests or the API of LEAN.

Download this release from GitHub.


  • Added IEX IDataQueueHandler for a free live US equity datafeed.
  • Added DailyBasicTemplate regression test algorithm.
  • Dramatically speed up Interactive Brokers connection speed.
  • Scan IBController logs for connection failures and handle them in LEAN.
  • Added FilteredIdentity indicator to filter tick trades and quotes.
  • Created Lean.TryParsePath() to create symbols from a file path.
  • Added ApiFileProvider to download data directly from the API.
  • Upgrade Oanda HistoryProvider to return QuoteBars instead of TradeBars.

Bug Fixes

  • Fix duplicate sampling bug in daily data backtesting.
  • Remove time from daily sample points in backtesting.
  • Properly load existing short positions when launching Interactive Brokers algorithm.
  • Fix issue with indicators that require a quote subscription.
  • Check for valid symbols when getting OANDA or FXCM history request.
  • Ensure logs are only savedonce.


  • We upgraded LEAN to use JSON.NET v9.0.1. This library is used extensively through LEAN.

Thank you to the community contributors in this release buybackoff andJay-Jay-D!

About LEAN

LEAN aims to empower investors to invest with confidence by using cutting edge algorithmic trading technology. Through the power of open source we are building the world’s best algorithmic trading platform, capable of accurately modeling global markets to give you insight into your strategy. Your trading algorithms can be seamlessly deployed from backtesting into production with no changes or even moved between brokerages. The LEAN user community reaches over 29,000 quants from all over the world.

LEAN supports C#, F#, VB, Java and Python programming languages and can be used in Equity, Forex, CFD, Options and Futures markets. It currently supports live paper trading, or execution by Interactive Brokers, FXCM and Oanda Brokerage.

For more information join the LEAN Community on GitHub.

Our Answer to NYSE Eliminating Stop Orders

From February 26th investors will no longer be able to use Stop or Good Till Cancelled order types on the NYSE, according to a recent press release from Reuters.

Typically Stop Market orders are used to place a market order when the stock exceeds a trigger price. On August 24th, 2015 many investors had their positions stopped out far below the stop prices they had entered. This is a known behavior of stop orders which cannot guarantee a certain execution price.

The difference between the market price, and the fill price is called slippage. In QuantConnect you can model slippage using our TransactionModel class. It would be wise to create a fill model which predicts a greater slippage in volatile market conditions. Most of the time this slippage is assumed to be negative (you execute at a price worse than expected), but occasionally you can even receive positive slippage (a better price than you expected).

To set a custom slippage model in QuantConnect you can use the code below:

 //$2 per trade transaction model, with custom slippage.
Securities["AAPL"].TransactionModel = new MyTransactionModel(2.00m);
public class MyTransactionModel : ConstantFeeTransactionModel { 
    public override decimal GetSlippageApproximation(Security security, Order order) {
        // If volatile, return high value for slippage.

To prevent negative slippage with Stop orders investors should use a Stop Limit order which places a limit order when the market exceeds the trigger price. Stop Limit orders are not guaranteed to be filled but they do ensure you get your expected fill price or better.

To submit a Stop Limit order with QuantConnect you can use the code below:

var newStopLimitOrderTicket = StopLimitOrder("IBM", 10, stopPrice, limitPrice);

At QuantConnect we will continue supporting Stop, Stop Limit and GTC Orders across all our supported brokerages using software techniques. This will ensure your algorithm can continue as expected with no interruptions. We believe you are sophisticated enough to harnesspowerful types and we won’t artificially restrict the tools in your arsenal!

Happy Coding!


Live Trading with Interactive Brokers

We’re very proud to announce our public release of live trading with Interactive Brokers! Now you can seamlessly design and trade your algorithm within QuantConnect.

Automated live trading is one of the most challenging engineering problems in financial technology. It involves controlling large financial resources, while pushing computational power to its limits!

Starting today, you can deploy your algorithms to your Interactive Brokers accounts, using minute, second or tick resolution data for Equities and FOREX. All powered by our open source algorithmic trading platform, LEAN.

Live Trading GUI

QuantConnect live trading comes packed with some impressive functionality to help your trading!

SMS and Email Notifications

Trigger sending emails, web hooks or SMS messages on key events with a single line of code. It is as simple as:

Custom Live Data Sources

Using QuantConnect you can connect your algorithm to external data sources and stream updates to your algorithm events. Check out our demo using a Bitcoin REST API.

Runtime Statistics

With runtime statistics you can display custom information in the header of your live GUI to track your key indicators and asset values.

SetRuntimeStatistic("EURUSD", price);
Runtime Statistics

Mobile Control Interface

Control your algorithm on the road with our mobile friendly, HTML5 GUI. You can see full running algorithm charts and trades, or just a summary of your algorithm performance.

Live Mobile Controller

Live Options

Upgrade to Start Live Trading Today with QuantConnect

Open Source Updates

Its been an awesome month for the open-source project with contributions from people all around the world. We love working with the community and seeing LEAN used in ways we can barely imagine!

@kaffeebrauer contributed the Stochastic and OnBalance Indicators
@AlexCatarino implemented the ROC, ROCP and WILR Indicators
@QANTau started implementation of an OANDA Brokerage
@bizcad created a Weighted Moving Average Indicator
@mattmast created the Money Flow Index(MFI) Indicator
@bdilber started working on futures support

Additionally thanks to @ammachado, and @dpallone for documentation fixes, and @willniu for working out our consolidator logic 🙂 The LEAN Engine is growing more powerful by the week.

We’re Raising Capital

We’ve been experiencing some incredible growth and have bold plans for the next 12 months! We are opening an investment round and talking to investors to continue our growth plan.

Open Source Future of Algorithmic Trading

We’re proud to announce, thanks to the support of the community, the LEAN Algorithmic Trading Engine is now 100% open source. You have the freedom to connect any data source, execute through any brokerage and design any algorithm 100% locally.

Moment of our Open Sourcing, Jan 12th 2015

It’s an exciting new frontier for algorithmic trading; through open source QuantConnect is breaking open the traditionally secretive world of algorithmic trading to give you the same powerful tools as major hedge-funds.

Lean is “plug and play“. Running your first backtest takes about 23 seconds.

1. Star/Fork and Download the QuantConnect/LEAN Repo* from GitHub
2. Open Lean Project in Visual Studio (let Nuget download all dependencies)
3. Press F5 to Run Project

Presto - you’ve run your first backtest! Here is a step by step guide for building your first algorithm. You can also design custom indicators, import data for international stock markets and connect with any brokerage. We even ship some data with the repo so you can get started instantly.

Clone LEAN Today to Start Your Journey

Clone LEAN Today to Start Your Journey

We’re incredibly grateful to the QuantConnect pioneers for making this possible. With your support we can build the best algorithmic trading platform in the world. Sustainable, independent and community driven.

More Raw Power

To be profitable you need to iterate quickly. Last week we upgraded our backtest processing servers: you can now run a 10 year, event driven backtest in 33 seconds. Your algorithms are running on beautiful i7x3930’s with 6 cores/12 threads/64GB ram. We are the world’s first cloud-desktop hybrid algorithmic trading platform aiming to give you the best of both worlds; ease of local development and horse power of the cloud.

Dynamic Indicator System

Thanks to some long hours by Michael H we launched an elegant, powerful and dynamic new indicator library. It lets you implement designs quickly and avoids reinventing the wheel. Creating an indicator is only a single line of code! Get started with the sample algorithm.

var rsi = RSI("SPY", 14);
var bb = BB(_symbol, 20, 1, MovingAverageType.Simple, Resolution.Daily);
if (rsi > 80) {
    SetHoldings("SPY", 1);
} else if (rsi < 20) {
    SetHoldings("SPY", -1);
Plot("BB", bb.UpperBand, bb.MiddleBand, bb.LowerBand);
Clone the sample algorithm which implements 15+ indicators.

Bollinger Bands Implementation – Clone the sample algorithm which implements 15+ indicators.


Older posts

© 2017 QuantConnect Blog

Democratizing algorithmic investments Up ↑