Building Crypto Trading Bots with Freqtrade and Jesse: A Complete Guide to Awesome Systematic Trading

The Awesome Systematic Trading repository provides ready-to-deploy Python strategies and curated links to Freqtrade and Jesse, enabling you to bootstrap a crypto trading bot with academically-backed algorithms in minutes.

This guide leverages the open-source resource collection at paperswithbacktest/awesome-systematic-trading to demonstrate how to build systematic cryptocurrency trading bots using two leading Python frameworks. Whether you prefer Freqtrade's event-driven architecture or Jesse's vectorized backtesting engine, the repository supplies the strategy implementations and configuration patterns needed to move from research to live trading.

Understanding the Awesome Systematic Trading Repository

The Awesome Systematic Trading repository functions as a curated knowledge hub rather than a monolithic codebase. Located at the root, README.md serves as the primary navigation anchor, organizing resources into six functional sections including Libraries & Packages, Strategies, and Educational Materials.

Within the Libraries and Packages section, the repository maintains a hierarchical taxonomy that categorizes tools by function. Under the Cryptocurrencies sub-section, you will find direct links to Freqtrade and Jesse, each annotated with star counts and primary language badges. The static/strategies/ directory contains over 40 Python implementations of peer-reviewed trading strategies, specifically formatted for QuantConnect's Lean engine but adaptable to other frameworks.

Notable crypto-specific strategy files include:

• static/strategies/intraday-seasonality-in-bitcoin.py – Implements overnight seasonality effects in Bitcoin markets
• static/strategies/rebalancing-premium-in-cryptocurrencies.py – Captures daily rebalancing premium across crypto assets

Freqtrade vs Jesse: Choosing Your Crypto Trading Framework

Selecting between these frameworks depends on your research workflow and performance requirements.

Freqtrade

Freqtrade is a fully featured, event-driven trading bot supporting backtesting, hyper-parameter optimization, and Telegram integration. It operates on a tick-by-tick basis, making it ideal for strategies requiring precise entry/exit timing or complex order management.

The repository links to Freqtrade within the Cryptocurrencies table row, noting its mature ecosystem and extensive exchange support via CCXT integration.

Jesse

Jesse emphasizes research velocity through vectorized backtesting and modular strategy definition. Unlike Freqtrade's event loop, Jesse processes data in optimized arrays, delivering backtest results orders of magnitude faster for strategies that don't require tick-level precision.

The Awesome Systematic Trading list highlights Jesse's focus on algorithmic research and its clean API for defining indicators within strategy classes.

Implementing Crypto Strategies from the Repository

The static/strategies/ directory provides production-ready code that bridges academic research and practical implementation.

Bitcoin Overnight Seasonality Strategy

The file intraday-seasonality-in-bitcoin.py implements a time-series pattern exploiting Bitcoin's overnight return behavior. The strategy class inherits from Lean's QCAlgorithm but can be adapted to Freqtrade's IStrategy interface or Jesse's Strategy base class.

Key components include:

• Time-based entry filters for specific UTC hours
• Volatility-adjusted position sizing
• Risk management through stop-loss logic

Rebalancing Premium Strategy

Located at static/strategies/rebalancing-premium-in-cryptocurrencies.py, this algorithm captures the premium generated by daily portfolio rebalancing across crypto assets. The implementation demonstrates cross-asset correlation analysis and dynamic weight allocation.

Step-by-Step Setup and Backtesting

Follow these procedures to deploy repository strategies on your local machine.

Setting Up Freqtrade with Academic Strategies

Install Freqtrade and initialize a new project:

# Install Freqtrade (requires Python 3.9+)

pip install freqtrade

# Create project scaffold

freqtrade new-project myfreqbot
cd myfreqbot

Download the Bitcoin seasonality strategy from the repository:

curl -L \
  https://raw.githubusercontent.com/paperswithbacktest/awesome-systematic-trading/main/static/strategies/intraday-seasonality-in-bitcoin.py \
  -o user_data/strategies/overnight_seasonality.py

Adapt the strategy to Freqtrade's interface:

# user_data/strategies/overnight_seasonality.py

from freqtrade.strategy import IStrategy
from pandas import DataFrame

