This project contains two bots I use for automated cryptocurrency trading on Binance. I built the bots on top of the Freqtrade library.

To use the project in your development machine, clone it, and go to the project's root:

git clone https://github.com/wanderindev/crypto-bot.git
cd crypto-bot

In the user_data directory, you will find a config.json.example file. This file contains the bots' configuration. Rename the file to config.json.

mv user_data/config.json.example user_data/config.json

You will be adding secret keys to this file so make sure it is kept out of version control by adding user_data/config.json to the .gitignore file.

There are many configuration options for the bot. Visit the configuration page in the Freqtrade documentation to get familiar with them and adjust the config.json file as per your needs and goals for your bots.

Below, I discuss a few of these options.

The dry_run option in line 8 controls whether the bots uses real money or fake money while trading. It is useful for testing your strategy against real market conditions without risking real money. If set totrue, the bots will use fake money. When you are ready to run the bots in production, change this option to false.

The dry_run_wallet in line 9 controls the balance available to the bots during backtesting and hyperoptimization. The default is 1,000. Set it to the balance you plan to risk in production to get accurate results from the backtesting.

The exchange option in line 35 controls where the bots will be trading. In my case, I set it to binance but you can set it to any of the supported exchanges.

For the bots to connect to the exchange, you need to add a public and private key to lines 37 and 38 in config.json. In the case of Binance, you can create API keys at API Management under your user. Make sure that the Enable Withdrawals option is not checked for your new API keys.

The stake_currency option in line 3 controls the currency the bot will use for trading. I set it to USDT but you can use any currency supported by your exchange.

The pair_whitelist option in line 43 tells the bots which assets they can buy and sell. All pairs must be quoted in the stake currency (in my case, USDT). My config include 50 pairs. I selected those pairs based on trading volume, excluding stable coins and meme coins/tokens.

There are several options that control how much stake the bots can risk while trading. Review the documentation to get familiar with them. In my case, I'm using a static stake of $2,475 USDT per bot. This stake comes from 33 max_open_trades (line 2) times $75 USDT stake_amount (line 4).

The timeframe option in line 7 controls the ticker interval. I set it to 1h. You can use any interval available at your exchange.

You can control your bots remotely using Telegram. This is extremely convenient. To enable it, you must add a Telegram token and chat id to lines 130 and 131. Clear instructions on how to set this up are available in the documentation.

To test and optimize your strategies, you need historical data. The user_data/data/binance directory contains data for all 50 pairs at 1 hour intervals from Jan. 1st, 2021 to Jun. 20, 2021.

If your exchange, stake currency, or pairs are different from mine or if you want to test against data from other time period, you should download new data.

Add a directory for your exchange to the user_data/data directory and include in it a pairs.json file similar user_data/data/binance/pairs.json.

Then download the data buy running:

docker-compose run --rm freqtrade download-data --exchange binance -t 1h --timerange=20210101-20210620

Make sure to replace binance with the name of your exchange, 1h with your timeframe, and 20210101-20210620 with the range of dates for which the data should be downloaded.

The user_data/strategies directory contains the strategies. In my case, there are three strategies:

This strategy was the starting point. It is based in two technical analysis indicators:

• the Relative Strength Index, and
• the Bollinger Bands.

This strategy sets sensible defaults for RSI and BB for the buy and sell spaces, as well as ranges of values hyperopt will use while searching for optimal results.

This strategy is based on the naive strategy, but the parameters were optimized against the ShortTradeDurHyperOptLoss loss function by running 20 hyperopt sets of 1000 epochs each for the default spaces:

docker-compose run --rm freqtrade hyperopt --config user_data/config.json --hyperopt-loss ShortTradeDurHyperOptLoss --strategy BBRSIStrategy1hShortTradeDur -i 1h --timerange=20210524-20210620 --epochs 1000

Once the optimized parameters were introduced into the strategy, I ran another 5 hyperopt sets of 1000 epoch each for the trailing space:

docker-compose run --rm freqtrade hyperopt --config user_data/config.json --hyperopt-loss ShortTradeDurHyperOptLoss --strategy BBRSIStrategy1hShortTradeDur -i 1h --timerange=20210524-20210620 --epochs 1000 --spaces trailing

The best result from these runs were also introduced into the strategy.

This strategy is based on the naive strategy, but the parameters were optimized against the SortinoHyperOptLoss loss function by running 20 hyperopt sets of 1000 epochs each for the default spaces:

