# VectorBT

Vectorised Python backtesting that has never heard of funding or liquidation.

*https://cryptomarkets.tools/tools/vectorbt · Backtesting & Research Libraries*

## Also covered on

- [VectorBT on StockMarketStack](https://stockmarketstack.com/tools/vectorbt.md) — the same engine judged on equities, where funding is not a cash flow it has to model

## Facts

### At a glance

| Field | Value |
| --- | --- |
| Vendor | VectorBT |
| Category | Backtesting & Research Libraries |
| Job | backtesting |
| Website | https://vectorbt.dev |
| Pricing model | free |
| Free tier | true |
| Open source | false |
| Licence | Apache-2.0 with Commons Clause |
| Self-hosted | true |
| KYC required | false |
| Tested hands-on | false |
| Last updated | 2026-09-19 |

### Pricing

| Tier | USD | Period |
| --- | --- | --- |
| Community edition | 0 USD | — |

### Coverage

| Field | Value |
| --- | --- |
| Asset classes | spot |
| Chains | none |
| Venues | cex |
| Data latency | none |
| Platforms | library |
| AI features | none |

### Interfaces

| Field | Value |
| --- | --- |
| API | false |
| Webhooks | false |
| Scripting | Python |
| MCP server | false |
| Export | none |

### Capabilities

Yes: charting, backtesting

No: screening, automation, live_trading, paper_trading, portfolio_tracking, exchange_import, tax_reporting, alerts, news, onchain_data, wallet_tracking, derivatives_analytics

*Verified: pricing 2026-09-19; capabilities 2026-09-19; coverage 2026-09-19.*

## What it is

A Python library that treats a backtest as array arithmetic rather than as a loop over bars.
Prices, signals and parameter grids are broadcast into NumPy arrays, the hot path is compiled by
Numba, and thousands of configurations are simulated in one call. The README's own example runs
10,000 dual-SMA window combinations across three pairs and plots the result as a heatmap; an
optional Rust engine installs as `vectorbt[rust]` for the paths where Numba's JIT overhead is the
cost.

That shape is the whole trade-off, and it is the one architectural choice on a backtester you do
not get to revise afterwards. A vectorised engine is fast because it computes over the entire
series at once, and for the same reason it struggles to express a rule that depends on what just
happened — a position size derived from the previous trade's result, or an exit conditional on the
drawdown of the position currently open. Stops and `from_order_func` recover some of it at the cost
of the speed you came for. If your strategy is path-dependent in that sense, an event-driven engine
is the other answer, not a slower version of this one.

It is also the free half of a commercial product. The vendor's own sentence is that VectorBT is the
open-source community edition of VectorBT PRO, and PRO is a separately installed package
(`vectorbtpro`) behind a paid membership and a private repository. What that split leaves out of
this edition is in Limitations, and it is not trivia.

Liveness, as of 2026-09-19: the repository is not archived, the last commit to `master` was
2026-09-17, and v1.1.0 shipped on 2026-07-05, the second release after v0.28.5 in March. 9,124 stars
and 121 open issues — the REST API's `open_issues_count` reads 139 because it counts pull requests
as issues.

## Pricing

The community edition is free, for individuals and organisations alike, and there is no pricing
page for it: the price is stated in the README and in LICENSE.md. What the licence withholds is the
right to sell it, not the right to use it — see Limitations.

The upgrade is a different purchase. On 2026-09-19 VectorBT PRO membership was advertised at $25 a
month, $240 for twelve months (shown as reduced from $300, i.e. $20 a month) or $500 once for
lifetime access, payable through GitHub Sponsors, Ko-fi, Stripe, Patreon, Paddle or Gumroad, with a
note that individual memberships cover personal, non-commercial use only and that the figures are a
limited-time rate for early contributors. Those are another product's prices, on a page this
catalogue does not have a card for; check them before planning against them.

## Data & coverage

VectorBT is not a data source and has no feed of its own, which is why this card records no data
latency: whatever you hand it is what you get, at whatever age you fetched it.

It does ship downloaders, and the two crypto ones are candle-only. `BinanceData` calls
python-binance's `get_klines`, which is the Binance **spot** klines endpoint. `CCXTData` calls
`fetch_ohlcv` on whichever CCXT exchange you pass it, so its venue list is CCXT's venue list and
its maintenance is CCXT's maintenance, not this library's. Neither fetches trades or order-book
depth, and neither is installed by default — `ccxt`, `python-binance`, `yfinance` and `alpaca-py`
all live in the `full` extra. There is also `YFData`, `AlpacaData` and a synthetic GBM generator for
tests.

`DataUpdater` schedules repeated fetches so a dataset can be kept current. That is data plumbing;
it does not place orders and it is not why the card's automation flag is false.

## Integrations

The library defines no exporter of its own — no `to_csv`, no `to_json`; whole objects pickle
through `save()` and `load()` with dill, and anything else comes from pandas, because every result
it returns is a pandas object. Indicators come from TA-Lib, `ta` and pandas-ta-classic through the
indicator factory, or from your own function wrapped by it. Plots are Plotly and Jupyter widgets. Performance reporting can be handed to
QuantStats. `vectorbt.messaging.telegram` wraps `python-telegram-bot` with `send_message` and
`send_to_all` so a script can push its own output to you — a sending helper, with no condition
engine behind it, which is why this card sets `alerts` to false.

Version 1.1.0 requires Python 3.11 to 3.14, numpy 2.4.6 or newer and pandas 3.0.3 or newer, which
is a more aggressive floor than most libraries in this category.

## Limitations

**No leverage, no limit orders, no contract multipliers.** All three are PRO features and the vendor
says so in the README and in its own comparison table. Searching the published 1.1.0 package for
`leverage` and `contract_multiplier` returns nothing at all.

**Which means no perpetuals, in any useful sense.** `funding` and `liquidat` are likewise absent
from the entire package. Nothing models an hourly funding payment, a mark price, maintenance margin
or a liquidation. You can feed it a perp's price series and it will backtest it as spot — arriving
at a number that omits the two largest cash flows the position actually has. For a crypto reader
this is the line that decides it, and it is not fixed by a parameter.

**The default fee is zero and the default slippage is zero.** `_settings.py` ships `fees=0.0`,
`fixed_fees=0.0` and `slippage=0.0`. Every README example that does not pass them is a frictionless
backtest, and on a strategy that turns over daily that is the difference between an edge and a
mirage.

**"Open source" is the vendor's word, not the licence.** LICENSE.md is Apache 2.0 with the Commons
Clause: the source is public, use is free, and the right to sell a product or service whose value
derives substantially from the software is explicitly withheld. That is source-available, which is
why this card sets `open_source` to false and writes the condition into the licence string. The
README calls it fair-code, the badge reads "Fair Code", and GitHub's own licence detector gives up
and returns NOASSERTION. If you intend to run a paid service on top of it, read the file first; the
author invites licence-exception requests by email.

**No execution of any kind.** There is no order placement in the package — no broker adapter, no
`create_order`. Going live means writing that yourself against the signals this produces, and the
vendor points paying members at PRO's streaming simulation for it.

**No portfolio optimiser.** The vendor's comparison table states it plainly: allocations are yours
to compute, and `PortfolioOptimizer` is PRO.

**No MCP server**, despite the README's talk of AI agents. The documentation chat, the CLI and the
MCP server are all PRO.

## Alternatives

The first fork in this category is architectural, not commercial. If your rule depends on what
happened at the last fill, an event-driven engine will express it and this one will fight you; if
you are sweeping parameter grids over long series, nothing event-driven will keep up. Decide that
before comparing feature lists.

The second is the licence. If you are building something you intend to sell, an MIT- or
BSD-licensed engine removes the Commons Clause question entirely rather than answering it by email.

The third is perpetuals, and it is the one with the shortest shortlist: most general-purpose Python
backtesters, this one included, model spot and stop there. The rest of the section is at
[Backtesting & Research Libraries](https://cryptomarkets.tools/categories/backtesting-libraries).

## FAQ

### Is VectorBT open source?

The source is public and free to use, but LICENSE.md is Apache 2.0 with the Commons Clause, which withholds the right to sell a product or service whose value derives substantially from the software. That is source-available rather than OSI open source, whatever the README calls it.

### What is the difference between VectorBT and VectorBT PRO?

They are two products. The community edition on this card simulates signals and market orders. PRO is a separate paid package, vectorbtpro, that adds limit orders, leverage, contract multipliers, stop ladders, a portfolio optimiser, cross-validation, parallel execution, streaming simulation and an MCP server.

### Can I backtest perpetual futures with VectorBT?

Not honestly. Nothing in the community edition models funding payments, mark-price liquidation, maintenance margin or leverage — the words do not appear in the package at all. You can feed it a perpetual's price series and it will treat it as spot, which omits the two largest cash flows the position has.

### Is VectorBT still maintained?

Yes as of 2026-09-19. The repository is not archived, the last commit to master was 2026-09-17, and v1.1.0 was released on 2026-07-05. Development is by the original author, who also sells the PRO edition.

## Also from VectorBT

- [VectorBT PRO](https://cryptomarkets.tools/tools/vectorbt-pro.md)

## Also worth comparing

- [Backtesting.py](https://cryptomarkets.tools/tools/backtesting-py.md) — Two thousand lines, one OHLC series, and no idea what a funding payment is.
- [Barter](https://cryptomarkets.tools/tools/barter.md) — Rust trading engine and market-data streams — live execution is a trait you implement.
- [HftBacktest](https://cryptomarkets.tools/tools/hftbacktest.md) — Tick-by-tick backtesting that models order queue position and feed and order latency.
- [Jesse](https://cryptomarkets.tools/tools/jesse.md) — Python backtesting and research framework whose live-trading half is a paid plugin.
- [LEAN](https://cryptomarkets.tools/tools/lean.md) — The engine behind QuantConnect, Apache-2.0 and runnable on your own machine.
- [Lumibot](https://cryptomarkets.tools/tools/lumibot.md) — One Python strategy that backtests and then trades live, across eight CCXT exchanges.

## Named as a replacement for

- [Enigma Catalyst](https://cryptomarkets.tools/alternatives/enigma-catalyst.md)