Meta Analysis

Live Deployment Automation


This page explains how use QuantConnect API in an interactive notebook to deploy and stop a set of live trading algorithms in QC Cloud.

Get Project Ids

To automate live deployments for multiple projects, save the projects under a single directory in QuantConnect Cloud. This tutorial assumes you save all the projects under a /Live directory.

Follow the below steps to get the project Ids of all projects under the /Live directory:

  1. Open a research notebook.
  2. Load the assembly files and data types in their own cell.
  3. #load "../Initialize.csx"
  4. Import the data types.
  5. #load "../QuantConnect.csx"
    #r "../Microsoft.Data.Analysis.dll"
    using QuantConnect;
    using QuantConnect.Data;
    using QuantConnect.Algorithm;
    using QuantConnect.Research;
    using QuantConnect.Indicators;
    using Microsoft.Data.Analysis;
  6. Call the list_projects method to get a list of all project responses.
  7. list_project_response = api.list_projects()
    var listProjectResponse = api.ListProjects();
  8. Obtain the project Ids for the projects in /Live directory.
  9. project_ids = [
        project.project_id for project in list_project_response.projects
        if"/")[0] == "Live"
    var projectIds = listProjectResponse.Projects
                .Where(project => project.Name.Split('/').First() == "Live")
                .Select(project => project.ProjectId)

Deploy Live Algorithms

Follow these steps to progromatically deploy the preceding projects with the QuantConnect API:

  1. Compile all the projects and cache the compilation Ids with a dictionary.
  2. compile_id_by_project_id = {}
    for project_id in project_ids:
        compile_response = api.create_compile(project_id)
        if not compile_response.success:
            print(f"Errors compiling project {project_id}: \n{compile_response.errors}")
            compile_id_by_project_id[project_id] = compile_response.compile_id
    var compileIdsByProjectIds = new Dictionary<int, string>();
    foreach (var projectId in projectIds)
        var compileResponse = api.CreateCompile(projectId);
        if (!compileResponse.Success)
            Console.WriteLine($"Errors compiling project {projectId}: \n{compileResponse.Errors}");
            compileIdsByProjectIds[projectId] = compileResponse.CompileId;
  3. Get the Ids of all the live nodes that are available and sort them by their speed.
  4. live_nodes = []
    node_response = api.read_project_nodes(project_ids[0])
    if not node_response.success:
        print(f"Error getting nodes: \n{node_response.errors}")
        nodes = sorted(
            [node for node in node_response.nodes.live_nodes if not node.busy], 
            key=lambda node: node.speed, 
        node_ids = [ for node in nodes]
    var liveNodes = new List<string>();
    var nodeResponse = api.ReadProjectNodes(projectIds[0]);
    if (!nodeResponse.Success)
        Console.WriteLine($"Error getting nodes: \n{nodeResponse.Errors}");
        nodesIds = nodeResponse.Nodes.LiveNodes
            .Where(node => !node.Busy)
            .OrderByDescending(node => node.Speed)
            .Select(node => node.Id)

    Check the length of node_idsnodeIds is greater than 0 to ensure there are live nodes available.

  5. Configure your brokerage and environment.
  6. For example, to use the QC paper brokerage, run:

    base_live_algorithm_settings = {
        "id": "QuantConnectBrokerage",
        "user": "", 
        "password": "", 
        "environment": "paper", 
        "account": ""
    version_id = "-1" # Master branch
    var baseLiveAlgorithmSettings = new Dictionary<string, object>
        {"id", "QuantConnectBrokerage"},
        {"user", ""}, 
        {"password", ""}, 
        {"environment", "paper"},
        {"account", ""}
    // Master branch
    var versionId = "-1";
  7. Deploy the projects and cache the project Ids of the successful deployments.
  8. deployed_ids = []
    for project_id, compile_id in compile_id_by_project_id.items():
        # Deploy live algorithm
        node_id = node_ids[len(deployed_ids)] # Fastest node available
        live_response = api.create_live_algorithm(project_id, compile_id, node_id, base_live_algorithm_settings, version_id)
        if not live_response.success:
            print(f"Errors deploying project {project_id}: \n{live_response.errors}")
            print(f"Deployed {project_id}")
    var deployedIds = new List<int>();
    foreach (var kvp in compileIdsByProjectIds)
        var projectId = kvp.Key;
        var compileId = kvp.Value;
        // Deploy live algorithm
        var nodeId = nodeIds[deployedIds.Count()];
        var liveResponse = api.CreateLiveAlgorithm(projectId, compileId, nodeId, baseLiveAlgorithmSettings, versionId);
        if (!liveResponse.Success)
            Console.WriteLine($"Errors deploying project {projectId}: \n{liveResponse.Errors}");
            Console.WriteLine($"Deployed {projectId}");

Stop Live Algorithms

To stop multiple live algorithms from an interactive notebook through the QuantConnect API, call the api.StopLiveAlgorithmapi.stop_live_algorithm method with each project Id.

for project_id in project_ids:
    stop_response = api.stop_live_algorithm(project_id)
    if not stop_response.success:
        print(f"Errors stopping live algorithm {project_id}: \n{stop_response.errors}")
        print(f"Successfully stopped live algorithm {project_id}")
foreach (var projectId in projectIds)
    var stopResponse = api.StopLiveAlgorithm(projectId);
    if (!stopResponse.Success)
        Console.WriteLine($"Errors stopping live algorithm {projectId}: \n{stopResponse.Errors}");
        Console.WriteLine($"Successfully stopped live algorithm {projectId}");

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: