Trading Haute Fréquence et Arbitrage Cryptos en Python

Le Trading Haute Fréquence c'est quoi ?

Si l'on devait donner une définition du trading haute fréquence cela pourrait être :

Le Trading Haute Fréquence consiste en l'analyse du carnet d'ordre par un algorithme afin de tirer des profits. Ces profits sont souvent générés grâce à des achats et ventes très rapides afin de profiter d'opportunité de marché.

L'article ci-dessous est en lien étroit avec une vidéo YouTube que vous pourrez trouver ici

Pour comprendre le Trading Haute fréquence il est donc indispensable de comprendre le carnet d'ordre ainsi que les notions de "bids" et "asks".

Pour rappel le carnet d'ordre répertorie les ordres d'achats et de ventes d'un actif. Lorsqu'un ordre d'achat et de vente ont le même prix une transaction est réalisée.

Le "Bid Price" est le prix le prix le plus haut qu'un acheteur est prêt à payer.

Le "Ask Price" est le prix le plus bas qu'un vendeur est prêt à recevoir en l'échange de son actif. Vous trouverez ci-dessous l'exemple d'un carnet d'ordre. On voit ici que le "Bid Price" est de 19 084 USD et le "Ask Price" de 19 085 USD et le prix de l'actif se situe donc à la frontière entre ces 2 prix.

Comment faire du Trading Haute Fréquence sur les cryptos ?

La première étape sera forcément de récupérer le carnet d'ordre sur un échangeur comme KuCoin ou bien Binance, mais surtout de le récupérer très régulièrement (plusieurs fois par seconde). Ensuite il faudra décider comment en tirer profit. Pour cette article nous allons essayer de faire de l'arbitrage entre les différents échangeurs.

Je ne vais pas détailler en quoi consiste l'arbitrage mais je vais vous donner un exemple concret. Imaginons que le prix du Bitcoin sur Binance soit 26k USD et que sur KuCoin il soit de 27k USD. Dans ce cas on pourrait acheter 1 Bitcoin sur Binance à 26k USD, le transférer sur KuCoin puis le vendre à 27k USD. On aura ici réalisé un bénéfice de 1k USD sans prendre de risque c'est un arbitrage.

Nous allons donc faire un code en python capable de repérer ce genre d'opportunité. Cependant je vous préviens d'avance l'opportunité que j'ai cité ci-dessus n'arrivera jamais.

Code Arbitrage Cryptos en Python

Dans ce code nous allons essayer de récupérer en continu le carnet d'ordre sur les exchanges Binance, KuCoin et Okx. Pour cela nous allons utiliser la librairie CCXT PRO qui depuis peu est totalement gratuite. Cette librairie va nous permettre de nous connecter aux différents échangeurs sans difficultés.

Pour pouvoir exécuter ce code vous aurez donc besoin d'avoir installé Python puis la librairie CCXT grâce à la commande

pip install ccxt

Ensuite vous trouverez le code à exécuter ci-dessous

import ccxt.pro
from asyncio import gather, run
import random

global last_binance_price
global last_okx_price
global bid_prices
global ask_prices

bid_prices = {}
ask_prices = {}

async def symbol_loop(exchange, symbol):
    global bid_prices
    global ask_prices
    print("Starting the", exchange.id, "symbol loop with", symbol)
    while True:
        try:
            orderbook = await exchange.watch_order_book(symbol)
            now = exchange.milliseconds()
            bid_prices[exchange.id] = orderbook["bids"][0][0]
            ask_prices[exchange.id] = orderbook["asks"][0][0]
            min_ask_ex = min(ask_prices, key=ask_prices.get)
            max_bid_ex = max(bid_prices, key=bid_prices.get)
            min_ask_price = ask_prices[min_ask_ex]
            max_bid_price = bid_prices[max_bid_ex]
            best_diff = max_bid_price - min_ask_price
            best_diff_pct = ((max_bid_price - min_ask_price) / min_ask_price) * 100
            if best_diff_pct > -1:
                # print(exchange.iso8601(now), "Bid prices :", bid_prices)
                # print(exchange.iso8601(now), "Ask prices :", ask_prices)
                print(
                    f"{exchange.iso8601(now)}: Buy BTC/USDT on {min_ask_ex} ({min_ask_price}$), Sell BTC/USDT on {max_bid_ex} ({max_bid_price}$), Theorical profit + {round(best_diff_pct, 2)} %"
                )
        except Exception as e:
            print(str(e))
            break  # you can break just this one loop if it fails

async def exchange_loop(exchange_id, symbols):
    print("Starting the", exchange_id, "exchange loop with", symbols)
    exchange = getattr(ccxt.pro, exchange_id)()
    loops = [symbol_loop(exchange, symbol) for symbol in symbols]
    await gather(*loops)
    await exchange.close()

async def main():
    exchanges = {
        "okex": ["BTC/USDT"],
        "kucoin": ["BTC/USDT"],
        "binance": ["BTC/USDT"],
        "ftx": ["BTC/USD"],
    }
    loops = [
        exchange_loop(exchange_id, symbols)
        for exchange_id, symbols in exchanges.items()
    ]
    await gather(*loops)

run(main())

Pour exécuter ce code il vous suffira ensuite de taper la commande:

python nom_de_votre_fichier.py

Ce script va récupérer en continu les carnets d'ordres des différents échangeurs afin d'avoir le "Bid Price" et le "Ask Price".

A partir de là on va regarder le "Bid Price" le plus haut et le "Ask Price" le plus bas. On va le comparer entre les échangeurs et faire la différence entre ces 2 prix et obtenir le résultat en pourcentage.

Le code va donc nous remonter le meilleur endroit pour acheter et vendre notre Bitcoin.

Le profit indiqué montre le bénéfice si l'on fait un achat sur l'échangeur qui a le prix plus bas et une vente sur l'échangeur qui a le prix le plus haut. Dans l'exemple ci-dessus le code nous conseille d'acheter notre Bitcoin sur Binance à 19044.6 USD et de le vendre sur Okex à 19048.8 USD.

Malheureusement cela ne fait qu'un profit de 0.02% ce qui en général ne couvrira pas vos frais. Vous pouvez notamment réduire vos frais en vous inscrivant via les images ci-dessous.

Conclusion sur Arbitrage et Haute Fréquence

Je vous ai présenté dans cet article un moyen de faire du trading haute fréquence en cryptos en essayant de détecter des opportunités d'arbitrage.

L'arbitrage est très concurrentiel et les opportunités sont très rares vous pourrez le remarquer en exécutant le code présenté. Le code ne permet que de repérer les opportunités actuellement mais pas de les prendre. Si vous maîtrisez Python et CCXT vous n'aurez pas de mal à transformer le code. Et ainsi par exemple si l'on détecte une opportunité de +0.2% d'acheter sur un échangeur et vendre sur un autre. Le code vous permettra de faire de nombreuses analyses sur le carnet d'ordre des différents échangeurs cryptos.

En espérant que cet article vous ait plu.