# Bitcoin – Trading Moving Averages or HODL? A Python Script Uncovers the Answer!

I’ve always wondered if a slow and high-level trading strategy focusing on long-term trends could outperform a buy-and-hold strategy.

To answer this question, I created a Python script that would utilize a momentum-based strategy to tell me when to buy and when to sell Bitcoin.

Despite my busy life and doubts that day trading would be a successful venture, I was eager to find out if this simple program could beat the market. I can run the Python code daily to decide whether to buy or sell BTC.

What would have happened if I had used the following strategy between the turbulent years 2020 and 2022 in Bitcoin? Read on to find out! π

## General Idea

The idea of this algorithm is to allow traders to automate their Bitcoin trading decisions using two moving averages.

π Finxter Academy: Complete Python Trading Course (Binance) — Simple Moving Average

The algorithm will enter buy positions when the shorter-term moving average (`MA1`) is higher than the longer-term moving average (`MA2`) indicating a positive momentum of the Bitcoin price, and enter sell positions when the shorter-term moving average is lower than the longer-term moving average indicating a negative momentum of the Bitcoin price.

When the moving averages cross, the algorithm will close any existing positions and reverse the trading direction.

## Algorithm Steps

My strategy follows these simple steps:

1. Initialize two moving averages, `MA1` and `MA2`, with different lookback periods.
2. Calculate the current value of each moving average.
3. If `MA1 > MA2`, enter a buy position in the Bitcoin market.
4. If `MA1 < MA2`, enter a sell position in the Bitcoin market.
5. Monitor the market for any changes in the moving averages.
6. When the moving averages cross, close any existing positions and reverse the trading direction (buy if previously selling, sell if previously buying).
7. Repeat steps 2 to 6.

## Python Program to Automate It

The following program implements these steps in practice by pulling the Bitcoin price data from an online API, calculating the moving averages (short- and long-term), and trading based on whether the short-term MA is below or above the long-term MA.

I’ll explain the code in a minute!

```import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import requests

# Get Bitcoin Price Data
URL = 'https://www.alphavantage.co/query?function=DIGITAL_CURRENCY_DAILY&symbol=BTC&market=USD&apikey=APIKEY'
response = requests.get(URL)
data = response.json()

daily_data = data["Time Series (Digital Currency Daily)"]

# Convert JSON to DataFrame
df = pd.DataFrame(daily_data)
df = df.T

# Create two Moving Averages
MA1 = 20
MA2 = 50
df['MA1'] = df['1a. open (USD)'].rolling(MA1).mean()
df['MA2'] = df['1a. open (USD)'].rolling(MA2).mean()

# Initialize variables
position = 0
my_usd = 10000
my_btc = 0

print('Initial balance:', str(my_usd), 'USD')

# Backtest Algorithm
for i in range(len(df)):

# Get price
price = float(df['1a. open (USD)'].iloc[i])

if df['MA1'].iloc[i] > df['MA2'].iloc[i] and position == 0:
position = 1
my_btc = price / my_usd
my_usd = 0
# Sell position
elif df['MA1'].iloc[i] < df['MA2'].iloc[i] and position == 1:
position = 0
my_usd = price * my_btc
my_btc = 0
print('Selling at', price, 'on', df.index[i])

print('Final balance:', str(my_usd + my_btc * price))

initial_btc = float(df['1a. open (USD)'].iloc[0]) / 10000
value_today = initial_btc * float(df['1a. open (USD)'].iloc[-1])
print('Final balance (buy and hold):', str(value_today))
```

## Code Explanation

This code implements the algorithm described above.

The first portion of the code is getting the daily Bitcoin price data from the API and converting it into a DataFrame.

Next, the code creates two moving averages, `MA1` and `MA2`, based on the open price of Bitcoin. Then, the code initializes the position variable to 0.

The backtest algorithm then runs a loop to iterate through the DataFrame to identify when conditions are met to buy or sell. If the shorter-term `MA1` is higher than the longer-term `MA2`, the code will enter a buy position.

Similarly, if the shorter-term `MA1` is lower than the longer-term `MA2`, the code will enter a sell position. We don’t assume short selling so “selling” on an empty position just means waiting for the next buy opportunity.

Finally, if the `MA1` and `MA2` cross, the code will close any existing position and reverse the trading direction.

## Backtesting the Strategy

Let’s have a look at an example run — note to read this from bottom to top! π

```Initial balance: 10000 USD
Selling at 18809.13 on 2022-09-26
Selling at 19331.28 on 2022-07-13
Selling at 41941.7 on 2022-03-10
Selling at 36660.35 on 2022-01-25
Selling at 57471.35 on 2021-10-12
Selling at 44572.54 on 2021-08-08
Selling at 57351.56 on 2021-03-22
Selling at 56900.74 on 2021-03-17