API Coinbase Pro / Guide par Cryptogeek

Chaque bourse a des caractéristiques spéciales pour attirer les traders. Coinbase Pro dispose d'un code spécial permettant d'automatiser et de simplifier le trading. Ce code est l'API Coinbase Pro. 
Il est absolument gratuit de créer un compte et d'activer l'API Coinbase Pro.

Différences entre Coinbase et Coinbase Pro

Les deux plates-formes ont quelque chose en commun. Au moins Coinbase Global Inc possède les deux et les interfaces utilisateur se ressemblent.

Pourtant, il est évident que Coinbase et Coinbase Pro partagent pas mal de différences. Coinbase est plutôt un marché de crypto-monnaie, alors que Coinbase Pro est un échange de crypto à part entière. Coinbase ressemble à un portefeuille de crypto-monnaie, alors que Coinbase Pro est plus probablement une plate-forme de trading.

Web3 wallet for your digital assets!

Install

Install

Des attributs et des points de terminaison innovants rendent le trading sur l'API Coinbase Pro beaucoup plus rapide et meilleur que sur Coinbase.

Maintenant, l'API Coinbase Pro est disponible pour plus de 100 pays.

Avantages et inconvénients de l'utilisation de l'API Coinbase Pro

Voici une courte liste des avantages et des inconvénients que les traders devraient prendre en compte.

Pro:

● Simple
● Intuitif
● Entièrement réglementé aux États-Unis
● Liquidité élevée
● Prend en charge fiat (USD, EUR, GBP)
● Prend en charge plus de 120 crypto-monnaies

Inconvénient:

● Frais élevés
● Support client lent
● Trop compliqué pour les débutants

Pour résumer, l'API Coinbase Pro a deux fois plus d'avantages que d'inconvénients.

Est-Ce Que Coinbase Pro Prend Des Frais?

Oui, c'est le cas. Coinbase Pro prend les frais de trading habituels de ses utilisateurs. Cela se produit après une période de 30 jours lorsque le prix final est calculé. Pour la commodité du trader, la somme est prise en USD.

Comme d'habitude, les frais sont divisés en "fabricant" et " preneur”:

1. Un utilisateur devient preneur lorsqu'un ordre au marché placé est exécuté immédiatement. Frais: de 0,04% à 0,50%.

2. Aser devient un fabricant lorsqu'une commande passée n'est pas remplie en une seule fois et figure dans le carnet de commandes. Il est donc nécessaire d'attendre qu'il soit apparié par un autre trader. Frais: 0,00% jusqu'à 0,50%.

3. Et lorsque la commande n'est remplie que partiellement, les deux frais sont payés. Dans un premier temps, des frais de prise correspondant à la partie remplie sont payés, tandis que le reste de la commande se déplace sur le carnet d'ordres jusqu'à plus tard. Et quand il est apparié, des frais de fabricant sont payés.

Ce tableau montre le volume de transactions actuel pour les deux frais:

Les autres Bourses ont - elles une API?

De nombreux autres échanges ont une API. C'est pourquoi l'API Coinbase Pro ne peut pas être le seul choix pour les traders. Voici quelques échanges avec API:

● Binance
● BitMEX
● HitBTC
● Kraken
● Gemini
● KuCoin
● Bittrex
● Bitfinex

Après avoir effectué des recherches appropriées, les traders peuvent choisir parmi les échanges fournis ou trouver d'autres plates-formes qui répondraient à leurs besoins. Cependant, revenons à Coinbase Pro.

Création d'un compte sur Coinbase Pro

Les traders n'ont que deux méthodes pour créer un compte sur cette plateforme:

1. Si un trader a déjà un compte Coinbase, il ne reste plus qu'à le connecter à Coinbase Pro. Ensuite, le transfert de fonds serait possible entre les comptes.

2. Ou visitez simplement le Page de démarrage de Coinbase Pro et lancez un compte là-bas.

Après avoir cliqué sur le bouton” Commencer", les nouveaux arrivants doivent renseigner les détails de leur compte de base, vérifier une adresse e-mail et activer l'authentification à deux facteurs. Pour compléter l'inscription, les utilisateurs doivent fournir certaines informations personnelles: nom, date de naissance, adresse, intention, source des fonds, profession, y compris une photo d'identité et un lien vers un compte bancaire.