docker-compose run --rm freqtrade hyperopt --config user_data/config.json --hyperopt-loss SortinoHyperOptLoss --strategy BBRSIStrategy1hSortino -i 1h --timerange=20210524-20210620 --epochs 1000

Once the optimized parameters were introduced into the strategy, I ran another 5 hyperopt sets of 1000 epoch each for the trailing space:

docker-compose run --rm freqtrade hyperopt --config user_data/config.json --hyperopt-loss SortinoHyperOptLoss --strategy BBRSIStrategy1hSortino -i 1h --timerange=20210524-20210620 --epochs 1000 --spaces trailing

The best result from these runs were also introduced into the strategy.

You should get familiar with the Hyperopt documentation.

Running the hyperopt takes a long time. When I first try to run it in my laptop, I notice it was only using 2 cores and the 1000 epoch run would take about 10 hours. Making 50 runs (25 for each loss function) would take about 500 hours.

I'm not sure why it only used 2 cores. Maybe is a limitation of running Ubuntu on Windows Subsystem for Linux.

To get it done quicker, I created 10 droplets at DigitalOcean with 64GB of RAM and 32CPUs each and ran the hyperopts in parallel there. All 50 runs were done in roughly 1 hour and 15 minutes including the time use for creating the droplets and cloning the repo in each droplet. The total cost was about $12 but I saved about 499 hours of running time.

If you are going to do this, make sure you use the Docker Marketplace app to ensure your droplets are created with Docker, docker-compose, and git installed.

Also, make sure you destroy your droplets as soon as hyperopt is done. Each of those droplets cost $640 a month, so you don't want to have them idle.

After optimizing the strategies' parameters, I ran backtests for each strategy to make sure I got results consistent with the hyperopt results.

To backtest the Short Trade Duration optimized strategy run:

docker-compose run --rm freqtrade backtesting --datadir user_data/data/binance --export trades -s BBRSIStrategy1hShortTradeDur -i 1h --timerange=20210524-20210620

This strategy produced a 10.23% profit in 28 days:

To backtest the Sortino optimized strategy run:

docker-compose run --rm freqtrade backtesting --datadir user_data/data/binance --export trades -s BBRSIStrategy1hSortino -i 1h --timerange=20210524-20210620

This strategy produced a 6.85% profit in 28 days:

Once happy with the optimized strategies, it's time to deploy the bots to production. You can deploy either bot or both. The Sortino optimized bot give a lower return with almost no volatility. The Short Trade Duration optimized bot provides better returns but greater volatility. I decided to deploy both balance returns and volatility.

To deploy de bots, I created a 4GB/2CPU droplet in DigitalOcean with a 10GB block storage volume for persistence using the Docker Marketplace app. The monthly cost for this droplet is $25. You could try using a cheaper droplet but the Freqtrade documentation recommends deploying to a 2CPU machine.

I create the droplet in the San Francisco datacenter because it gave me the lowest latency (less than 1ms) to the Binance API servers (https://api.binance.com).

Once the droplet is created, ssh into it, go to the block storage volume, create a directory for the first bot, cd into it, and clone the repository:

cd /mnt/volume-sfo3-01
mkdir bbrsi_1h_sortino
cd bbrsi_1h_sortino
git clone https://github.com/wanderindev/crypto-bot.git .

Open the docker-compose.yml file:

sudo vi docker-compose.yml

and make sure the container name (line 14) is set to bbrsi_1h_sortino and the strategy is set to BBRSIStrategy1hSortino. Save and exit.

Rename config.json.example to config.json:

mv user_data/config.json.example user_data/config.json

Open the config.json file:

sudo vi user_data/config.json

Set the dry_run (line 8) to false, enter your Binance API keys (lines 37 and 38), and your Telegram bot token and chat id (lines 130 and 131). Save and exit.

The bot will need permissions to write to the logs file:

sudo chmod a+rwx user_data/logs/freqtrade.log

Start the bot:

docker-compose up -d

You should start receiving messages from the bot in your Telegram.

If you wish to also deploy the Short Trade Duration bot, repeat the instructions above, replacing sortino with shorttradedur where appropriate. Also, create another Telegram bot and use the new token to control this bot. That way you can control each bot separately.

If you need to debug, take a look at the bot's logs:

docker-compose logs -f

Fix any issues and restart the bot.

👤 Javier Feliu

• Twitter: @JavierFeliuA
• Blog: Wander In Dev
• Github: @wanderindev

Give a ⭐️ if this project helped you!

This project is MIT licensed.

This README was generated with ❤️ by readme-md-generator