# Jesse

Python backtesting and research framework whose live-trading half is a paid plugin.

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

## Facts

### At a glance

| Field | Value |
| --- | --- |
| Vendor | Jesse.Trade |
| Category | Backtesting & Research Libraries |
| Job | backtesting |
| Website | https://jesse.trade |
| Pricing model | one-time |
| Free tier | true |
| Open source | true |
| Licence | MIT |
| Self-hosted | true |
| KYC required | false |
| Tested hands-on | false |
| Last updated | 2026-09-21 |

### Pricing

| Tier | USD | Period |
| --- | --- | --- |
| Free | 0 USD | — |
| Basic | 899 USD | once |
| Pro | 999 USD | once |
| Enterprise | 1599 USD | once |

### Coverage

| Field | Value |
| --- | --- |
| Asset classes | spot, perpetuals |
| Chains | none |
| Venues | cex, dex, derivatives |
| Data latency | realtime |
| Platforms | web, cli, library |
| AI features | assistive |

### Interfaces

| Field | Value |
| --- | --- |
| API | false |
| Webhooks | false |
| Scripting | Python |
| MCP server | true |
| Export | csv, json |

### Capabilities

Yes: charting, backtesting, automation, live_trading, paper_trading, alerts

No: screening, portfolio_tracking, exchange_import, tax_reporting, news, onchain_data, wallet_tracking, derivatives_analytics

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

## 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](https://cryptomarkets.tools/categories/backtesting-libraries) are a
better fit for that, and Jesse's own research module assumes the same installed stack.

## Alternatives

[Freqtrade](https://cryptomarkets.tools/tools/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](https://cryptomarkets.tools/tools/nautilus-trader) is the more serious engine for the same ambition, and
costs more to learn than either. [backtesting.py](https://cryptomarkets.tools/tools/backtesting-py) is the small, readable
option with no funding model and one instrument per run.
[vectorbt](https://cryptomarkets.tools/tools/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](https://cryptomarkets.tools/tools/hftbacktest); for a hosted
engine with the data attached, [QuantConnect Cloud](https://cryptomarkets.tools/tools/quantconnect-cloud).

## FAQ

### Is Jesse free?

The framework on GitHub is MIT-licensed and free, and it backtests without paying anything. Live and paper trading are a separate pre-built plugin sold to licence holders — a one-time purchase starting at $899. On the free plan the only exchanges you can trade are testnets.

### Does Jesse's backtest simulate funding payments on perpetuals?

No. Position.funding_rate returns 0 unless the bot is running live, so a perpetuals backtest carries no funding cost or credit. Budget for that separately before believing a carry-sensitive result.

### What fees and slippage does Jesse charge by default?

It ships a real taker fee per exchange rather than zero — 0.1% for Binance spot, 0.04% for Binance perpetual futures — and you can override it per backtest. There is no slippage model at all, and one fee rate covers both maker and taker fills.

### Can I run the same strategy code in a backtest and live?

Yes, that is the design — one strategy class, three modes. The catch is that the live and paper modes are not in the open-source repository; they arrive as a closed binary once you buy a licence.

### Does Jesse have an MCP server?

Yes. It ships a first-party MCP server that runs on your own machine, with setup guides for Claude Code, Codex, Cursor, VS Code and Zed. The free plan caps it at 100 agentic workflows a day.

## 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.
- [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.
- [NautilusTrader](https://cryptomarkets.tools/tools/nautilus-trader.md) — Event-driven Rust engine that settles perpetual funding at the venue boundary.

## Named as a replacement for

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