Qu'est-ce qu'une clé API Coinbase?

Pour gérer une API Coinbase Pro, les traders ont besoin d'une clé API Coinbase. Tout d'abord, cliquez sur le bouton “API” puis sur le bouton “+ Nouvelle clé API”. Ensuite, les utilisateurs doivent choisir les autorisations pour la clé API, définir le surnom et une phrase de passe, un niveau supplémentaire d'authentification et une fonctionnalité de sécurité réalisée par Coinbase.

Avant que la clé API puisse commencer à fonctionner, les traders doivent effectuer une étape supplémentaire: entrer un code de vérification pour obtenir une clé secrète. De plus, les utilisateurs doivent conserver cette clé secrète dans un endroit sûr afin de ne pas la perdre.

Enfin, l'API Coinbase Pro est créée. Passons à autre chose et parlons de ses capacités.

Commandes API Python Coinbase Pro utiles

Chaque trader peut choisir son client préféré parmi cinq.:

● Python
● Aller
● Java
● Rouiller
● C#

Python est le client le plus populaire pour écrire des commandes sur l'API Coinbase Pro. C'est pourquoi les exemples ne consisteraient qu'en elle.

Commençons:

pip installer cbpro

Informations sur les Paires de Trading Avec L'API Python Coinbase

Dans l'API Coinbase Pro, la bibliothèque python utilise obtenir_produits point final pour obtenir les informations sur les paires de trading. L'étape suivante consiste à importer la bibliothèque, à initialiser le client, à obtenir les données des produits:

importer cbpro 
importer des pandas en tant que pd 
c = cbpro.PublicClient() 
données = pd.Cadre de données(c. get_products()) 
données.queue().

Données de Prix Avec L'API Python Coinbase

Pour obtenir les informations sur les données de prix, utilisez get_product_ticker point final et spécifiez le paramètre ticker. Pour Cardano, ce serait:

ticker = c. get_product_ticker(product_id= 'ADA-USD') 
téléscripteur

La deuxième façon d'obtenir la date est à l'aide de API REST Coinbase Pro terminaison:

importer les requêtes ticker = requests. get ('https://api.pro.coinbase.com/products/ADA-USD/ticker'). json() 
téléscripteur

Données Historiques Avec L'API Python Coinbase

Pour obtenir les informations sur les données historiques, utilisez obtenir_des_rates_historiques_de_produits terminaison. Il est possible de spécifier la granularité, la date de début et de fin.

Regardez comme il est simple d'obtenir des données historiques ETH-USD avec les paramètres par défaut et de les organiser dans une trame de données ordonnée:

historique = pd.DataFrame(c. get_product_historic_rates(product_id= 'ETH-USD')) historique.colonnes= ["Date", "Ouvert", "Haut", "Bas","Fermer","Volume"] 
historique ['Date'] = pd. to_datetime(historique ['Date'], unité= 's') 
historique.set_index ('Date', inplace=True) 
historique.sort_values(by= 'Date', ascending=True, inplace=True) 
historique

Si nécessaire, ces données pourraient ensuite être utilisées pour créer un indicateur simple et produire un graphique en chandelier.

Accéder aux Indicateurs Techniques Avec L'API Python Coinbase

Malheureusement, l'API Coinbase Pro n'offre aucun indicateur prédéfini. Cependant, il est possible de les créer en utilisant des fonctionnalités pandas intégrées ou simplement en s'appuyant sur la bibliothèque btalib.

Voici comment créer un indicateur simple de 20 SMA avec des pandas:

historique['20 SMA'] = historique.Proche.roulement(20).signifier() 
historique.queue()

Et avec toutes ces données, il est possible de créer un graphique interactif:

importer plotly.graph_objets au fur et à mesure 
fig = aller.Figure (données=[aller.Chandelier(x = historique.index, 
open = historique ['Open'], 
élevé = historique ['Élevé'], 
faible = historique ['Faible'], 
fermer = historique ['Fermer'],), 
aller.Dispersion(x=).index, y=historique['20 SMA'], ligne=dict (couleur= 'violet', largeur=1))]) 
figue.montrer()

Données du Carnet De Commandes

