Comment obtenir des données historiques de crypto-monnaie

Téléchargement de données OHLC à résolution minute via des API d'échange

MISE À JOUR:

En raison de l'intérêt général pour cette question, j'ai créé un ensemble de données comprenant toutes les données OHLC de l'API d'échange Bitfinex et l'ai téléchargé en tant qu'ensemble de données public sur Kaggle.

introduction

Le trading algorithmique est un moyen populaire de s'attaquer à l'environnement rapide et volatil des marchés des crypto-monnaies. Cependant, la mise en œuvre d'une stratégie de trading automatisée est difficile et nécessite beaucoup de backtesting, qui à son tour nécessite beaucoup de données historiques. Bien qu'il existe plusieurs sources disponibles qui fournissent des données historiques sur les crypto-monnaies, la plupart d'entre elles présentent des inconvénients. Soit ils sont chers, ne fournissent que des données à faible résolution temporelle (quotidiennement) ou couvrent des périodes limitées d'un nombre limité de paires de devises. Ici, nous verrons que l'obtention de données historiques ouvertes, hautes, basses et fermées (OHLC) à une résolution d'une minute n'est en fait pas une tâche magique et peut être effectuée gratuitement en quelques lignes de code Python.

Connexion à l'échange

Dans ce didacticiel, nous utiliserons l'API d'échange Bitfinex pour récupérer des données historiques. Cependant, l'approche devrait également fonctionner pour tout autre échange qui fournit une API similaire. De plus, vous n'avez pas besoin d'un compte Bitfinex pour que ce code fonctionne, car nous n'utiliserons que des points de terminaison d'API publics. Dans le cas où vous ne savez pas ce qu'est une API ou comment l'utiliser, je vous suggère de lire la documentation de l'API Bitfinex, après tout, c'est également l'interface par laquelle votre algorithme interagira plus tard avec l'échange. Mais ne vous inquiétez pas, vous n'aurez pas besoin d'écrire vous-même l'interface Python pour l'API Bitfinex. Il existe déjà plusieurs implémentations disponibles, dont l'une est ce client ici. L'installation la plus simple se fait via pip:

>>> pip installer bitfinex-tencars

Alternativement, si Git est installé, vous pouvez simplement exécuter les commandes ci-dessous pour installer le client. N'oubliez pas de remplacer par votre dossier cible.

>>> git clone https://github.com/akcarsten/bitfinex_api.git 
>>> python  /setup.py install

Si Git n'est pas installé, vous pouvez cloner le référentiel sur la page GitHub, puis accédez au dossier dans lequel vous l'avez cloné et exécutez:

>>> installation de python setup.py

Dans les deux cas, le client Bitfinex sera installé sur votre distribution Python.

Utilisation du client API

Si vous regardez la documentation de l'API Bitfinex, vous verrez qu'il existe deux versions d'API, v1 et v2, les deux sont implémentées dans le client que vous venez d'installer, mais ici nous n'utiliserons que l'API v2. Ainsi, après avoir importé le client Bitfinex API, nous devons créer une instance de l'API v2 en exécutant le code ci-dessous. Notez que nous ne fournissons aucune clé ici, nous n'aurons donc accès qu'aux points de terminaison publics, un message correspondant sera affiché après l'exécution du code.

>>> importer bitfinex
 
>>> # Créer une instance api de l'API v2
>>> api_v2 = bitfinex.bitfinex_v2.api_v2 ()

Et c'est notre porte d'accès aux données. De la documentation, nous savons que l'un des points de terminaison publics est appelé bougies qui renvoie les données derrière les graphiques en chandeliers que vous voyez sur tous les échanges. Ce type de données contient les informations suivantes, un horodatage du prix ouvert, fermé, haut et bas et le volume des échanges. Elles sont également appelées données OHLC. Le moyen le plus simple d'interagir avec ce point de terminaison via le client est de simplement l'appeler avec ses paramètres par défaut.

>>> result = api_v2.candles ()

La ligne ci-dessus vous donnera les 1000 dernières minutes de données OHLC pour le prix Bitcoin en USD. Eh bien, c'est bien, mais nous pourrions être intéressés par une période antérieure ou par une paire de devises différente. Dans ce cas, nous pouvons spécifier des paramètres supplémentaires pour obtenir exactement ce que nous voulons. Et ces paramètres sont:

  • symbole: paire de devises, par défaut: BTCUSD
  • intervalle: résolution temporelle, par ex. 1 m pour 1 minute de données OHLC
  • limite: nombre de points de données retournés, par défaut: 1000
  • start: heure de début de l'intervalle en millisecondes depuis 1970
  • end: heure de fin de l'intervalle en millisecondes depuis 1970

Donc, avec ces informations à portée de main, nous pouvons exécuter la première requête. Le code ci-dessous renverra les données OHLC d'une résolution d'une minute du prix du Bitcoin en USD pour les deux premiers jours d'avril 2018.

