software for
data-driven traders

JupyterLab screenshot
Research and trade
quantitative strategies
in global markets
using Python

feature icon Choose Your Backtester

One size does NOT fit all

The backtesting or analysis library that's right for you depends on the style of your trading strategies. End of day or intraday? 8 symbols, or 8000? Event-driven or factor-based? QuantRocket supports multiple open-source Python backtesting and analysis libraries. Or, plug in your own custom scripts and tools thanks to QuantRocket's modular, microservice architecture.

The popular backtester that originally powered Quantopian

Key features:

  • The world's best-known backtester, with over a decade of real-world use
  • Maintained, modernized, and continuously enhanced by QuantRocket
  • Support for equities and futures
  • 1-minute US stock data included
  • Live trading (automated or manual)
  • Pairs with Pyfolio, an open-source performance analysis library
Pyfolio Tear Sheet
import zipline.api as algo

def initialize(context: algo.Context):

    context.assets_to_buy = []

    # Rebalance every day, 30 minutes before market close.

def rebalance(context: algo.Context, data: algo.BarData):

    positions = context.portfolio.positions

    # Exit positions we no longer want to hold
    for asset, position in positions.items():
        if asset not in context.assets_to_buy:
            algo.order_target_value(asset, 0, style=MarketOrder())


See Zipline code examples or read the Zipline docs

Screen and analyze large universes of securities with Pipeline

Key features:

  • Historical, point-in-time screening and ranking of securities using price and fundamental data
  • Define rules and perform computations that are too complex for point-and-click screening tools
  • Designed for large datasets that other code platforms struggle to handle
  • Can be paired with Zipline for backtesting, Alphalens for factor analysis, or used as a standalone tool
from zipline.pipeline import sharadar

# trailing-twelve month fundamentals
fundamentals = sharadar.Fundamentals.slice("ART")

# create a universe of the top 50% of stocks by market cap
# that also pay dividends
liquid_stocks = fundamentals.MARKETCAP.latest.percentile_between(50, 100)
pay_dividends = fundamentals.DIVYIELD.latest > 0
universe = liquid_stocks & pay_dividends

# Select the cheapest 100 stocks by enterprise multiple from among
# the universe of liquid, dividend-paying stocks  
enterprise_multiple = fundamentals.EVEBITDA.latest
stocks_to_buy = enterprise_multiple.bottom(100, mask=universe)

See Pipeline code examples or read the Pipeline docs

Quickly analyze the predictive value of alpha factors with Alphalens

Key features:

  • View the relative performance of baskets of stocks bucketed by alpha factor
  • Ideal for long-short or factor model strategies
  • Pairs well with the Pipeline API
  • Quickly assess whether an alpha factor is predictive
  • Use as an initial research step to determine if further investigation is warranted
Alphalens Tear Sheet

See Alphalens code examples or read the Alphalens docs

Moonshot is the backtester for data scientists

Key features:

  • Based on Pandas, the centerpiece of the Python data science stack
  • Fast, vectorized, multi-strategy backtests and parameter scans
  • Daily or intraday strategies
  • Equities, futures, and FX
  • Live trading (automated or manual)
  • Open source, designed by and for QuantRocket
  • Learn more about Moonshot in the Intro Video
import pandas as pd
from moonshot import Moonshot

class MovingAverageStrategy(Moonshot):

    CODE = "demo-50ma"
    DB = "demo-stk-1d"

    def prices_to_signals(self, prices: pd.DataFrame):
        # Buy when the close is above the 50-period moving average.
        closes = prices.loc["Close"]
        mavgs = closes.rolling(50).mean()
        signals = closes > mavgs.shift()
        return signals.astype(int)

See Moonshot code examples or read the Moonshot docs

First class support for machine learning strategies with MoonshotML

Key features:

  • Walk-forward optimization: Rolling and expanding walk-forward optimization, widely considered the best technique for validating machine learning models in finance.
  • Incremental/out-of-core learning: Train models and run backtests even when your data is too large to fit in memory.
  • Multiple machine learning/deep learning packages: Including scikit-learn, Keras + TensorFlow, and XGBoost.
import pandas as pd
from moonshot import MoonshotML

class DemoMLStrategy(MoonshotML):

    CODE = "demo-ml"
    DB = "demo-stk-1d"

    def prices_to_features(self, prices: pd.DataFrame):
        closes = prices.loc["Close"]
        features = {}
        # use past returns...
        features["returns_1d"]= closes.pct_change()
        # predict next day returns
        targets = closes.pct_change().shift(-1)
        return features, targets

    def predictions_to_signals(self, predictions: pd.DataFrame, prices: pd.DataFrame):
        # buy when the model predicts a positive return
        signals = predictions > 0
        return signals.astype(int)