class OvernightSeasonality(IStrategy):
    timeframe = '5m'
    stoploss = -0.05
    
    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        # Add seasonality indicators

        dataframe['hour'] = dataframe['date'].dt.hour
        return dataframe
    
    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (dataframe['hour'] >= 22) & (dataframe['volume'] > 0),
            'buy'
        ] = 1
        return dataframe
    
    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (dataframe['hour'] <= 6) & (dataframe['volume'] > 0),
            'sell'
        ] = 1
        return dataframe

Execute the backtest:

freqtrade backtest --strategy OvernightSeasonality --pair BTC/USDT

Configuring Jesse for Vectorized Backtesting

Install Jesse and create a project structure:

pip install jesse
jesse init myjessebot
cd myjessebot

Retrieve the rebalancing premium strategy:

curl -L \
  https://raw.githubusercontent.com/paperswithbacktest/awesome-systematic-trading/main/static/strategies/rebalancing-premium-in-cryptocurrencies.py \
  -o strategies/rebalancing_premium.py

Implement the Jesse-compatible strategy class:

# strategies/rebalancing_premium.py

from jesse.strategies import Strategy

class RebalancingPremium(Strategy):
    def __init__(self):
        super().__init__()
        self.vars['rebalance_hour'] = 0
        
    def should_long(self) -> bool:
        # Entry logic based on rebalancing premium detection

        return self.time == self.vars['rebalance_hour']
    
    def should_exit(self) -> bool:
        # Hold until next rebalancing period

        return self.time == 23
    
    def go_long(self):
        qty = self.capital / self.price
        self.buy = qty, self.price
    
    def go_short(self):
        pass

Run the vectorized backtest:

jesse backtest rebalancing_premium BTC-USDT 1h

Key Files and Directory Structure

Understanding the repository layout accelerates strategy discovery:

• README.md – Central navigation containing categorized tables of libraries and strategies
• static/strategies/intraday-seasonality-in-bitcoin.py – Bitcoin-specific overnight seasonality implementation
• static/strategies/rebalancing-premium-in-cryptocurrencies.py – Multi-asset crypto rebalancing algorithm
• static/strategies/asset-growth-effect.py – Equity strategy template adaptable to crypto markets
• opencode.json – Platform metadata for Opencode integration (not required for end-users)

Summary

• The Awesome Systematic Trading repository at paperswithbacktest/awesome-systematic-trading serves as a curated index linking to Freqtrade and Jesse within its Cryptocurrencies section.
• Freqtrade provides event-driven live trading with exchange integrations, while Jesse offers high-speed vectorized backtesting for research iterations.
• Ready-made strategies in static/strategies/ include intraday-seasonality-in-bitcoin.py and rebalancing-premium-in-cryptocurrencies.py, formatted initially for QuantConnect Lean but adaptable to both frameworks.
• You can bootstrap a functional crypto bot by curling strategy files directly from the repository into your local Freqtrade or Jesse projects.
• The repository structure emphasizes discoverability through Markdown tables, making it straightforward to locate data APIs, analytics libraries, and machine learning tools alongside the core trading frameworks.

Frequently Asked Questions

What is the Awesome Systematic Trading repository?

The Awesome Systematic Trading repository is a curated "awesome-list" that aggregates open-source resources for quantitative trading. It organizes links to backtesting frameworks, live-trading bots, academic strategy implementations, and educational materials into navigable Markdown tables, serving as a knowledge hub rather than a standalone executable platform.

How do I install Freqtrade and Jesse from the repository?

The repository does not distribute the frameworks directly; instead, it provides verified links to the official projects. You install Freqtrade via pip install freqtrade and Jesse via pip install jesse, then download strategy files from the repository's static/strategies/ directory using curl or manual download to integrate academically-backed algorithms into your local bot instances.

Can I use these strategies with QuantConnect Lean?

Yes. The Python files in static/strategies/ are originally implemented for QuantConnect's Lean engine, inheriting from QCAlgorithm. You can deploy them directly to QuantConnect's cloud platform or run them locally using the Lean CLI. To use them with Freqtrade or Jesse, you must adapt the class structure to inherit from IStrategy or Strategy respectively while preserving the core indicator logic.

Where are the crypto trading strategies located in the repository?

Crypto-specific strategies reside in the static/strategies/ directory at the repository root. Key files include intraday-seasonality-in-bitcoin.py for Bitcoin overnight effects and rebalancing-premium-in-cryptocurrencies.py for portfolio rebalancing approaches. These files are referenced in the main README.md within the Strategies table, which maps each implementation to its originating academic paper.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}