⚠️ Important Note
I am not qualified to offer investment, legal, or any other advice, nor am I trying to do so. This is a programming tutorial aimed at teaching you how to build a trading bot for learning purposes. Any decisions, investments, or risks you take as a result of building a trading bot are your responsibility.
I cannot be held responsible for any decisions you make as a result of reading this tutorial. Remember: Bots can lose a lot of money, so you should be careful.
Quite regularly, we all come across some variation of this article: “10 Projects You Should Build as a Programmer”.
And most times that list includes a Trading Bot.
So, since I think trading bots are great projects, I thought I’d take some time to teach you how to build one.
However, rather than giving you all the code line by line, I decided it would be best to go through all the concepts you should be familiar with to take on this project.
After all, the whole point is that you code it yourself.
Hence, this article will go through everything you need to know and have to build a trading bot (from the exchange to a simple trading strategy), as well as the basic architecture, concepts, and design of a simple bot.
And the great thing is: I’ll be using pseudocode, so you can follow this tutorial in the language of your choice.
As such, you can feel comfortable and focus on the actual programming, rather than figuring out all the setup for yourself.
So let’s go!
Step 1: Pick a Weapon
The first step in this tutorial is just selecting a language to use. This is entirely up to you.
Some languages like Python could be helpful if you want to later expand your bot to use Machine Learning, for example, but the main goal here is that you pick a language you’re comfortable with.
Step 2: Pick a Battleground
Want to read this story later? Save it in Journal.
An often overlooked step in trading bot tutorials is the selection of the exchange.
For a trading bot to work, you need to have access to an exchange where you can trade assets. This is just as important as knowing how to program.
So, for this step, you need to decide what assets you will be trading (e.g. stocks, currencies, cryptocurrencies), and where you will be trading.
Regarding the asset, I would strongly suggest cryptocurrencies. The reason for this is not that I’m a blockchain/crypto advocate (full disclosure), but simply because cryptocurrency markets operate 24/7 i.e. all day, every day.
Most “traditional” assets can only be traded during certain times, and often only on weekdays. Stock markets, for instance, are generally open sometime between 9AM-4PM and do not operate on weekends. FOREX (foreign currency exchange) markets can go on for 24h, but are also usually closed during the weekend.
As such, it is easier and nicer to have your bot running 24/7, which is what crypto markets allow for. Additionally, cryptocurrencies are known to be very volatile, which means that a) you can lose a lot of money, but b) they are a great way to learn and test trading strategies.
Since we’ve covered the asset class, let’s now go over the two requirements for picking an exchange for your trading bot.
- You must be legally allowed to trade on the exchange and the assets it offers. Some countries don’t allow cryptocurrency trading, for instance.
- The exchange must have a Public API available. One cannot build a bot without an endpoint to send requests to.
With the two requirements above fulfilled, you may also wish to consider things like the fees charged by the exchange, if it is well-rated or well-known, and how good the API docs are.
Last but not least, I would also recommend checking the daily volume of trades on the exchange. Exchanges with very low volumes tend to lag behind in price movements, as well as make it harder for limit orders to be filled (more on this terminology later).
If you decide to go with cryptocurrencies as your asset class, here’s a useful list of the top exchanges, their volumes, and various other important pieces of information to help you choose.
Step 3: Pick a Base
If the exchange is the battleground, you need a place to ship your troops from. And I need to stop with this stupid analogy.
What I’m talking about is a server. You need a server to send requests to the exchange’s API.
For testing purposes, you can obviously run the server from your own computer. However, if you want your bot to be operating constantly, your computer is definitely not a good choice.
Hence, I have two suggestions:
- Use a Raspberry Pi as a server (Cooler)
- Use a Cloud Provider (Better)
I think running a bot from your Pi is a pretty cool idea, so you should try it if it also sounds nice to you.
Most large cloud service providers offer a good free tier, so you might even be able to host your bot for free.
Regarding servers, I’ll just leave it at that. You should pick whatever suits you best, and, for a small project like this, the choice shouldn’t make much of a difference.
Step 4: Building the Bot!
Now we’re getting to the fun part. Ensure that before you come to this step you have:
- Registered and been approved to use an exchange
- Enabled API usage on the exchange and have an API key
- Decided how you will be hosting your bot
Got that? Alright, let’s move on.
The Simplest of Bots
My goal here is to get you from zero to bot in a simple and concise way. As such, I’ll be teaching you how to build a simple trading bot, which you can then expand and improve to suit your needs.
This bot will have a few constraints:
- The bot will only ever be in one of two states: BUY or SELL. It will not place various buy or sell orders consecutively at multiple price points. If its last operation was a sale, it will try to buy next.
- It will use fixed thresholds for buying and selling. A smarter bot might be able to tinker with the thresholds based on various indicators, but our bot will have its strategy and thresholds set manually.
- It will only trade one currency pair e.g. BTC/USD.
The constraints come with benefits, however. Keeping it simple makes the bot easier to create and maintain, as well as allows us to deploy this very quickly.
Here’s a simple diagram providing an overview of how our bot will operate:
From here, we can start to determine what our architecture will look like.
First, we need a variable to indicate the state the Bot is currently in. This is either BUY or SELL. A boolean or enum should fit this purpose well.
Then we need to set our thresholds for buying and selling. These indicate the percentage decrease or increase in price since we last made an operation.
For example, if I bought the asset at 100$, and its price is now at 102$, we have a 2% increase. If we have a SELL threshold set to a 1% increase, our bot will then sell, because it has made a profit above our threshold.
In our case, these thresholds will be constants. We need 4 of them, two for each state:
BUY Thresholds (If the Bot is in SELL State)
DIP_THRESHOLD: Buys the asset if its price decreased by more than the threshold. The idea of this is to follow the “buy low, sell high” strategy, where you attempt to buy an asset when it is undervalued, expecting its value to rise so you can sell.
UPWARD_TREND_THRESHOLD: Buys the asset if its price increased by more than the threshold. This goes against the “buy low, sell high” philosophy, but aims to identify when the price is going up and we don’t want to miss an opportunity to buy before it goes even higher.
Here’s an illustration that might help:
If we performed a SELL operation at the point marked “SELL” in the picture above, we now have our thresholds set for the buy operation.
If the price ever goes below the bottom green line or above the top green line we will perform a BUY operation. In this case, we surpassed the upper threshold first, so we bought based on the
SELL Thresholds (If the Bot is in BUY State)
PROFIT_THRESHOLD: Sells the asset if its price has increased above the threshold since we bought it. This is how we profit. We sell at a higher price than we bought.
STOP_LOSS_THRESHOLD: Ideally, we would only want our bot to sell when it makes a profit. However, maybe the market is just going down significantly and we want to get out before it’s too late and then buy at a lower price. Therefore, this threshold is used to sell at a loss, but with the goal of stopping a bigger loss from happening.
Here’s an illustration:
Here, we bought at the point marked with “BUY”. Then, we met our upper threshold before the lower one, meaning we sold our asset for a profit. This is how trading bots make money.
Now we already have a basic idea of how the bot works, so let’s get into some (pseudo)code.
API Helper Functions
The first thing our bot needs are some helper functions to get data from the exchange’s API. We need:
The above should be self-explanatory, but you need to make sure you are aware of what currencies the API
POSTrequests ask for when doing a buy or sell operation.
Often times, when you are trading USD for Gold, for example, you can specify either how much Gold to buy, or how much USD to sell. Getting the currencies right is very important.
Bot Loop Cycle
Now that we have our helper functions, let’s start to define the workflow of the bot. The first thing we need is an infinite loop with some sleep time. Let’s say we want the bot to try to make an operation every 30 seconds. Here’s what that might look like:
Then, let’s set the variables and constants we talked about, as well as the decision-making flow. API helper functions aside, our code would end up something like this:
Note: The values for the thresholds here are just arbitrary values. You should pick your own according to your own strategy.
If the above is paired up with the helper functions and the loop function, which could also be
main , we should now have ourselves the basic pillars of a working bot.
At every iteration, our bot will check its current state (BUY or SELL) and attempt to make a trade based on the thresholds hardcoded in. It will then update the BUY/SELL state and the last price for an operation.
Then it does it all over again.
Step 5: Polishing the Bot
The basic architecture of our bot is ready, but there’s probably a few things we may still want to consider adding.
When I first built a variation of this bot, one thing that was essential for me was having constant logging of the bot’s actions both to the terminal as well as to a separate log file.
At every step, I would create logs like:
[BALANCE] USD Balance = 22.15$
[BUY] Bought 0.002 BTC for 22.15 USD
[PRICE] Last Operation Price updated to 11,171.40 (BTC/USD)
[ERROR] Could not perform SELL operation - Insufficient balance
The logs that went to the file would also get a timestamp added to them, so when I accessed the server after a whole day and found an error, for example, I could trace it back exactly to where it happened, as well as find out everything else the bot did along the way.
This should be a matter of setting up a
createLog function that is called at every step. Something like this:
The main goal of our bot should be to buy at a low price and sell at a profit. However, we have two thresholds that kind of contradict this idea:
These thresholds supposedly tell us when we should sell at a loss or buy at a price increase. The idea is that we try to identify trends that fall outside of the general strategy but may be harmful or beneficial to us so we should act.
However, the way I structured it above is quite limited. A static snapshot of a price is far from an indication of a trend.
Luckily, without much hassle, you can make this a little more reliable.
All you need to do is also keep track of more prices than just
lastOpPrice . You could, for instance, keep track of price 10 or 20 iterations ago, and compare that with the current price instead of
lastOpPrice . This would probably be better at identifying a trend because it checks for rapid shifts in price rather than a shift that occurred over a long period of time.
While it is running, this simple bot doesn’t actually need a database, since it is handling very little data and can keep all the information in memory.
However, what happens when the bot fails, for example? How could it determine the
lastOpPrice without you checking it manually?
To prevent manual work on your end, you might want to keep some sort of lightweight database to keep track of a few things, like
This way, when the bot starts up, rather than using the default values, it will actually check its stored values and continue from there.
Depending on how simple you want to make this, you can even consider a “database” of
json files, since you might just be storing a few values anyway.
If you want to facilitate the visualization of your bot’s operations, as well as manage it without having to go in and manually tinker with the code, you may want to consider connecting your bot to a dashboard.
This would require that your bot be connected to a web server/API of its own that allows you to control its functionality.
This way, you could change thresholds more easily, for example.
Testing Strategies on Past Data
Many exchanges will offer you access to past price data, as well as you can usually easily get that data elsewhere if you need to.
This is very useful if you want to test your strategy before putting it to action. You can run a simulation of your bot with past data and “fake money” to see how well your defined thresholds would have worked and adjust them for the real deal.
Additional Points on Thresholds and Orders
There are a few things you need to watch out for when placing orders.
First, you should understand that there are two types of orders: limit orders and market orders. You should really read a little into this if you’re not familiar with the concepts, but I’ll give you a basic overview here.
Market orders are orders that execute at the current market price, effectively executing immediately in most cases.
Limit orders, on the other hand, happen when you place an order for a price lower than market price (in the case of a BUY order) or higher than market price (in the case of a SELL order). These are not guaranteed to execute, since the price might not reach the threshold you set.
The benefit of limit orders is that you can anticipate market movements and place an order regarding where you expect the market to go before such movement happens.
In addition, limit orders are usually subject to lower fees than market orders. This is because market orders are subject to what is commonly called a “taker fee” whereas limit orders are subject to “maker fees”.
The reason for the names and their respective fees is that market orders are just accepting (“taking”) the current market price, whereas limit orders outside the market price are adding liquidity and hence “making a market”, for which they are “rewarded” with lower fees.
Note that the bot in this article is best suited for market orders.
Lastly, on the topic of fees, when setting your
PROFIT_THRESHOLD , remember to take fees into consideration.
In order to make a profit, you need to perform a BUY and then a SELL operation, which leaves you subject to 2 fees.
As such, you need to make sure that you only sell for a profit once you’re able to at least cover your fees, otherwise you will actually be making a loss.
Think about it, assuming fees were flat, if you bought an asset for 100.00$, incurring a 0.50$ fee, and then sold it for 100.75$, again with a 0.50$ fee, you would have made a gross profit of 0.75%, but, in actuality, you would have a net loss of 0.25%.
Now imagine your bot was always selling for a net loss. You’d lose a lot of money rather quickly…
That’s it for our bot. I hope this tutorial was useful.
The idea was to focus on all the concepts you need to know to build a trading bot even if you’ve never traded before, not teach you how to program.
The assumption is that all readers are able to do HTTP requests in their language of choice, so it would be best to focus on other aspects.
It is the first tutorial I ever write like this (pseudocode-based), so please do let me know what you thought of the concept.
Thanks for reading! And if you think this article was useful, feel free to support me with some claps 👏👏.