Pour accéder aux données du Carnet de commandes, utilisez le obtenir_commander_de_produit Point de terminaison de l'API Coinbase Pro. Voici un exemple d'obtention de données pour BTC-USD et d'organisation des offres et des demandes.

order_book = c. get_product_order_book ('BTC-USD') 
carnet de commandes

L'étape suivante consiste à créer les deux trames de données:

offres = pd.Cadre de données(order_book ['bids']) 
demande = pd.DataFrame(order_book ['demande']) 
offre.tête()

Maintenant, les fusionner et renommer les colonnes pour être plus informatif:

df = pd.fusionner(offres, demandes, left_index=True, right_index=True) 
df = df.rename ({"0_x":"Prix de l'offre","1_x":"Taille de l'offre", "2_x": "Montant de l'offre", 
"0_y":"Prix demandé","1_y":" Taille demandée","2_y":" Montant demandé"}, axis= 'colonnes') 
df.tête()

Données sur les Transactions

Pour obtenir les données des transactions, utilisez le obtenir_produit_trades terminaison. N'oubliez pas d'entrer l'actif obtenant les données sur; ETH-USD dans cet exemple.

trades = pd. DataFrame (requêtes. get ('https://api.pro.coinbase.com/products/ETH-USD/trades'). json()) 
commerce.queue()

Pour ne pas bloquer la bibliothèque Python, utilisez l'API REST.

Comment utiliser l'API WebSocket de Coinbase Pro?

Pour accéder aux WebSockets Coinbase Pro, utilisez le WebscoketClient terminaison. Grâce à cela, les traders peuvent facilement rester à jour sur les données intéressantes.

importer cbpro 
wsc = cbpro. WebsocketClient (url= "wss: / /ws-feed. pro. coinbase. com", produits= "ADA-USD", 
canaux=["ticker"])

Pour fermer la WebSocket, il suffit d'utiliser une simple commande:

wsc.proche()

La commande suivante permet de collecter les données de prix du ticker jusqu'à un certain nombre de messages WebSocket et de les imprimer:

temps d'importation, cbpro 
classe myWebsocketClient(cbpro.Client WebSocket): 
def on_open (soi-même): 
auto.url = " wss: / /ws-feed. pro. coinbase. com/" 
auto.produits = ["ETH-USDT"] 
auto.canaux=["ticker"] 
auto.message_count = 0 
def on_message(auto, msg): 
auto.message_count + = 1 
si "prix" en msg et "type" en msg: 
print ("Type de message:", msg ["type"], 
"\t@ {:.3f}".format (flottant (msg ["prix"]))) 
def on_close (auto): 
imprimer ("Fermeture") 
wsClient = myWebsocketClient() 
wsClient.commencer() 
imprimer(wsClient.url, wsClient.produits, wsClient.canal) 
alors que (wsClient.message_count < 50): 
print ("\nmessage_count =", "{} \n".format(wsClient.message_count)) 
temps.sommeil(1) 
wsClient.proche()

Exécution de transactions sur l'API Coinbase Pro

Avec les commandes de l'API python Coinbase, il est assez simple d'exécuter des transactions. Jetons un coup d'œil à deux exemples: exécuter un trade sur ETH lorsque BTC atteint un certain prix et exécuter un trade ETH lorsque BTC bouge de 5% au cours des 5 dernières minutes.

Comment exécuter une transaction sur ETH Lorsque BTC atteint un Certain prix?

Voyons maintenant comment lancer correctement un ordre avec des exigences spécifiées: commencez une transaction sur ETH lorsque BTC atteint un certain prix (par exemple, 38500$).

1. Définir une fondation de commande;
2. Créez une boucle qui vérifiera si le niveau de prix est atteint ou non;
3. Une fois le prix atteint, un ordre au marché sera exécuté; 
4. Attendez quelques secondes et vérifiez si la commande a bien été remplie. 

Après avoir défini la logique, il est temps d'importer les bibliothèques pertinentes et de configurer les API:

importer cbpro 
importer base64 
importer json à partir de time 
importer le sommeil 
clé = '' 
secret = '' 
phrase = '' 
encodé = json.décharges (secrètes).encodage() 
b64secret = base64.b64encode(codé) 
auth_client = cbpro.AuthenticatedClient(clé=clé, b64secret=secret, phrase de passe=phrase de passe) 
c = cbpro.PublicClient()

