Jesse — Python Crypto Trading Framework with Backtesting & Futures

Jesse is a Python-based crypto trading framework built for backtesting, optimization, and live trading. It focuses exclusively on cryptocurrency markets and provides a clean, expressive syntax for defining strategies. With 300+ built-in indicators, futures/leverage support, and a web dashboard, it targets crypto-native quant traders.

Language: Python + JavaScript (dashboard) | License: MIT (core) | Price: Free core, ~$99/mo live trading | GitHub Stars: ~7,600

Key Features

300+ built-in technical indicators
Multi-symbol and multi-timeframe strategies in a single backtest
Spot and futures with leverage and short-selling
Partial position fills simulation
Walk-forward optimization and hyperparameter tuning
Web-based GUI dashboard for managing strategies
Paper trading mode for validation before live deployment
JesseGPT — AI assistant for strategy development
Docker support for deployment
Risk management tools built-in

Strategy Example

from jesse.strategies import Strategy
import jesse.indicators as ta

class GoldenCross(Strategy):
    @property
    def fast_sma(self):
        return ta.sma(self.candles, 50)

    @property
    def slow_sma(self):
        return ta.sma(self.candles, 200)

    def should_long(self) -> bool:
        return self.fast_sma > self.slow_sma

    def should_short(self) -> bool:
        return self.fast_sma < self.slow_sma

    def go_long(self):
        entry = self.price
        qty = self.position_size / entry
        self.buy = qty, entry

    def go_short(self):
        entry = self.price
        qty = self.position_size / entry
        self.sell = qty, entry

    def should_cancel_entry(self):
        return False

Strategies use a clear method-based pattern: define entry conditions, define exit conditions, define position sizing. Jesse handles execution, risk management, and reporting.

Data Sources

Exchange candle data downloaded directly from Binance, Binance Futures, Bybit, Coinbase
Built-in historical candle import tool
Crypto-only — no stock or forex data

Pros

Clean, expressive Python syntax — one of the most readable strategy APIs
Best-in-class crypto futures backtesting (leverage, shorts, partial fills)
300+ indicators included out of the box
MIT license for the core framework
Web dashboard for visual strategy management
Multi-timeframe and multi-symbol support
Walk-forward optimization built-in
Paper trading for validation

Cons

Crypto-only — no stocks, forex, or other asset classes
Live trading requires paid plugin (~$99/month)
Smaller community than general-purpose frameworks (~7.6K stars)
JavaScript-heavy codebase may surprise Python-focused users
Development pace slowed (last commit Dec 2024)
Limited exchange support compared to CCXT-based tools like Freqtrade

Pricing

The core framework is free and MIT-licensed. Live trading requires the Jesse Live Trade plugin at approximately $99/month. JesseGPT (AI assistant) is included with some plans.

Community & Support

~7,600 GitHub stars, 3,213 commits, 48 contributors
Active Discord community
YouTube tutorials from the team
Help center at help.jesse.trade
Documentation is well-written and beginner-friendly

Who Should Use Jesse?

Jesse is ideal for crypto traders who want a clean Python API with built-in futures support, leverage, and short-selling simulation. The web dashboard and walk-forward optimization make it a step above simpler frameworks for serious crypto strategy development.

If you trade stocks or forex, look at Backtrader or QuantConnect. If you want a fully free crypto bot with live trading included, check Freqtrade. If you need raw speed for research, see VectorBT.