What is Boot Camp?
Boot Camp is a great way to improve your skills and learn the QuantConnect API in easily digestible portions.
Don't have an account? Join QuantConnect Today
We are dedicated to providing investors with a cutting-edge platform for rapidly creating quant investment strategies. Founded in 2012, we've empowered more than 250,000 quants and engineers to create and trade their ideas.
Quickly and easily started with our API to build your strategy. The learning center lessons are interactive, step-by-step guides to make you productive as fast as possible.
Focus your efforts on driving alpha, not parsing CSV files. Our cloud offers hundreds of terabytes of traditional and alternative data preformatted, cleaned, and instantly accessible by our API.
Coordinate teamwork, control access permissions, and your shared cloud resources. Grow your trading organization safely and efficiently on top of our cloud architecture.
A selection of streaming live-trading strategies written by QuantConnect, and top highlights from the community available to follow and clone. Peer into detailed real-time positions to gain insight for your own trading.
What is Boot Camp?
Boot Camp is a great way to improve your skills and learn the QuantConnect API in easily digestible portions.
A collection of courses from independent educators to improve your quant skill base and create better strategies.
Solidify and expand your quant skill base with courses at QuantConnect
Learn algorithmic trading with python for US Equities. Guided strategy development in easily digestible portions.
Author: QuantConnect
Free | 95,944 People Enrolled
Learn algorithmic trading with python for FX. Guided strategy development in easily digestible portions.
Author: QuantConnect
Free | 20,567 People Enrolled
Learn algorithmic trading with python for Futures. Guided strategy development in easily digestible portions.
Author: QuantConnect
Free | 7,418 People Enrolled
In this algorithmic trading tutorial series you will learn everything you need to know to start writing your own trading bots using Python and the QuantConnect quantitative trading platform.
Author: Louis
Free | 28,751 People Enrolled
Master algorithmic trading on QuantConnect; backtest and live trade Stocks, Options, Futures, Forex, and Crypto.
Author: Cheng Li
Paid | Enroll on Udemy
Learn to use Python, Pandas, Matplotlib, and the QuantConnect Lean Engine to perform financial analysis and trading.
Author: Jose Portilla, Pierian Training
Paid | Enroll on Udemy
Learn to write programs that algorithmically trade cryptocurrencies using QuantConnect (C#).
Author: Eric Summers
Paid | Enroll on Udemy
Organization Notes
Get Started with Algorithm Lab
New Research
Optimizing a Gold-SPY Portfolio Using Hidden Markov Models for Market Downtime
Gold-SPY portfolio optimization using Hidden Markov Models for minimizing market downturn risk....
ReadAlgorithm Lab is your playground for developing and refining trading algorithms with QuantConnect. Utilize advanced tools, historical data, and robust backtesting to enhance your trading strategies. Transform your ideas into actionable insights and optimize your trading approach with ease.
Sign Up for FreeAlready have an account Log In.
This account is protected by two-factor authentication.
Request Token Information Reset My TokenCreated | Last Time Used | Agent | |
---|---|---|---|
No entries found |
To continue please enter your email:
(No google account required)
To verify that everything goes well please enter the 6 digit verification code generated by the authenticator application
Algorithm Lab is your playground for developing and refining trading algorithms with QuantConnect. Utilize advanced tools, historical data, and robust backtesting to enhance your trading strategies. Transform your ideas into actionable insights and optimize your trading approach with ease.
Sign Up for FreeAlready have an account Log In.
Please stop one of the following coding sessions, or upgrade your account.
NAME | ORGANIZATION |
---|
QuantConnect Datasets
Explore free and paid datasets available on QuantConnect covering fundamentals, pricing, and alternative options.
Datasets >
Dashboard
A transparent, community reporting system. Report suspected issues with our cloud data to be investigated by the QuantConnect Team.
Issue List
Loading...
Data Explorer Issues are a way to report and track data problems. They give the QuantConnect community a way to discuss potential solutions and be notified when they are resolved. If you think you have found a data problem please check the existing open and closed issues first; often another user may have already reported your problem.
Does your issue match any of the already listed issues?
Thank you for your contribution! Our team is currently working on resolving these issues, please subscribe to them to receive updates.
Datasets >
US Future Universe
Dataset by QuantConnect
The US Future Universe dataset by QuantConnect lists the available US Future contracts, their daily trading volume, and Open Interest. The data covers the 162 most liquid contracts, starts in May 2009, and is delivered on daily frequency. This dataset is created by monitoring the trading activity on the CFE, CBOT, CME, COMEX, NYMEX, and ICE*.
This dataset depends on the US Futures Security Master dataset because the US Futures Security Master dataset contains information on symbol changes of the contracts.
This dataset does not contain market data. For market data, see US Futures by AlgoSeek.
QuantConnect was founded in 2012 to serve quants everywhere with the best possible algorithmic trading technology. Seeking to disrupt a notoriously closed-source industry, QuantConnect takes a radically open-source approach to algorithmic trading. Through the QuantConnect web platform, more than 50,000 quants are served every month.
The following snippet demonstrates how to request data from the US Future Universe dataset:
future = self.add_future(Futures.Metals.GOLD)
future.set_filter(0, 90)
var future = AddFuture(Futures.Metals.Gold);
future.SetFilter(0, 90);
The following table describes the dataset properties:
Property | Value |
---|---|
Start Date | May 2009 |
Asset Coverage | 162 Futures |
Data Density | Dense |
Resolution | Daily |
Timezone |
|
Market Hours | Regular and Extended |
The US Future Universe dataset enables you to accurately design Futures strategies. Examples include the following strategies:
For more example algorithms, see Examples.
The US Future Universe dataset provides FutureFilterUniverse and FuturesChain objects.
FutureFilterUniverse objects have the following attributes:
FuturesChain objects have the following attributes:
The following list shows the available (162) Futures:
To add US Future Universe data to your algorithm, call the AddFutureadd_future method. Save a reference to the Future object so you can access the data later in your algorithm. To define which contracts should be in your universe, specify the filter when requesting the Future data.
The AddFutureadd_future method provides a daily stream of Future chain data. To get the most recent daily chain, call the FuturesChainfutures_chain method with the underlying Future Symbol. The FuturesChainfutures_chain method returns data on all the tradable contracts, not just the contracts that pass your universe filter.
class USFutureDataAlgorithm(QCAlgorithm):
def initialize(self) -> None:
self.set_start_date(2020, 6, 1)
self.set_end_date(2021, 6, 1)
self.set_cash(100000)
self.universe_settings.asynchronous = True
self._future = self.add_future(Futures.Metals.GOLD)
# Set our contract filter for this Future chain.
self._future.set_filter(lambda universe: universe.standards_only().front_month())
# Get the entire Futures chain for the current day.
chain = self.futures_chain(self._future.symbol, flatten=True).data_frame
public class USFutureDataAlgorithm : QCAlgorithm
{
private Future _future;
public override void Initialize()
{
SetStartDate(2020, 6, 1);
SetEndDate(2021, 6, 1);
SetCash(100000);
UniverseSettings.Asynchronous = true;
_future = AddFuture(Futures.Metals.Gold);
// Set our contract filter for this Future chain.
_future.SetFilter((universe) => universe.StandardsOnly().FrontMonth());
// Get the entire Futures chain for the current day.
var chain = FuturesChain(_future.Symbol);
}
}
For more information about creating US Future universes, see Futures.
You can get historical US Future Universe data in an algorithm and the Research Environment.
To get historical US Future Universe data in an algorithm, call the Historyhistory method with the list Future contract Symbol objects. You may obtain all available Future contracts on a date by calling the FuturesChainfutures_chain method. Note that this method will return all available contracts despite your previous filter. If there is no data for the period you requested, the history result is empty.
# Subscribe to the underlying Future and save a reference to the Symbol.
symbol = self.add_future(Futures.Metals.GOLD).symbol
# Get the contracts available on this day.
contracts = [x.symbol for x in self.futures_chain(symbol)]
# Request the historical data to obtain the data.
# DataFrame objects
history_df = self.history(contracts, 10, Resolution.DAILY, flatten=True)
open_interest = self.history(OpenInterest, contracts, 10, Resolution.DAILY, flatten=True)
# Open Interest objects
open_interest = self.history[OpenInterest](contracts, 10, Resolution.DAILY)
// Subscribe to the underlying Future and save a reference to the Symbol.
var symbol = AddFuture(Futures.Metals.Gold).Symbol
// Get the contracts available on this day.
var contracts = contracts = FuturesChain(symbol).Select(x => x.Symbol).ToList();
// Request the historical data to obtain the data.
// Slice objects
var history = History(contracts, 10, Resolution.Daily);
// Open Interest objects
var openInterest = History<OpenInterest>(contracts, 10, Resolution.Daily);
For more information about historical US Future Universe data in algorithms, see History Requests.
To get historical US Future Universe data in the Research Environment for an entire Futures chain, call the FutureHistoryfuture_history method with the continuous Future Symbol.
qb = QuantBook()
future = qb.add_future(Futures.Metals.GOLD)
future.set_filter(0, 90)
history = qb.future_history(future.symbol, datetime(2020, 6, 1), datetime(2020, 6, 5), Resolution.DAILY)
history_df = history.data_frame
expiries = history.get_expiry_dates()
var qb = new QuantBook();
var future = qb.AddFuture(Futures.Metals.Gold);
future.SetFilter(0, 90);
var history = qb.FutureHistory(future.Symbol, new DateTime(2020, 6, 1), new DateTime(2020, 6, 5));
You can also do similar in the research environment like in the algorithm to obtain the price and open interest data.
qb = QuantBook()
end = datetime(2020, 6, 5)
qb.set_start_date(end)
symbol = qb.add_future(Futures.Metals.GOLD).symbol
# Get the contracts available on this day.
contracts = [x.symbol for x in qb.futures_chain(symbol)]
# Request the historical data to obtain the data.
history_df = qb.history(contracts, datetime(2020, 6, 1), end, Resolution.DAILY, flatten=True)
open_interest = qb.history(OpenInterest, contracts, datetime(2020, 6, 1), end, Resolution.DAILY, flatten=True)
var qb = new QuantBook();
var end = new DateTime(2020, 6, 5);
qb.SetStartDate(end)
var future = qb.AddFuture(Futures.Metals.Gold);
// Get the contracts available on the day.
var contracts = qb.FuturesChain(future.Symbol).Select(x => x.Symbol);
// Request the historical data to obtain the data.
var history = qb.History(contracts, new DateTime(2020, 6, 1), end, Resolution.Daily);
var openInterest = qb.History<OpenInterest>(contracts, new DateTime(2020, 6, 1), end, Resolution.Daily);
The US Future Universe dataset provides FutureFilterUniverse and FuturesChain objects.
FutureFilterUniverse objects have the following attributes:
FuturesChain objects have the following attributes:
The following example algorithm selects and buys the front-month Mini Gold Futures contract and sells the front-month Micro Gold Futures contract. When the front-month contract changes, the algorithm rebalances the portfolio.
class USFuturesDataAlgorithm(QCAlgorithm):
def initialize(self) -> None:
self.set_start_date(2013, 12, 20)
self.set_end_date(2014, 2, 20)
self.set_cash(1000000)
self.universe_settings.asynchronous = True
# Requesting data on gold and micro-gold contracts.
# Filter the universe to trade only the contracts expiring within 90 days to ensure liquidity.
self.mini_gold = self.add_future(Futures.Metals.GOLD)
self.mini_gold.set_filter(0, 90)
self.micro_gold = self.add_future(Futures.Metals.MICRO_GOLD)
self.micro_gold.set_filter(0, 90)
# Save a cache of the mapped symbol to trade.
self.contract = {self.mini_gold.symbol: None, self.micro_gold.symbol: None}
def on_data(self, slice: Slice) -> None:
for symbol, chain in slice.future_chains.items():
if symbol in self.contract:
# Select the contract with the greatest open interest to trade with the most efficiency.
most_liquid_contract = sorted(chain, key=lambda contract: contract.open_interest, reverse=True)[0]
if self.contract[symbol] is None or most_liquid_contract.symbol != self.contract[symbol].symbol:
# Liquidate any unmapped contracts.
if self.contract[symbol] is not None:
self.liquidate(self.contract[symbol].symbol)
self.contract[symbol] = most_liquid_contract
# Buy mini-gold and short micro-gold contracts as planned.
if symbol == self.mini_gold.symbol:
self.market_order(self.contract[symbol].symbol, 1)
elif symbol == self.micro_gold.symbol:
self.market_order(self.contract[symbol].symbol, -1)
namespace QuantConnect.Algorithm.CSharp
{
public class USFuturesDataAlgorithm : QCAlgorithm
{
private Future _miniGold;
private Future _microGold;
// Save a cache of the mapped symbol to trade.
private Dictionary<Symbol, FuturesContract?> _contract = new ();
public override void Initialize()
{
SetStartDate(2013, 12, 20);
SetEndDate(2014, 2, 20);
SetCash(1000000);
UniverseSettings.Asynchronous = true;
// Requesting data on gold and micro-gold contracts.
// Filter the universe to trade only the contracts expiring within 90 days to ensure liquidity.
_miniGold = AddFuture(Futures.Metals.Gold);
_miniGold.SetFilter(0, 90);
_contract.Add(_miniGold.Symbol, null);
_microGold = AddFuture(Futures.Metals.MicroGold);
_microGold.SetFilter(0, 90);
_contract.Add(_microGold.Symbol, null);
}
public override void OnData(Slice slice)
{
foreach (var (symbol, chain) in slice.FutureChains)
{
if (_contract.ContainsKey(symbol))
{
// Select the contract with the greatest open interest to trade with the most efficiency.
var mostLiquidContract = chain.OrderBy(x => x.OpenInterest).Last();
if (_contract[symbol] == null || mostLiquidContract.Symbol != _contract[symbol].Symbol)
{
// Liquidate any unmapped contracts.
if (_contract[symbol] != null)
{
Liquidate(_contract[symbol].Symbol);
}
_contract[symbol] = mostLiquidContract;
// Buy mini-gold and short micro-gold contracts as planned.
if (symbol == _miniGold.Symbol)
{
MarketOrder(_contract[symbol].Symbol, 1);
}
else if (symbol == _microGold.Symbol)
{
MarketOrder(_contract[symbol].Symbol, -1);
}
}
}
}
}
}
}
The following example algorithm selects and buys the front-month Mini Gold Futures contract and sells the front-month Micro Gold Futures contract. When the front-month contract changes, the algorithm rebalances the portfolio.
from AlgorithmImports import *
from QuantConnect.DataSource import *
from Selection.FutureUniverseSelectionModel import FutureUniverseSelectionModel
class USFuturesDataAlgorithm(QCAlgorithm):
def initialize(self) -> None:
self.set_start_date(2013, 12, 20)
self.set_end_date(2014, 2, 20)
self.set_cash(100000)
self.universe_settings.asynchronous = True
# Set up an universe selection model that selects the front month contract
self.set_universe_selection(FrontMonthFutureUniverseSelectionModel())
self.add_alpha(ConstantFuturesAlphaModel())
# A portfolio construction model that only order a single share per insight signal
self.set_portfolio_construction(SingleSharePortfolioConstructionModel())
class FrontMonthFutureUniverseSelectionModel(FutureUniverseSelectionModel):
def __init__(self,) -> None:
# Daily updating with select_future_chain_symbols function
super().__init__(timedelta(1), self.select_future_chain_symbols)
def select_future_chain_symbols(self, utcTime: datetime) -> List[Symbol]:
# Select gold and micro gold contracts for the strategy need
future_pairs = [
(Futures.Metals.GOLD, Market.COMEX),
(Futures.Metals.MICRO_GOLD, Market.COMEX)
]
return [Symbol.create(pair[0], SecurityType.FUTURE, pair[1]) for pair in future_pairs]
def filter(self, filter: FutureFilterUniverse) -> FutureFilterUniverse:
# Filter only front month contract for liquidity and most informed information
return filter.front_month().only_apply_filter_at_market_open()
class ConstantFuturesAlphaModel(AlphaModel):
# Long gold and short micro gold in this strategy
long_symbol = Symbol.create(Futures.Metals.GOLD, SecurityType.FUTURE, Market.COMEX)
short_symbol = Symbol.create(Futures.Metals.MICRO_GOLD, SecurityType.FUTURE, Market.COMEX)
def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
if algorithm.portfolio.invested:
return []
insights = []
# For both gold and micro gold, select the front month contract (only contract) in the chain
for kvp in slice.future_chains:
chain = [contract for contract in kvp.Value]
contract = chain[0]
# Long gold and short micro gold as planned
if kvp.Key == self.long_symbol:
insights.append(Insight.price(contract.symbol, contract.expiry + timedelta(days=1), InsightDirection.UP))
elif kvp.Key == self.short_symbol:
insights.append(Insight.price(contract.symbol, contract.expiry + timedelta(days=1), InsightDirection.DOWN))
return insights
def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
for security in changes.added_securities:
# Historical data
history = algorithm.history(security.symbol, 10, Resolution.MINUTE)
algorithm.debug(f"We got {len(history)} from our history request for {security.symbol}")
class SingleSharePortfolioConstructionModel(PortfolioConstructionModel):
def create_targets(self, algorithm: QCAlgorithm, insights: List[Insight]) -> List[PortfolioTarget]:
targets = []
for insight in insights:
if algorithm.securities[insight.symbol].is_tradable:
# Single share only using integer portfolio target
targets.append(PortfolioTarget(insight.symbol, insight.direction))
return targets
using QuantConnect.DataSource;
namespace QuantConnect
{
public class USFuturesDataAlgorithm : QCAlgorithm
{
public override void Initialize()
{
SetStartDate(2013, 12, 20);
SetEndDate(2014, 2, 20);
SetCash(1000000);
UniverseSettings.Asynchronous = true;
// Set up an universe selection model that selects the front month contract
SetUniverseSelection(new FrontMonthFutureUniverseSelectionModel());
SetAlpha(new ConstantFuturesAlphaModel());
// A portfolio construction model that only order a single share per insight signal
SetPortfolioConstruction(new SingleSharePortfolioConstructionModel());
}
}
class FrontMonthFutureUniverseSelectionModel : FutureUniverseSelectionModel
{
// Daily updating with select_future_chain_symbols function
public FrontMonthFutureUniverseSelectionModel()
: base(TimeSpan.FromDays(1), SelectFutureChainSymbols) {}
private static IEnumerable<Symbol> SelectFutureChainSymbols(DateTime utcTime)
{
//Select gold and micro gold contracts for the strategy need
return new List<Symbol> {
QuantConnect.Symbol.Create(Futures.Metals.Gold, SecurityType.Future, Market.COMEX),
QuantConnect.Symbol.Create(Futures.Metals.MicroGold, SecurityType.Future, Market.COMEX)
};
}
protected override FutureFilterUniverse Filter(FutureFilterUniverse filter)
{
// Filter only front month contract for liquidity and most informed information
return filter.FrontMonth().OnlyApplyFilterAtMarketOpen();
}
}
class ConstantFuturesAlphaModel : AlphaModel
{
// Long gold and short micro gold in this strategy
private Symbol
_longSymbol = QuantConnect.Symbol.Create(Futures.Metals.Gold, SecurityType.Future, Market.COMEX),
_shortSymbol = QuantConnect.Symbol.Create(Futures.Metals.MicroGold, SecurityType.Future, Market.COMEX);
public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
{
var insights = new List<Insight>();
if (algorithm.Portfolio.Invested)
{
return insights;
}
// For both gold and micro gold, select the front month contract (only contract) in the chain
foreach (var kvp in slice.FutureChains)
{
var symbol = kvp.Key;
var chain = kvp.Value;
var contract = chain.First();
// Long gold and short micro gold as planned
if (symbol == _longSymbol)
{
insights.Add(Insight.Price(contract.Symbol, contract.Expiry + TimeSpan.FromDays(1), InsightDirection.Up));
}
else if (symbol == _shortSymbol)
{
insights.Add(Insight.Price(contract.Symbol, contract.Expiry + TimeSpan.FromDays(1), InsightDirection.Down));
}
}
return insights;
}
public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
{
foreach (var security in changes.AddedSecurities)
{
// Historical data
var history = algorithm.History(security.Symbol, 100, Resolution.Minute);
algorithm.Debug($"We got {history.Count()} from our history request for {security.Symbol}");
}
}
}
class SingleSharePortfolioConstructionModel : PortfolioConstructionModel
{
public override IEnumerable<PortfolioTarget> CreateTargets(QCAlgorithm algorithm, Insight[] insights)
{
var targets = new List<PortfolioTarget>();
foreach (var insight in insights)
{
if (algorithm.Securities[insight.Symbol].IsTradable)
{
// Single share only using integer portfolio target
targets.Add(new PortfolioTarget(insight.Symbol, (int) insight.Direction));
}
}
return targets;
}
}
}
US Future Universe is allowed to be used in the cloud for personal and commercial projects for free. The data is permissioned for use within the licensed organization only
Free | Documentation
US Future Universe can be downloaded on premise with the LEAN CLI, for a charge per file downloaded. This download is for the licensed organization's internal LEAN use only and cannot be redistributed or converted in any format.
Starting at 100 QCC/file | Learn More
LEAN CLI is a cross-platform wrapper on the QuantConnect algorithmic trading engine called LEAN. The CLI makes using LEAN incredibly easy, reducing most of the pain points of developing and managing an algorithmic trading strategy to a few lines of bash.
Using the CLI you can download the same data QuantConnect hosts in the cloud for a small fee. These fees are per file downloaded, and are paid for in QuantConnect-Credits (QCC). We recommend purchasing credits to enable downloading.
The CLI command generator is a helpful tool to generate a copy-paste command to download this dataset from the form below.
lean data download \
--dataset "US Future Universe" \
--data-type "universe" \
--ticker "ES, GC" \
--market "cme" \
--start "20240330" \
--end "20250330"
lean data download `
--dataset "US Future Universe" `
--data-type "universe" `
--ticker "ES, GC" `
--market "cme" `
--start "20240330" `
--end "20250330"
Free access for US Future universe selection on the QuantConnect Cloud. Create custom filters using expiration dates, and open interest for the US Futures.
On premise download of US Future universe data files, including price, expiration dates, and open interest for local backtesting.
Bulk download of the entire US Future Universe dataset
Bulk download of the entire US Future Universe dataset
What people are saying about this
This product has not received any reviews yet, be the first to post one!
Rate the Module:
Provider offers 4 licensing options
Explore free and paid datasets available on QuantConnect covering fundamentals, pricing, and alternative options.
Dataset Status from to
No Runs
OK
Degraded
Failure
Explore free and paid datasets available on QuantConnect covering fundamentals, pricing, and alternative options.
Lorem ipsum dolor sit amet conjectura lorem ipsum dolor sit amet conjectura lorem ipsum
Configuration Keys
Environment Variables
Lorem ipsum dolor sit amet conjectura lorem ipsum dolor sit amet conjectura lorem ipsum
File Link
Lorem ipsum dolor sit amet conjectura lorem ipsum dolor sit amet conjectura lorem ipsum
Lorem ipsum dolor sit amet conjectura lorem ipsum dolor sit amet conjectura lorem ipsum
Upload a manually created tar or zip file to all cloud data systems.
Add a link and click the Sync Dataset button to upload the dataset
Upload Destinations
The dataset synchronizer is an internal tool for the QuantConnect team to upload data to the
cloud data storage environments. It supports TAR files which are extracted in the root directory
of the cloud data environments.
Take extreme care to carefully structure your data TAR package with
the same folders as the LEAN data folder. Ensure all folders and file names are lowercase as Linux is case-sensitive.
Support
Algorithm Lab is your playground for developing and refining trading algorithms with QuantConnect. Utilize advanced tools, historical data, and robust backtesting to enhance your trading strategies. Transform your ideas into actionable insights and optimize your trading approach with ease.
Sign Up for FreeAlready have an account Log In.
â‘
â‘
â‘
â‘
â‘
Hover and click over the stars to rate us.
It looks like you are not fully satisfied with your experience on QuantConnect, please take a moment to let us know how we can improve our services for you:
If you have a minute to spare, please leave us a review on Trustpilot.
Stories like yours help others see the full potential of QuantConnect.
Organization Name |
---|
Upgrade to Team plan or higher to enable custom invoicing
Changes will be applied to future invoices.
Users will be able to join by following the link in the invitation email.
You’ve been invited by Jared Broad to join his G-Force Organization.
Would you like to accept the invitation?
Are you sure you want to delete the encryption key "undefined"?
Caution: We will not be able to decrypt encrypted projects without the original key.
Drag & Drop or
Keys are added to the local storage in your web browser and not uploaded to QuantConnect. To use an encrypted project on another computer you will need to bring a copy of the key.
This project is encrypted using the key .
This project will be encrypted using the key .