Python backtesting libraries compared on one strategy

Short answer: Backtesting in Python is either vectorized, computing whole pandas or NumPy columns at once, or event-driven, feeding bars one at a time to logic that behaves like a live system. The main free libraries, backtesting.py, backtrader, vectorbt, zipline-reloaded and bt, differ in license, maintenance, portfolio support and cost modeling. None is best for every case: choose by those criteria, verify against plain pandas and test out of sample; a backtest does not guarantee future results.

Measure the drawdown of an equity series in your browser: Max drawdown calculator.

Which Python backtesting library fits depends on what you trade, how you plan to go live and which license your product can accept. This guide compares five libraries from their documentation, PyPI and GitHub pages as of 25 October 2026, then runs one strategy in plain pandas and in four of them on synthetic data, with walk-forward and Monte Carlo checks. zipline-reloaded was compared from its documentation only and was not run.

Why backtests flatter strategies is covered in backtesting pitfalls; this guide is about tools.

Vectorized vs event-driven backtesting in Python

A vectorized backtest computes signals and returns for the whole history with array operations; an event-driven backtest feeds bars one at a time to strategy code that reacts as a live system would.

Backtesting Python libraries compared (October 2026)

The five libraries differ less in what they can simulate than in license, maintenance and portfolio support.

Release dates are PyPI upload dates; maintenance signals come from GitHub. Recheck both before committing. Activity signals upkeep, not quality.

Licenses: AGPL, GPL and Commons Clause in practice

For a commercial product, license terms can decide before features do.

• AGPL-3.0 (backtesting.py). Section 13: if you modify it and users interact with it remotely, your version must offer them its source code.
• GPL-3.0 (backtrader). Distributing modified versions or software built on it brings source-sharing obligations.
• Apache 2.0 with Commons Clause (vectorbt). Source-available ("fair-code"), not OSI open source: free to use, but no right to sell a product or service whose value derives entirely or substantially from it, including paid hosting, consulting or support for it.
• MIT (bt) and Apache-2.0 (zipline-reloaded). Permissive, with notice requirements.

Internal research rarely triggers these clauses; a hosted product or client deliverable can. This is not legal advice.

backtesting.py vs backtrader: how to choose a framework

Neither is better in general; decide by these criteria, then test the candidate on a strategy you can verify.

1. Asset scope. One instrument per run (backtesting.py) or several feeds and timeframes together (backtrader, zipline-reloaded, bt, vectorbt columns).
2. Order realism. backtrader lists market, limit, stop, stop-limit, trailing, OCO and bracket orders; the free vectorbt leaves limit orders to VectorBT PRO, a separate membership product.
3. Speed. Large parameter sweeps favor vectorized tools; measure on your own data.
4. Path to live trading. backtrader documents live connections to Interactive Brokers, Oanda v1 and VisualChart, plus third-party ones such as ccxt; otherwise live orders need a separate engine, such as a CCXT Python bot.
5. Units and markets. backtesting.py trades whole units unless you use FractionalBacktest, which matters for crypto; zipline-reloaded uses an exchange trading calendar, NYSE by default.
6. Maintenance and license, as in the table above.

Crypto backtesting in Python: what changes

Crypto backtesting in Python uses the same libraries, but five market details need explicit handling, or the results flatter the strategy.

• 24/7 sessions. Annualized statistics depend on the assumed day count. backtesting.py's statistics code, read on 4 November 2026, uses 365 days when enough of the index falls on weekends and 252 otherwise. Check what your tool assumes.
• Funding. Perpetual futures positions pay or receive funding at set intervals. Model it as a separate cash flow; a commission setting does not capture it.
• Delisted pairs. A universe built from today's symbol list leaves out pairs removed since, which is survivorship bias. Build the list as of each test date.
• Candle gaps. Periods without trades, outages and maintenance can leave missing candles. Check for missing timestamps, because forward-filling silently invents prices you could not have traded.
• Fee tiers. Fees vary with volume tier, maker or taker status and discounts. Test with the rate your account actually pays, and with the taker rate when orders cross the spread.

Crypto backtesting data, software and GitHub projects

Data usually starts with candles from an exchange's API or public files, as covered in crypto price APIs. On GitHub, some crypto bots include a built-in tester. Freqtrade's documentation, read on 4 November 2026, says it uses the exchange's default fees and assumes orders fill at the requested price, with no slippage, while the price is within the candle's range. Read such assumptions in any tool before trusting its figures; a backtest does not guarantee future results.

The same strategy in plain pandas and four libraries

Before trusting a library, reproduce one simple strategy in plain pandas and compare the trades.

