---
title: "Live Deployment Automation"
canonical: https://www.quantconnect.com/docs/v2/research-environment/meta-analysis/live-deployment-automation
markdown: https://www.quantconnect.com/docs/v2/research-environment/meta-analysis/live-deployment-automation.md
language: python
source: https://github.com/QuantConnect/Documentation/tree/master/04%20Research%20Environment/10%20Meta%20Analysis/06%20Live%20Deployment%20Automation
modified: 2026-11-01
index: https://www.quantconnect.com/llms.txt
---

# Live Deployment Automation

[Documentation](https://www.quantconnect.com/docs/v2.md) > [Research Environment](https://www.quantconnect.com/docs/v2/research-environment.md) > Meta Analysis > Live Deployment Automation

> Code examples are shown in Python. Append `?lang=csharp` to this URL for the C# version of this page.

## Introduction

This page explains how use [QuantConnect API](https://www.quantconnect.com/docs/v2/cloud-platform/api-reference.md) 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](https://www.quantconnect.com/docs/v2/cloud-platform/projects/getting-started.md#08-Create-Project-Directories) 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](https://www.quantconnect.com/docs/v2/research-environment/key-concepts/getting-started.md#03-Open-Notebooks).
2. Call the `list_projects` method to get a list of all project responses.
   ```python
   list_project_response = api.list_projects()
   ```
3. Obtain the project Ids for the projects in `/Live` directory.
   ```python
   project_ids = [
       project.project_id for project in list_project_response.projects
       if project.name.split("/")[0] == "Live"
   ]
   ```

## 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.
   ```python
   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}")
       else:
           compile_id_by_project_id[project_id] = compile_response.compile_id
   ```
2. Get the Ids of all the live nodes that are available and sort them by their speed.
   ```python
   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}")
   else:
       nodes = sorted(
           [node for node in node_response.nodes.live_nodes if not node.busy],
           key=lambda node: node.speed,
           reverse=True
       )
       node_ids = [node.id for node in nodes]
   ```
   Check the length of `node_ids` is greater than 0 to ensure there are live nodes available.
3. Configure your brokerage and environment.
   For example, to use the QC paper brokerage, run:
   ```python
   base_live_algorithm_settings = {
       "id": "QuantConnectBrokerage",
       "user": "",
       "password": "",
       "environment": "paper",
       "account": ""
   }
   version_id = "-1" # Master branch
   ```
4. Deploy the projects and cache the project Ids of the successful deployments.
   ```python
   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}")
       else:
           print(f"Deployed {project_id}")
           deployed_ids.append(project_id)
   ```

## Stop Live Algorithms

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

```python
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}")
    else:
        print(f"Successfully stopped live algorithm {project_id}")
```

## Examples

### Example 1: Create New GPU Deployment

The following example will create a new live algorithm deployment using a GPU live node with the [Interactive Brokers](https://qnt.co/interactive-brokers) in a jupyter notebook. It can help with a streamline deployment.

```python
# Instantiate QuantBook instance for researching.
qb = QuantBook()

# Get all the nodes available in the current project.
project_nodes = api.read_project_nodes(qb.project_id)
# Obtain the most powerful live GPU node which is idling.
live_node_id = max(
    [x for x in project_nodes.nodes.live_nodes if x.has_gpu and not x.busy],
    key=lambda x: x.cpu_count
).id

# Compile the project before deploying.
compilation = api.create_compile(qb.project_id)
compile_id = compilation.compile_id

# Deploy the live algorithm with the brokerage settings.
brokerage_settings = {
    "id": "InteractiveBrokersBrokerage",
    "ib-user-name": "user-name",
    "ib-account": "account-number",
    "ib-password": "password",
    "ib-weekly-restart-utc-time": "00:00:00"
}
result = api.create_live_algorithm(qb.project_id, compile_id, live_node_id, brokerage_settings)
```