Deploy Jesse Strategies on TradingHost
Run open-source Jesse strategies from GitHub on always-on TradingHost runtimes.
Jesse is a Python algo trading framework with backtesting, Optuna-based optimisation, a built-in ML pipeline, and live execution. TradingHost gives that strategy a production runtime.
- GitHub-native deployment
- Backtest with no look-ahead bias
- Optuna optimisation
- Built-in ML pipeline
- Multi-symbol, multi-timeframe
- Always-on runtime
- Encrypted API keys
- Region proximity to exchanges
- MCP-ready
Introduction
New to Jesse?
Jesse is a free, open-source crypto trading framework written in Python. It is designed around the idea that strategy code should be unusually readable, and that the same file should run cleanly across backtest, paper, and live without copy-paste changes between modes.
Out of the box you get a backtester with no look-ahead bias, parameter optimisation powered by Optuna, a Monte Carlo stress tester for trade and candle shuffling, a built-in machine-learning pipeline for binary, multiclass, and regression models, and a 300+ technical indicator library. The framework is MIT licensed and actively developed.
Jesse supports multi-symbol and multi-timeframe trading inside one strategy, partial fills, and a clean separation between the routes definition (what symbols and timeframes you trade) and the strategy class (how you trade them).
TradingHost is where a Jesse strategy runs in production. Instead of leaving your strategy on a laptop or a generic VPS, you deploy your Jesse repo to a TradingHost cloud runtime that stays online, manages your exchange API keys as encrypted secrets, and streams logs back to you.
Section 01 · At a glance
At a glance
- What Jesse is
- Open-source Python algo trading framework, MIT licensed
- Maintained by
- The Jesse project on GitHub (jesse-ai/jesse)
- Language
- Python
- Markets
- Crypto spot, perpetual futures (multiple venues)
- Indicators
- 300+ built-in technical indicators
- Modes
- Backtest, optimise (Optuna), paper, live, ML training
- Notable features
- No look-ahead bias, multi-symbol and multi-timeframe, partial fills, Monte Carlo stress test
- Deployment source
- GitHub
- TradingHost role
- Runtime, deployment, logs, secrets, region selection
- Jesse role
- Strategy framework, backtester, optimiser, ML pipeline
- Affiliation
- TradingHost is independent and is not affiliated with the Jesse project
- Best for
- Indicator-driven crypto strategies, multi-symbol portfolios, ML-assisted entries
Section 02 · Where Jesse fits
How Jesse fits into the trading stack
Jesse is a self-contained algo trading framework. Unlike Freqtrade, Jesse ships its own exchange drivers rather than relying on CCXT, which is part of why the supported exchange list is shorter but more deeply integrated.
You can use Jesse two ways on TradingHost:
Path 01
Strategy class
Subclass Jesse’s Strategy class. Write should_long, should_short, go_long, go_short, update_position, and Jesse handles routes, candles, indicators, broker simulation, and order management.
Path 02
ML pipeline
Use Jesse’s built-in ML pipeline to train binary, multiclass, or regression models alongside your strategy. The framework wires features, splits, and inference into the same lifecycle as a normal strategy.
Either path runs the same way on TradingHost. You bring a Jesse GitHub repo. We run it.
- You
- Your strategy class owns the trading rules.
- Jesse
- Runs the strategy loop, backtester, optimiser, ML pipeline, and exchange drivers.
- Exchange
- Your exchange account receives the orders.
- TradingHost
- Runs the strategy process, manages secrets, streams logs.
Section 03 · Why on TradingHost
Why deploy Jesse on TradingHost
A live Jesse strategy needs to run continuously, hold your exchange API keys, and keep websocket connections alive. Running on a laptop, desktop, or generic VPS introduces operational drag, including process supervision, restarts, dependency management, log scattering, and manual deployment.
TradingHost gives a Jesse strategy a production-oriented runtime designed for long-running trading processes.
What you get
- GitHub-native deployment
- Always-on container runtime
- Multi-strategy support inside one runtime
- Encrypted exchange API key storage
- Region selection close to your exchange
- Streaming logs and basic health
- Strategy-level start, stop, restart, inspect
- Update one strategy without restarting the runtime
- MCP-compatible AI IDE workflows
What you keep
- Full control over your Jesse strategy code
- Direct ownership of your exchange accounts and API permissions
- Your choice of Jesse modes: backtest, optimise, paper, live, ML
Section 04 · Supported exchanges
Supported exchanges
Jesse ships its own exchange drivers rather than relying on CCXT, so the supported list is curated and tightly integrated. Coverage spans major centralised venues plus Hyperliquid and the Apex DEX family.
Five featured pairings are shown below. Apex Pro perpetual and Apex Omni are also supported drivers documented by the Jesse project.
- Jesse
- your exchange
- TradingHost runtime
Jesse also ships drivers for the Apex DEX family: Apex Pro perpetual, Apex Omni. New exchange drivers are added as community demand and sponsorship justify the integration work.
Browse the crypto broker directorySection 05 · Deployment flow
How a Jesse deployment works
A Jesse strategy on TradingHost follows the same deployment pattern as any GitHub-based project.
- STEP 01
Connect or create a repo
Sign in with GitHub and connect an existing Jesse strategy repository, or create one from a TradingHost Jesse template with sensible defaults.
- STEP 02
Configure the runtime
TradingHost reads your project’s runtime configuration to know how to install dependencies and start Jesse in the mode you want.
- STEP 03
Add encrypted exchange API keys
Add your exchange API keys as TradingHost secrets. They are encrypted, injected into the runtime at start, and never written to your repository.
/platform/secrets/ - STEP 04
Choose a region
Select a region close to your exchange’s matching engine. AWS Tokyo for Binance Spot, AWS Frankfurt for many EU-domiciled exchanges.
/platform/regions/ - STEP 05
Deploy
TradingHost starts Jesse in a managed container. Logs stream back to the dashboard. The Jesse dashboard, when configured, runs alongside the strategy process.
/platform/observability/
Section 06 · Strategy lifecycle
Backtest, optimise, paper, live
Jesse is designed around the idea that one strategy file should run cleanly across every stage of its life. Backtest, optimise, train an ML model, paper trade, and go live, all from the same Python class.
Each stage runs on the same TradingHost runtime. Pick a stage at start time, or run several side by side as separate processes (for example, a paper-traded clone of a live strategy as a continuous canary).
Section 07 · What we don’t do
What TradingHost does not do
- TradingHost does not act as your exchange.
- TradingHost does not provide trading strategies or financial advice.
- TradingHost does not modify your Jesse routes file or strategy class.
- TradingHost does not custody your exchange API keys beyond encrypted runtime injection.
- TradingHost does not guarantee strategy performance, exchange uptime, or market connectivity.
Section 08 · FAQ
FAQ
No. TradingHost is independent. Jesse is open-source, MIT-licensed software maintained by the Jesse project on GitHub (jesse-ai/jesse).
Python. You write a strategy class with hooks like should_long, go_long, and update_position. The same class runs in backtest, optimise, paper, and live modes.
Jesse documents native drivers for Binance Spot, Binance Spot US, Binance USDT-M Futures, Bybit Spot, Bybit USDT and USDC perpetuals, Coinbase Spot, Gate.io Spot and perpetuals, Hyperliquid, Apex Pro perpetual, and Apex Omni.
No. Jesse ships its own native exchange drivers, which is why the supported list is shorter but the integrations are deeper.
It is built to avoid look-ahead bias by default, supports partial fills, and lets one strategy run multi-symbol and multi-timeframe simultaneously. There is also a Monte Carlo stress test that shuffles trades and candle data to gauge robustness.
Yes. Jesse ships a built-in ML pipeline for binary, multiclass, and regression models that integrates with the same strategy lifecycle as a normal Jesse class.
Yes. Jesse’s Optuna integration is compute-bound and runs cleanly inside a TradingHost runtime sized for the search space. The same runtime can later be re-pointed to live mode without code changes.
You add them to TradingHost as encrypted secrets. They are injected into the Jesse runtime at start and are not written to your repository.
No. Jesse places trades through your exchange API credentials. TradingHost runs the Jesse process and streams logs.
No. Jesse is designed for cryptocurrency exchanges. For non-crypto markets, see /frameworks/nautilustrader/ or /frameworks/backtrader/.
Deploy your first Jesse strategy
Connect GitHub, choose a Jesse template or your own strategy repo, add your exchange API keys, choose a region, and launch into a TradingHost runtime.