The strategy is long while a 10-day simple moving average is above a 30-day one, filling at the next open with 0.1% commission per side, on 2,000 synthetic daily bars (run on 5 November 2026 with Python 3.11, pandas 3.1.1, NumPy 2.4.6 and backtesting.py 0.6.6):

import numpy as np
import pandas as pd

rng = np.random.default_rng(7)                       # synthetic, hypothetical prices
n = 2000
close = 100 * np.exp(np.cumsum(rng.normal(0.0002, 0.012, n)))
open_ = np.r_[100, close[:-1]] * np.exp(rng.normal(0, 0.002, n))
high = np.maximum(open_, close) * (1 + rng.uniform(0, 0.006, n))
low = np.minimum(open_, close) * (1 - rng.uniform(0, 0.006, n))
df = pd.DataFrame({"Open": open_, "High": high, "Low": low, "Close": close},
                  index=pd.date_range("2019-01-01", periods=n, freq="D"))

def bar_returns(df, fast, slow, fee=0.001):
    """Long-only SMA cross: signal at the close, fill at the next open, fee per side."""
    f, s = df.Close.rolling(fast).mean(), df.Close.rolling(slow).mean()
    pos = (f > s).astype(int).shift(1).fillna(0)
    r = (df.Open.shift(-1) / df.Open - 1).fillna(0)
    return (1 + pos * r) * (1 - fee) ** pos.diff().abs().fillna(0) - 1, pos

ret, pos = bar_returns(df, 10, 30)
print("trades:", int((pos.diff() == 1).sum()), "ending equity:", round((1 + ret).prod(), 4))

trades: 38 ending equity: 0.729

The same rules in backtesting.py, continuing with df:

from backtesting import Backtest, Strategy
from backtesting.lib import crossover

def SMA(values, n):
    return pd.Series(values).rolling(n).mean()

class SmaCross(Strategy):
    fast, slow = 10, 30
    def init(self):
        self.f = self.I(SMA, self.data.Close, self.fast)
        self.s = self.I(SMA, self.data.Close, self.slow)
    def next(self):
        if crossover(self.f, self.s):
            self.buy()                    # market order: fills at the next open
        elif crossover(self.s, self.f):
            self.position.close()

stats = Backtest(df, SmaCross, cash=1_000_000, commission=0.001,
                 finalize_trades=True).run()
print("trades:", stats["# Trades"], "ending equity:", round(stats["Equity Final [$]"] / 1e6, 4))

trades: 38 ending equity: 0.7283

Both make the same 38 entries, and the 37 closed trades exit, at identical prices. The small equity gap comes mainly from the last trade, which backtesting.py closes on the final bar with exit commission (finalize_trades=True) while pandas leaves it open; whole-unit sizing adds a little. A different trade count would point to a fill-timing or warm-up difference to fix first. The strategy lost about 27% on random-walk synthetic data.

The same rule, data and costs in three more libraries, run on the same day, make the same trades:

All 38 entry dates and all 37 closed-trade exit dates match plain pandas in each library, so the gaps in ending equity come from where the last open position is marked, plus the exit commission and whole units in backtesting.py. In backtrader, sizing all in without the 0.01% cash reserve had all 38 orders rejected as margin, leaving ending equity at 1.0, a silent failure that this kind of comparison catches. zipline-reloaded was not run, so its row in the table above rests on documentation only.

Walk-forward analysis in Python

Walk-forward analysis picks parameters on a past window, applies them unchanged to the next window and reports only those out-of-sample results.

from itertools import product

grid = list(product((5, 10, 20), (30, 50, 100)))      # (fast, slow)
curves = {p: bar_returns(df, *p)[0] for p in grid}   # indicators use past data only
growth = lambda r: float((1 + r).prod())

train, test, oos = 500, 250, []
for start in range(0, n - train - test + 1, test):
    fit = slice(start, start + train)
    best = max(grid, key=lambda p: growth(curves[p].iloc[fit]))   # chosen on the past
    oos.append(curves[best].iloc[start + train:start + train + test])
    print(df.index[start + train].date(), best, round(growth(oos[-1]), 3))

period = slice(train, train + len(pd.concat(oos)))
hindsight = max(grid, key=lambda p: growth(curves[p].iloc[period]))
print("walk-forward:", round(growth(pd.concat(oos)), 3),
      "| hindsight best", hindsight, round(growth(curves[hindsight].iloc[period]), 3))

2020-05-15 (20, 100) 1.03
2021-01-20 (20, 100) 1.128
2021-09-27 (5, 50) 0.891
2022-06-04 (5, 50) 0.974
2023-02-09 (5, 50) 1.031
2023-10-17 (20, 100) 0.959
walk-forward: 0.997 | hindsight best (5, 50) 1.211

