Building a Crypto Trading Strategy with Python: A Step-by-Step Backtesting Guide

In this guide, we will build a complete cryptocurrency trading strategy using Python. We will use historical data to create and test a simple moving average crossover strategy, which generates buy and sell signals based on the interaction between two moving averages.

Prerequisites and Previous Knowledge

This article is part of a series on using Python for cryptocurrency investment. If you are new to this topic, it is recommended to review the foundational concepts covered in earlier parts. These include the rationale for investing in cryptocurrencies, methods for collecting cryptocurrency data via web scraping, and the basics of generating trading signals.

Constructing the Trading Signals

The core of our strategy relies on two moving averages: a short-term (20-period) and a long-term (60-period) simple moving average (SMA). The trading rules are straightforward:

A long (buy) signal is generated when the short-term SMA crosses above the long-term SMA.
A short (sell) signal is generated when the short-term SMA crosses below the long-term SMA.

In code, these signals are created using the pandas library in Python:

signal_long = (sma1 > sma2) & (sma1.shift() < sma2.shift())
signal_short = (sma1 < sma2) & (sma1.shift() > sma2.shift())

These signals are Boolean Series (True/False values) where True indicates the exact bar where a crossover event occurs.

Combining Signals into a Single Strategy

To prepare for backtesting, we need to combine the separate long and short signals into a single series that our backtesting engine can interpret. We want a series where:

A value of 1 represents a command to go long.
A value of -1 represents a command to go short.
A value of 0 represents no action (hold the current position).

This can be achieved with the following code:

signal = signal_long.copy()
signal[signal_short] = -1

Full Code for Signal Generation

The following code block fetches historical Bitcoin price data and generates the complete signal series.

from finlab import crypto

# Get historical price data for BTC/USDT on a 4-hour timeframe
df = crypto.get_all_binance('BTCUSDT', '4h')

# Calculate moving averages
sma1 = df.Close.rolling(20).mean()
sma2 = df.Close.rolling(60).mean()

# Create long and short signals
signal_long = (sma1 > sma2) & (sma1.shift() < sma2.shift())
signal_short = (sma1 < sma2) & (sma1.shift() > sma2.shift())

# Combine signals into a single series
signal = signal_long.copy()
signal[signal_short] = -1

Implementing the Backtest

To evaluate the performance of this strategy, we use the Backtesting.py library. This involves creating a custom strategy class that inherits from SignalStrategy.

The key steps in the class are:

Initialization (init method): This method runs once before the backtest begins. Here, we precompute our moving averages and the trading signal based on the historical price data provided to the strategy.
Setting the Signal: The precomputed signal series is passed to the backtesting engine using the set_signal() method.

This approach decouples the strategy logic from the specific asset, making it reusable for different cryptocurrencies or even traditional equities.

from backtesting import Backtest
from backtesting.lib import SignalStrategy
import pandas as pd

# Assuming 'df' is already loaded with price data
class Strategy(SignalStrategy):

    def init(self):
        # Call the parent class's init method
        super().init()

        # Precompute the two moving averages from the backtest data
        close = pd.Series(self.data.Close)
        sma1 = close.rolling(20).mean()
        sma2 = close.rolling(60).mean()

        # Precompute the trading signals
        signal_long = (sma1 > sma2) & (sma1.shift() < sma2.shift())
        signal_short = (sma1 < sma2) & (sma1.shift() > sma2.shift())

        signal = signal_long
        signal[signal_short] = -1

        # Set the signal for the backtesting engine
        self.set_signal(signal)

    def next(self):
        # This method runs on every bar; we call the parent method for standard processing.
        super().next()

# Create a Backtest instance and run it
bt = Backtest(df, Strategy)
results = bt.run()
bt.plot()

Analyzing the Backtest Results

After running the backtest, the library will output a performance report containing metrics like Total Return, Sharpe Ratio, Max Drawdown, and others. The bt.plot() function will generate a chart visualizing the equity curve, trade entries/exits, and the price data with the moving averages.

It is common for a simple strategy like this to show suboptimal performance initially. The next logical step is to optimize the strategy parameters (e.g., the lengths of the moving averages) to improve its risk-adjusted returns. 👉 Explore more strategies for advanced parameter optimization techniques.

Frequently Asked Questions

What is a moving average crossover strategy?
It is a common trading tactic that uses two moving averages of different lengths. A buy signal occurs when the shorter-term average crosses above the longer-term one, suggesting emerging upward momentum. A sell signal occurs during the opposite crossover, indicating potential downward momentum.

Why use Python for backtesting crypto strategies?
Python offers powerful, accessible libraries for data analysis (pandas), numerical computation (NumPy), and specialized backtesting (Backtesting.py, vectorbt). This allows traders to quickly prototype, test, and validate trading ideas against historical data before risking real capital.

What is the difference between a backtest and a live trade?
A backtest simulates how a strategy would have performed on historical data. Live trading involves executing the strategy with real money in real-time markets. Backtests can be optimistic due to "overfitting" to past data and not accounting for real-world factors like slippage and exchange fees, which must be considered before going live.

How can I improve this basic strategy?
Improvements can include adding filters (e.g., using volume or volatility), incorporating different types of indicators (e.g., RSI, MACD), optimizing parameters for specific market regimes, and implementing robust risk management rules, such as stop-loss and take-profit orders.

Is this strategy profitable?
The profitability of any strategy depends heavily on the market conditions, the specific parameters used, and the transaction costs involved. A simple crossover strategy may work well in trending markets but will likely generate losses (whipsaws) in ranging or choppy markets. Thorough backtesting and forward-testing are essential.

What are the risks of automated crypto trading?
Risks include technical failures (e.g., code errors, internet outages, exchange API issues), extreme market volatility ("crypto winters," flash crashes), cybersecurity threats (hacking), and the inherent risk of financial loss. It's crucial to understand these risks and never invest more than you can afford to lose.