En ce qui concerne la logique de négociation principale, voici un avis important pour rendre l'ordre plus sûr. Pour ce faire, placez un ordre à cours limité en prenant le prix actuel de l'ETH-USD et en ajoutant quelques dollars en haut.

bien que Vrai: 
essayer: 
ticker = c. get_product_ticker(product_id= 'BTC-USD') 
sauf exception en tant que e: 
print(f'Erreur d'obtention des données du ticker: {e}') 
si float(ticker ['prix']) > = 38500.00: 
essayer: 
limit = c. get_product_ticker(product_id= 'ETH-USD') 
sauf exception en tant que e: 
print(f'Erreur d'obtention des données du ticker: {e}') 
essayer: 
order=auth_client.place_limit_order (product_id= 'ETH-USDT', 
side= 'acheter', 
prix=flottant(limite ['prix'])+2, 
taille='0.007') 
sauf exception en tant que e: 
print(f'Erreur de commande: {e}') 
sommeil(2) 
essayer: 
check = commande ['id'] 
check_order = auth_client.get_order(order_id=vérifier) 
sauf exception en tant que e: 
imprimez(f'Unable pour vérifier la commande. Il pourrait être rejeté. {e}') 
si check_order ['status'] = = 'terminé': 
imprimer ("Commande passée avec succès") 
imprimer(check_order) 
briser 
autre: 
print ('La commande n'a pas été jumelée') 
briser 
autre: 
imprimer (f) L'exigence n'est pas atteinte. Le prix du ticker est à {ticker ["price"]}') 
sommeil(10)

Comment exécuter un trade ETH lorsque BTC bouge de 5% au cours des 5 dernières minutes?

La tâche devient légèrement compliquée. La nouvelle boucle devra obtenir les prix des deux crypto-monnaies et calculer le pourcentage de variation entre les deux:

● Si le changement de pourcentage est inférieur à 5%, le programme dormira pendant 5 minutes de plus;

● Si le changement de pourcentage est égal ou supérieur à 5%, la transaction s'exécutera.

Attendez quelques secondes après l'accomplissement et vérifiez à nouveau le trade.

bien que Vrai: 
essayer: 
ticker_old = c. get_product_ticker(product_id= 'BTC-USD') 
sauf exception en tant que e: 
print(f'Erreur d'obtention des données du ticker: {e}') 
sommeil(300) 
essayer: 
ticker_new = c. get_product_ticker(product_id= 'BTC-USD') 
sauf exception en tant que e: 
print(f'Erreur d'obtention des données du ticker: {e}') 
pourcentage = ((float (ticker_new ['prix']) - float(ticker_old['prix']))*100) / float(ticker_old ['prix']) 
si pourcentage >= 5: 
essayer: 
limit = c. get_product_ticker(product_id= 'ETH-USDT') 
sauf exception en tant que e: 
print(f'Erreur d'obtention des données du ticker: {e}') 
essayer: 
order=auth_client.place_limit_order (product_id= 'ETH-USDT', 
side= 'acheter', 
prix=flottant(limite ['prix'])+2, 
taille='0.007') 
sauf exception en tant que e: 
print(f'Erreur de commande: {e}') 
sommeil(2) 
essayer: 
check = commande ['id'] 
check_order = auth_client.get_order(order_id=vérifier) 
sauf exception en tant que e: 
imprimez(f'Unable pour vérifier la commande. Il pourrait être rejeté. {e}') 
si check_order ['status'] = = 'terminé': 
imprimer ("Commande passée avec succès") 
imprimer(check_order) 
briser 
autre: 
print ('La commande n'a pas été jumelée') 
briser 
autre: 
imprimer (f) L'exigence n'est pas atteinte. Le pourcentage de changement est à {%}')

Comment annuler des commandes avec l'API Coinbase Pro?

Il est très simple d'annuler une commande. Aller à la annuler_commande Point de terminaison API et entrez l'ID de commande en tant que paramètre:

client.cancel_order(order_id = "ID-DE-COMMANDE-ICI")

Conclusion

Dans cet article, nous avons examiné de plus près l'API Coinbase Pro et donné quelques exemples de code python. Le code complet peut être trouvé sur le site de la plateforme GitHub page.