Programming a crypto-trading bot is a great way to start trading algorithmically. This post will outline how to program your own simple bot by interfacing with the Bittrex API.
For this guide you will need Python 3 installed, and a competent text editor. This post will not cover the basics of programming, as there are hundreds of resources that already cover that angle. If you have any questions feel free to comment below.
To begin, you will need an API key from Bittrex. Login to your account, and then head to the settings page. Click on the API Keys section, and then create a new one. If you have 2FA enabled, you will need to enter your key before creating it.
Now that we have our key, let's create our bot. The architecture will be very simple. The bot will run indefinitely and query for markets every 30 seconds. Using our simple algorithm the bot will open buy / sell positions. The resulting bot will be extremely dumb, but this guide should serve as a base for you to develop your own trading algorithm.
Begin with a fresh Python file, and the contents from below. Make sure to adjust the API_KEY and API_SECRET_KEY values.
import time
import requests
import hashlib
import hmac
TICK_INTERVAL = 60 # seconds
API_KEY = 'my-api-key'
API_SECRET_KEY = b'my-api-secret-key'
def main():
print('Starting trader bot, ticking every ' + str(TICK_INTERVAL) + 'seconds')
def format_float(f):
return "%.8f" % f
if __name__ == "__main__":
main()
Running the program now won't do much. The print statement will execute, and we will see some text in the console, but the program will exit immediately after. Most bots run indefinitely until terminated by the operator. Let's setup our bot to do the same. Update the main() method with the following changes, and also add the new tick() method stub.
def main():
print('Starting trader bot, ticking every ' + str(TICK_INTERVAL) + 'seconds')
while True:
start = time.time()
tick()
end = time.time()
# Sleep the thread if needed
if end - start < TICK_INTERVAL:
time.sleep(TICK_INTERVAL - (end - start))
def tick():
pass
Now our bot will run it's tick method every 30 seconds while accounting for any latency in the tick method itself. Next we need to flesh out the tick method. This is where most of the program logic will live.
def tick():
print('Running routine')
market_summaries = simple_reqest('https://bittrex.com/api/v1.1/public/getmarketsummaries')
for summary in market_summaries['result']:
market = summary['MarketName']
day_close = summary['PrevDay']
last = summary['Last']
percent_chg = ((last / day_close) - 1) * 100
print(market + ' changed ' + str(percent_chg))
def simple_reqest(url):
r = requests.get(url)
return r.json()
Now if you run the program you'll see that the bot queries all of the available markets on Bittrex and then prints the percentage the market has changed over the last 24 hours. We've also added the simple_request() method which dispatches an HTTP request and then converts the response to JSON.
Our bot is cool and all, but it doesn't actually trade any crypto yet. Let's flesh out our advanced algorithm to place buy and sell orders. We'll need a few things including a way to make signed requests which the Bittrex API expects when making trades.
def tick():
print('Running routine')
market_summaries = simple_reqest('https://bittrex.com/api/v1.1/public/getmarketsummaries')
for summary in market_summaries['result']:
market = summary['MarketName']
day_close = summary['PrevDay']
last = summary['Last']
percent_chg = ((last / day_close) - 1) * 100
print(market + ' changed ' + str(percent_chg))
if 40 < percent_chg < 60:
# Fomo strikes! Let's buy some
print('Purchasing 5 units of ' + market + ' for ' + str(format_float(last)))
res = buy_limit(market, 5, last)
print(res)
if percent_chg < -20:
# Ship is sinking, get out!
sell_limit(market, 5, last)
def buy_limit(market, quantity, rate):
url = 'https://bittrex.com/api/v1.1/market/buylimit?apikey=' + API_KEY + '&market=' + market + '&quantity=' + str(quantity) + '&rate=' + format_float(rate)
return signed_request(url)
def sell_limit(market, quantity, rate):
url = 'https://bittrex.com/api/v1.1/market/selllimit?apikey=' + API_KEY + '&market=' + market + '&quantity=' + str(quantity) + '&rate=' + format_float(rate)
return signed_request(url)
def signed_request(url):
now = time.time()
url += '&nonce=' + str(now)
signed = hmac.new(API_SECRET_KEY, url.encode('utf-8'), hashlib.sha512).hexdigest()
headers = {'apisign': signed}
r = requests.get(url, headers=headers)
return r.json()
There's quite a bit going on here. Let's break it down. The new logic in our tick() method includes the meat of our algorithm.
if 40 < percent_chg < 60:
# Fomo strikes! Let's buy some
print('Purchasing 5 units of ' + market + ' for ' + str(format_float(last)))
res = buy_limit(market, 5, last)
print(res)
if percent_chg < -20:
# Ship is sinking, get out!
sell_limit(market, 5, last)
As you can see, this algorithm is extremely stupid. This bot trades based only on the 24 hour change of a coin. Despite this silly example, it should serve as a gateway for you to begin fleshing out your own secret algorithm.
We've also added some new methods to handle placing buy and sell orders. These methods require an API key because they modify aspects of your account. The final method we added, signed_request(), is needed to send a valid request to Bittrex. The specifics of this are outlined in the Bittrex developer's guide online.
I hope this guide helps you on your way to riches! Feel free to ask for help in the comments if you get lost or stuck.