See MoonshotML code examples or read the machine learning docs

Run custom scripts or connect third-party backtesters

A hint of what's possible:

  • Schedule daily downloads of third party data
  • Create an options trading script that uses QuantRocket's Python API to query data and place orders using the blotter
  • Create and schedule multi-step maintenance tasks such as creating futures calendar spreads based on changing rollover rules
  • Run third-party backtesters such as backtrader
import backtrader as bt

class DualMovingAverageStrategy(bt.SignalStrategy):

    params = (
        ('smavg_window', 100),
        ('lmavg_window', 300),

    def __init__(self):

        # Compute long and short moving averages
        smavg = bt.ind.SMA(period=self.p.smavg_window)
        lmavg = bt.ind.SMA(period=self.p.lmavg_window)

        # Go long when short moving average is above long moving average
        self.signal_add(bt.SIGNAL_LONG, bt.ind.CrossOver(smavg, lmavg))

See a complete example or read the custom scripts docs

Unrivaled Speed

QuantRocket backtests run up to 75x faster than QuantConnect for data-intensive strategies. See the full performance review.

feature icon Global Data Made Easy

Research without the wrangling

Most quants spend 80% of their time wrangling data and only 20% doing research.
QuantRocket puts a wealth of global market data at your fingertips so you can focus on analysis.

What will you ask the data?

>>> prices = get_prices('us-stk-1d').loc["Close"]
>>> sectors = get_securities_reindexed_like(prices, fields=["Sector"]).loc["Sector"]
>>> eps = get_sharadar_fundamentals_reindexed_like(prices, fields=["EPS"]).loc["EPS"]
>>> eps.groupby(sectors).mean()
>>> prices = get_prices("us-stk-1d").loc["Close"]
>>> borrow_fees = get_ibkr_borrow_fees_reindexed_like(prices)
>>> borrow_fees.where(prices < 1).rank(axis=1)
>>> at_close = prices.xs("16:00:00", level="Time")
>>> near_close = prices.xs("15:30:00", level="Time")
>>> is_up_for_session = (near_close - at_close.shift()) / at_close.shift()
>>> last_half_hour_returns = (at_close - near_close) / near_close
>>> last_half_hour_returns.where(is_up_for_session)
>>> cl_prices = get_prices("cl-fut-1min", times="14:00:00").loc["Close"]
>>> gold_prices = get_prices("us-stk-1d", sids="FIBBG000CRF6Q8").loc["Close"]
>>> contract_nums = get_contract_nums_reindexed_like(cl_prices, limit=2)
>>> month_1_prices = cl_prices.where(contract_nums==1).mean(axis=1)
>>> month_2_prices = cl_prices.where(contract_nums==2).mean(axis=1)
>>> cl_in_contango = month_2_prices > month_1_prices
>>> gold_prices.where(cl_in_contango)

Find your data in the Data Library

feature icon Deploy With Ease

Run anywhere

Linux, Mac, or Windows. In the cloud or on your laptop. QuantRocket runs anywhere Docker runs.

Connect from anywhere

Control your cloud-based deployment securely from any location using QuantRocket's JupyterLab web interface.

Flexible architecture

Use QuantRocket as a standalone end-to-end trading platform, or connect to it from other trading applications to query data, submit orders, or use other components you need.

Your servers, your way

Hosted platforms limit your compute resources and require uploading your secrets to third party servers. QuantRocket's ready-to-use trading infrastructure runs on your servers. Give your hardware as much power as you want, and keep your secrets safe.

Powered by Open Source...

QuantRocket's flexible, fault-tolerant, and performant stack is built on top of the best open source software available.

...with Tools You Know...


QuantRocket's home base is JupyterLab, the IDE of choice for data scientists. (VS Code is also supported.)

...and Attention to Detail

Comprehensive hover documentation with auto-complete is available for all of QuantRocket's APIs.


feature icon Live Trading

Multi-strategy, multi-account

Trade multiple strategies in multiple accounts, or even with multiple brokers, with different allocations for each. QuantRocket keeps it all straight.

Automated or semi-manual

Fully automate your strategies, or manually review the order file before placing it.

Built-in scheduler

Automate data collection and live trading using standard Unix cron.

Supported Brokers

Interactive Brokers

feature icon Real-time Data

Real-time market data, powered by your choice of provider.
An intuitive API with a flexible feature set, powered by QuantRocket.

feature icon Track Your Live Trading

Backtesting is only the first step. Once you go live, you need a clear picture of performance to assess whether live trading is mirroring your backtest.

feature icon Watch an Intro Video

See how to run an intraday momentum strategy using Moonshot, QuantRocket's pandas-based backtester, all the way from data collection to backtesting to live trading to performance tracking.

Find more example strategies in the Code Library