Each fold optimizes nine SMA pairs on 500 bars and trades the winner for the next 250. The six stitched out-of-sample periods end at 0.997, roughly flat, while the best pair in hindsight over the same 1,500 bars shows +21%. That gap is selection bias: an optimizer reports the hindsight number, while walk-forward measures the selection procedure honestly. Computing indicators on the full series is safe here only because rolling means use past bars; fitted models or scalers must be refitted inside each training window. Walk-forward testing across many symbols is part of the BIST strategy backtesting platform scenario.

Monte Carlo backtesting in Python: resampling trades

Monte Carlo resampling draws many alternative sequences from the strategy's own trades to show the range of outcomes and drawdowns they could produce.

r = stats["_trades"]["ReturnPct"].to_numpy()          # 38 net trade returns
rng = np.random.default_rng(1)
paths = 1 + rng.choice(r, size=(10_000, r.size), replace=True)   # bootstrap
equity = np.cumprod(paths, axis=1)
peak = np.maximum.accumulate(np.hstack([np.ones((10_000, 1)), equity]), axis=1)[:, 1:]
max_dd = (1 - equity / peak).max(axis=1)
print("final equity 5/50/95%:", np.percentile(equity[:, -1], [5, 50, 95]).round(3))
print("max drawdown 5/50/95%:", np.percentile(max_dd, [5, 50, 95]).round(3))
print("paths ending above 1:", (equity[:, -1] > 1).mean().round(3))

final equity 5/50/95%: [0.404 0.717 1.409]
max drawdown 5/50/95%: [0.223 0.418 0.623]
paths ending above 1: 0.2

Bootstrapping assumes independent trades; if results cluster, resample blocks of consecutive trades or returns.

Libraries reproduce rules; they cannot tell you whether the rules will make money, backtests do not guarantee future results, and automated trading can lose money. Strategies ported from TradingView need the checks in the TradingView Strategy Tester guide and Pine Script to Python. Test software built from rules the customer wrote is part of the custom trading bot development service.

Frequently asked questions

What is the best Python library for backtesting?

None is best for every case. Choose by asset scope, order realism, speed, license, maintenance and path to live trading.

Is backtesting.py free for commercial use?

It is AGPL-3.0: if you modify it and offer it to users over a network, you must give them your modified source. Have the terms reviewed for a commercial product.

Is backtrader still maintained?

Its last PyPI release, 1.9.78.123, and last master-branch commit date from 19 April 2023 (checked 25 October 2026); the repository is not archived.

How do I do walk-forward analysis in Python?

Optimize parameters on a rolling past window, trade them unchanged on the next one, and report only the stitched out-of-sample periods.

Does a Monte Carlo test prove a strategy works?

No. It shows the range of results the observed trades could produce in another order or mix, but it cannot add an edge the trades lack.

What is different about crypto backtesting?

Markets run around the clock, perpetual futures add funding, delisted pairs vanish from current symbol lists, thin pairs leave candle gaps and fees depend on your tier.

Sources

• backtesting.py API reference: Backtest (parameters, fills, commission, optimize) (opens in a new tab)
• backtesting.py API reference: lib (MultiBacktest, FractionalBacktest, SignalStrategy) (opens in a new tab)
• backtesting.py on GitHub: LICENSE (GNU AGPL-3.0, section 13) (opens in a new tab)
• PyPI: backtesting (release 0.6.6) (opens in a new tab)
• backtrader documentation: Features (opens in a new tab)
• backtrader on GitHub (GPL-3.0, commit history, version 1.9.78.123 commit of 19 April 2023) (opens in a new tab)
• vectorbt on GitHub (README, PRO features, Apache 2.0 with Commons Clause) (opens in a new tab)
• vectorbt API reference: Portfolio (fees, slippage, cash sharing) (opens in a new tab)
• PyPI: vectorbt (release 1.2.0) (opens in a new tab)
• zipline-reloaded on GitHub (README, maintenance status) (opens in a new tab)
• Zipline Reloaded documentation: Beginner tutorial (events, bundles, calendars, costs) (opens in a new tab)
• PyPI: zipline-reloaded (release 3.2.0) (opens in a new tab)
• bt on GitHub (README, MIT license) (opens in a new tab)
• backtesting.py source: _stats.py (annual trading days) (opens in a new tab)
• Freqtrade documentation: Backtesting (fees and assumptions) (opens in a new tab)

This guide is general information about software and markets, not investment, legal or tax advice. Automated trading can lose money, past or backtested performance does not guarantee future results, and the rules that apply depend on your jurisdiction and your exchange's terms. Sources, checks and corrections: see the editorial policy.