>>> importer datetime
>>> temps d'importation
>>> # Définir les paramètres de requête
>>> pair = 'btcusd' # Paire de devises d'intérêt
>>> bin_size = '1m' # Cela renverra des données minute
>>> limit = 1000 # Nous voulons le maximum de 1000 points de données
>>> # Définissez la date de début
>>> t_start = datetime.datetime (2018, 4, 1, 0, 0)
>>> t_start = time.mktime (t_start.timetuple ()) * 1000
>>> # Définissez la date de fin
>>> t_stop = datetime.datetime (2018, 4, 2, 0, 0)
>>> t_stop = time.mktime (t_stop.timetuple ()) * 1000
>>> result = api_v2.candles (symbol = pair, interval = bin_size,
>>> limite = limite, début = t_start, fin = t_stop)

Collecte de données historiques pour des intervalles de temps plus longs

C'est très bien, mais il y a toujours un problème: l'API ne renverra qu'un maximum de 1 000 points de données. Donc, si nous devions augmenter l'intervalle de temps d'intérêt pour tout le mois d'avril 2018, nous ne serions pas en mesure de l'obtenir avec une résolution d'une minute. Donc, pour dépasser cette limitation, nous devons écrire une fonction qui divise notre grande requête en plusieurs plus petites. Une autre chose que nous devons garder à l'esprit ici est qu'il y a une limite au nombre de demandes que nous pouvons faire à l'API Bitfinex. Actuellement, cette limite est de 60 appels par minute, ce qui signifie qu'après chaque demande, nous devons attendre au moins 1 seconde avant de commencer la suivante. Pour être sûr, la fonction ci-dessous attend 2 secondes, mais vous pouvez changer cela si vous le souhaitez.

>>> def fetch_data (démarrage, arrêt, symbole, intervalle, tick_limit, étape):
>>> # Créer une instance api
>>> api_v2 = bitfinex.bitfinex_v2.api_v2 ()
>>> data = []
>>> start = start - étape
>>> pendant le démarrage >> start = start + step
>>> fin = début + étape
>>> res = api_v2.candles (symbole = symbole, intervalle = intervalle,
>>> limit = tick_limit, start = start,
>>> fin = fin)
>>> data.extend (res)
>>> time.sleep (2)
>>> renvoyer les données

Avec la fonction ci-dessus, nous pouvons maintenant exécuter des requêtes pour des intervalles de temps plus longs, la seule chose supplémentaire que nous devons fournir est la taille du pas en millisecondes. C'est le nombre de points de données que nous devrions demander dans chacune des petites requêtes. C'est fondamentalement la même que la limite que nous avons définie précédemment mais maintenant en millisecondes. Donc, pour réduire le nombre d'appels à l'API, nous devrions opter pour le maximum, ce qui signifie pour le cas d'une minute une taille de pas de: 60000 * 1000 = 60000000.

>>> # Définir la taille des pas
>>> time_step = 60000000
>>> # Définissez la date de début
>>> t_start = datetime.datetime (2018, 4, 1, 0, 0)
>>> t_start = time.mktime (t_start.timetuple ()) * 1000
>>> # Définissez la date de fin
>>> t_stop = datetime.datetime (2018, 5, 1, 0, 0)
>>> t_stop = time.mktime (t_stop.timetuple ()) * 1000
>>> pair_data = fetch_data (start = t_start, stop = t_stop, symbol = pair,
>>> interval = bin_size, tick_limit = limit,
>>> step = time_step)

Enfin, convertissons les résultats dans un bloc de données Pandas afin de pouvoir supprimer les doublons potentiels, nous assurer que tout est dans le bon ordre et convertir l'horodatage en un format lisible.

>>> importez des pandas en tant que pd
>>>
>>> # Créer un cadre de données pandas et nettoyer / formater les données
>>> names = ['time', 'open', 'close', 'high', 'low', 'volume']
>>> df = pd.DataFrame (paire_données, colonnes = noms)
>>> df.drop_duplicates (inplace = True)
>>> df ['time'] = pd.to_datetime (df ['time'], unit = 'ms')
>>> df.set_index ('time', inplace = True)
>>> df.sort_index (inplace = True)

Conclusion

La récupération de données OHLC haute résolution n'est donc pas si compliquée. Et si vous vous demandez combien de paires de devises nous pouvons le faire via l'API Bitfinex, exécutez simplement les deux lignes de code ci-dessous.

>>> api_v1 = bitfinex.bitfinex_v1.api_v1 ()
>>> paires = api_v1.symbols ()

Maintenant, si nous le poussions, nous pourrions écrire un script comme celui-ci qui collecte toutes les données pour chaque paire de devises et les enregistre dans un fichier CSV. Cela vous donne toutes les données de trading OHLC historiques de la bourse Bitfinex avec une résolution d'une minute qui devrait vous aider à développer une stratégie de trading automatisée. Cependant, cela prendra un certain temps jusqu'à ce que toutes les données soient sur votre ordinateur, vous devez donc limiter votre requête à une période plus courte ou être plus sélectif avec vos paires de devises.

J'espère que cela aide et vous pouvez consulter le code ici, suivez-moi sur Twitter ou connectez-vous via LinkedIn.