Jesse

Platform

Crypto trading framework

License

MIT core. The prebuilt live-trading plugin uses a separate commercial license

Pricing

Open-source research core with a separately licensed live-trading plugin

Live trading

Available through the separately licensed plugin

Best for

Self-hosted, route-based strategy research with a dashboard and optional live exchange connections

Jesse is a self-hosted Python framework for candle-based strategy research and parameter optimization. Routes connect strategies to exchanges and symbols without repeating that setup inside each strategy. Its MIT-licensed core covers backtesting and research. A separate plugin adds paper and live trading. The free plan includes limited testnet access, while paid lifetime plans add paper trading and broader exchange access.

The project is under active development. The Jesse 3.2.0 changelog is dated September 17, 2026 and adds traditional-market research documentation and trading-hours controls alongside simulation fixes.

How Jesse organizes a strategy

A route binds an exchange, symbol, timeframe, and strategy. Multiple routes let one session apply strategies across several symbols and timeframes, while data routes expose additional candle series without trading them. This configuration model is useful, but it does not mean every data source or exchange can be mixed in one backtest. For example, current traditional-market runs require one data source per run.

Strategies receive new candle events and define entries, exits, position updates, and lifecycle callbacks in Python. The simulator supports market, limit, and stop orders, partial position changes, fees, spot and perpetual-futures accounting, and multiple timeframes. Dashboard and research APIs expose backtests, Optuna and Ray optimization, Monte Carlo checks, exports, and performance metrics.

A self-contained core backtest

Jesse's research.backtest() API can run generated candles without the dashboard, a database, Redis, exchange credentials, or the commercial live plugin. The following script uses the MIT-licensed research core from Jesse 3.2.0. It creates 21 synthetic one-minute candles with closes from 10 through 30, buys one unit on the first strategy iteration, and submits a take-profit limit order two price units above the fill.

import jesse.helpers as jh
from jesse import research
from jesse.factories import candles_from_close_prices
from jesse.strategies import Strategy


class OneTradeStrategy(Strategy):
    def should_long(self):
        return self.index == 0

    def go_long(self):
        self.buy = 1, self.price

    def should_cancel_entry(self):
        return False

    def on_open_position(self, order):
        self.take_profit = self.position.qty, self.price + 2


exchange = "Fake Exchange"
symbol = "TEST-USDT"
config = {
    "starting_balance": 10_000,
    "fee": 0.001,
    "type": "futures",
    "futures_leverage": 1,
    "futures_leverage_mode": "cross",
    "exchange": exchange,
    "warm_up_candles": 0,
}
routes = [
    {
        "exchange": exchange,
        "strategy": OneTradeStrategy,
        "symbol": symbol,
        "timeframe": "1m",
    }
]
candles = {
    jh.key(exchange, symbol): {
        "exchange": exchange,
        "symbol": symbol,
        "candles": candles_from_close_prices(range(10, 31)),
    }
}

result = research.backtest(config, routes, [], candles)
trade = result["trades"][0]
metrics = result["metrics"]

print("trades:", metrics["total"])
print("entry / exit:", trade["entry_price"], trade["exit_price"])
print("quantity:", trade["qty"])
print("fees:", round(trade["fee"], 3))
print("net profit:", round(metrics["net_profit"], 3))
print("finishing balance:", round(metrics["finishing_balance"], 3))

Save it as jesse_research_example.py. A direct pip install jesse==3.2.0 attempt on macOS ARM with Python 3.11 failed while building Jesse's pinned Peewee 3.14.10 dependency against Cython 3. That is one environment-specific result, not proof that every native installation fails, but it reinforces the value of the supported Docker path. The current official project template references salehmir/jesse:latest, which can change. This validation instead pinned the image digest that contained Jesse 3.2.0 on September 19, 2026:

docker run --rm \
  -v "$PWD/jesse_research_example.py:/tmp/example.py:ro" \
  --entrypoint python \
  salehmir/jesse@sha256:e1da3649e45262c3694e0ad7fc195fbfaedd289e44027eae6ca3afaf66d84811 \
  /tmp/example.py

The exact script produced:

trades: 1
entry / exit: 10.0 12.0
quantity: 1.0
fees: 0.022
net profit: 1.978
finishing balance: 10001.978

The 0.022 fee is 0.1% of the 10-unit entry plus 0.1% of the 12-unit exit. The deliberately rising closes make the take profit inevitable, so the 1.978 gain is arithmetic, not evidence of an edge. The fake exchange, one-times leverage, generated candles, zero warm-up, and lack of spread, slippage, funding, liquidation, or market impact make this an engine and API check only.

This example does not cross Jesse's commercial boundary. Core research and backtesting are MIT-licensed. Installing jesse-live, connecting a testnet or production venue, or using paper trading follows the separate account, plan, and license rules discussed below.

Backtest results are still model outputs

Jesse replays imported candles and models common order types and fees. These features are more informative than assuming every decision fills at a candle close, but they do not establish exchange-level fill probability. Historical candles omit queue position and usually omit order-book depth. A resting limit order touched within a bar may behave differently in live trading because available size, latency, and competing orders are unknown.

Traditional-market data adds further qualifications. Jesse preserves market closures as gaps and can fill an order skipped by an opening gap at the new open. However, a stock short uses the perpetual-futures simulation model rather than a stock-borrow model. Individual futures contracts do not include contract multipliers, margin schedules, or rollover. The gapped-data documentation explicitly describes those assumptions.

For any market, record data provenance, symbol history, fees, leverage and margin settings, warm-up length, annualization, and timezone. Validate features for look-ahead bias and compare the strategy with simple baselines under the same settings.

Optimization and robustness tools

Jesse's research optimizer separates training and testing metrics and warns that more trials increase the chance of finding a parameter set that succeeded by coincidence. An internal test split is helpful, but repeated inspection can still contaminate it. Keep a final untouched period and report how many strategies, parameter sets, markets, and objectives were tried.

Trade-order and candle-based Monte Carlo tools probe path sensitivity. They do not create new independent market history or prove that a policy will generalize. Treat them as diagnostics alongside walk-forward testing, parameter-stability checks, and forward observation.

Open core, free plan, and paid live plugin

The core repository uses the MIT License. Live and paper trading use a prebuilt package available through an account license, not the MIT core. The live-trading documentation describes this installation boundary.

As accessed on September 19, 2026, the official pricing page lists free testnet live access but no free paper trading. It lists Basic, Pro, and Enterprise lifetime plans at $899, $999, and $1,599, with different IP, route, timeframe, support, and research-feature limits. Prices and entitlements can change, so verify the current plan before relying on them.

The live plugin remains self-hosted, but self-hosting does not remove exchange, credential, reconciliation, or operational risk. Use restricted API keys with withdrawals disabled, a dedicated account or subaccount, hard exposure limits, monitoring, and an independent record of exchange balances and orders.

When to choose Jesse

Choose Jesse when route-based strategy organization, its dashboard and research tooling, and its supported live-plugin path fit the project. It can also research traditional-market candles, but it is not yet a live traditional-broker platform. Choose Freqtrade when a GPL-licensed, fully open path to supported crypto live trading is more important. Use an order-book or tick-driven engine when microstructure determines the result.