Jesse

What it is

A Python framework for writing a crypto trading strategy as a class, replaying it over historical candles, and — if you buy a licence — running that same class against a live exchange. It is not a library you import into an existing project: it wants a project of its own, a PostgreSQL database and a Redis instance, and it gives you a local web dashboard to drive backtests from. Python 3.10 to 3.13; Docker is the documented shortcut.

The engine is event-driven. Jesse replays one-minute candles and aggregates every larger timeframe from them as it goes, which is how it gets multi-timeframe strategies without lookahead, and why it is slower than a vectorised engine and able to express rules that depend on the last fill. The indicator library is the other half of the pitch: 174 functions exported by the package at v3.2.0, several of which select further variants by argument. The vendor advertises 300+.

Around the backtest sit the parts that make it a research tool rather than a runner: Optuna-driven parameter optimisation with separate train and test periods, Monte Carlo analysis by trade-order shuffling, bootstrap significance testing for a single entry rule, a scikit-learn pipeline that labels backtest output and deploys the model inside a strategy, and a Python research API for Jupyter. It also ships a first-party MCP server, so an agent can run those workflows on your machine instead of you clicking through the dashboard.

The repository is active in a way that is easy to check and worth checking: last commit on master 2026-09-17, v3.2.0 released the same day, seven open issues, not archived.

Pricing

The MIT repository is free and backtests without an account. What the money buys is the live trading plugin, and the split is sharper than the marketing suggests: on the free plan, the only exchanges you may trade are testnets, paper trading is off, backtest benchmarks are off, DEX support is off, optimisation and Monte Carlo runs are throttled to "limited CPU cores", and the MCP server is capped at 100 agentic workflows a day.

Paid plans are one-time purchases, not subscriptions, all badged "Lifetime": Basic $899, Pro $999, Enterprise $1,599. Basic already unlocks every supported live exchange, paper trading and DEX support; the higher tiers buy capacity rather than capability — IP limits (1 / 2 / 5), live trading tabs (1 / 10 / 20), trading routes (1 / 10 / 50), data routes (1 / 50 / 250), and the timeframes you may trade. That last one is the trap in the cheap tier: Basic restricts live trading to hourly and daily candles, so a strategy you developed on 5m bars needs Pro. Monthly credits for the vendor's GPT assistant run 100 / 150 / 300 / 500.

A promotional 40–50% discount was running on this page in late 2025 and is not running today, which is worth knowing before you treat the list price as final.

Data & coverage

Jesse ships no data. You import candles from an exchange's own public endpoints into your own Postgres, picking a start date — there is no end date, because the importer always runs to today — and history depth is therefore whatever that exchange serves, not a number Jesse controls.

Twelve venues can supply backtest candles: Binance Spot, Binance US Spot, Binance Perpetual Futures, Bitfinex Spot, Coinbase Advanced Spot, Bybit Spot, Bybit USDT and USDC Perpetuals, Gate.io Perpetual Futures, KuCoin Spot, KuCoin USDT Perpetuals and Kraken Pro Futures. Sixteen can be traded live, and the two lists are not the same. Five live venues — Hyperliquid, Lighter, Apex Omni, Gate.io Spot and Kraken Pro Spot — cannot be backtested at all, because their APIs do not return enough history; Bitfinex Spot runs the other way, a candle source with no live driver. The exchange name only labels the source of the candles — you can backtest Binance Spot data in futures mode and vice versa.

Traditional markets are backtest-only. One first-party data provider, Massive, covers stocks, currencies, indices and futures, and there is a generic CSV import for anything else; live trading still has to go through a crypto exchange until the Alpaca driver ships.

What the simulation actually charges you is the number that decides whether a result means anything, and Jesse's defaults are better than most. Fees are pre-filled per exchange from the venue's real taker rate — 0.1% Binance spot, 0.04% Binance perpetual futures, 0.055% Bybit, 0% on Lighter — rather than the zero that several competing engines default to, and the backtest form lets you override the rate. See ## Limitations for what it does not charge you.

Integrations

Strategies are plain Python classes, so anything on PyPI is available inside one; the research API exposes candles, backtests, optimisation, Monte Carlo and significance testing to a Jupyter notebook. Backtest results export as CSV or JSON, one row per closed trade, both opt-in on the backtest form.

The MCP server is first-party, runs locally, and has documented setup for Claude Code, Codex, Cursor, VS Code and Zed, plus an AGENTS.md rules file so the assistant follows Jesse's own conventions. Live notifications go to Telegram, Discord and Slack, the latter two by pasting an incoming-webhook URL — there is no general-purpose webhook interface, and the notification drivers ship with the paid plugin rather than the open package.

Limitations

Funding is not simulated. Position.funding_rate returns zero unless the bot is running live. A perpetuals backtest in Jesse therefore contains no funding payments in either direction, which for a carry-sensitive or long-held position is the difference between a result and a number.

Liquidation is off by default. The backtest only checks for liquidations in isolated margin mode, and the shipped default is cross — in which liquidation_price is NaN and the check returns immediately. A leveraged strategy will happily survive a drawdown in simulation that would have closed the account.

There is no slippage model. Not a configurable one set to zero: the word does not appear in the package. Fills happen at the price the candle gives them. For anything that trades size, turns over quickly, or works in thin books, this is the largest single gap between the backtest and the exchange.

One fee rate, no maker/taker split. The per-exchange default is the taker rate and it is charged on every fill, including limit orders that would have earned a rebate. Maker-heavy strategies are penalised; the correction has to be done by hand.

The half you pay for is not open source. The MIT repository contains the backtest engine, the indicators, the research module and the MCP server. jesse/modes/ has no live mode at all — the live and paper loops arrive as a pre-built binary for your OS, CPU architecture and Python version, installed by jesse install-live against a licence token, and are not published on PyPI. The licence claim on the repository is true and also not the whole product; nothing above about fees, funding or liquidation has been checked against the plugin, because it cannot be read.

Spot mode is a real restriction, not a setting. No short selling, self.leverage is always 1, and you cannot set take-profit or stop-loss inside go_long() because the fee is deducted from the asset and the position size is not known until the order fills; those targets move to on_open_position().

It is not a lightweight import. Postgres, Redis, a project scaffold and a dashboard are the minimum. If you want to score a signal over a price series in a notebook, most of this is overhead — other engines in backtesting and research libraries are a better fit for that, and Jesse's own research module assumes the same installed stack.

Alternatives

Freqtrade is the direct comparison and the one that makes this card's pricing the deciding fact: it backtests and trades live for nothing, on an open licence, with a fill model the documentation admits is optimistic. What you are buying here instead is the research ergonomics and a live plugin sold once rather than monthly.

NautilusTrader is the more serious engine for the same ambition, and costs more to learn than either. backtesting.py is the small, readable option with no funding model and one instrument per run. vectorbt is the answer when the job is thousands of parameter sweeps rather than one strategy, and it has no perpetuals in any useful sense.

For fills that model queue position and latency, hftbacktest; for a hosted engine with the data attached, QuantConnect Cloud.