Hoe een crypto-handelsbot voor Binance te bouwen (met Python)

>

Binance en handelsbots.

De wereld heeft sinds Bert en Ernie geen iconischer duo gezien. De legendarische beurs is overspoeld met allerlei soorten geautomatiseerde handelsbots. Instellingen en vermogende particulieren voeren geavanceerde algoritmische handelsstrategieën uit terwijl beleggers hun portefeuille automatiseren. Het is een spannende speeltuin geworden voor bouwers.

Toch is er nog veel te bouwen. Tot nu toe is slechts een fractie van de benodigde diensten ontwikkeld en het komende jaar zal er veel groei zijn.

Als u aan de slag wilt gaan met deelname aan de ontwikkeling van handelsbots, dan is dit de beste plek om te beginnen. In dit artikel zullen we u leren hoe u toegang kunt krijgen tot marktgegevens van de beurs, verbinding kunt maken met uitwisselingsrekeningen om balansgegevens te lezen, transacties kunt uitvoeren, candlesticks in kaart te brengen en zelfs verbinding kunt maken met realtime websockets voor ticker-gegevens.

Er is veel te behandelen, dus laten we beginnen!

Beginnen

De volgende stappen zullen de noodzakelijke componenten opsplitsen om te beginnen met het programmeren van uw Binance Python-scripts.

Shrimpy Python installeren

Eerst moeten we de Shrimpy Python-bibliotheek installeren. De officiële Shrimpy Python GitHub is te vinden hier.

Met Pip kun je de bibliotheek snel installeren met behulp van het volgende.

pip installeer shrimpy-python

Binance API-sleutels

Om verbinding te maken met de Binance-uitwisseling, moeten we via de uitwisseling een nieuwe API-sleutel genereren. Dit kan gedaan worden door het Binance API Key Help-artikel te volgen.

Nadat u bij de stap bent gekomen waarin u de API-sleutels uit Binance kopieert, kunt u ze stoppen en op een veilige plaats opslaan (in plaats van ze in de Shrimpy Portfolio Management-applicatie te plakken). Deze sleutels worden in onze scripts gebruikt door ze toe te wijzen aan een variabele die we kunnen doorgeven aan onze client wanneer deze is gemaakt.

exchange_public_key = ‘…’

exchange_secret_key = ‘…’

Shrimpy API-sleutels

Nadat de exchange API-sleutels zijn gemaakt, moeten we ook API-sleutels genereren voor de Shrimpy Universal Crypto Trading API’s. Deze sleutels worden gegenereerd door u aan te melden voor het Shrimpy Developer API’s daarna de beschreven gids volgen hier.

Nadat de sleutels zijn gemaakt, slaat u ze op een veilige locatie op en gebruikt u ze op de volgende manier in uw Python-scripts.

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

Wissel gegevens uit

Het verkrijgen van nauwkeurige marktgegevens is de eerste stap naar het creëren van een cryptohandelbot die strategieën kan uitvoeren op basis van signalen, marktomstandigheden en prijsbewegingen.

Dit wordt doorgaans gedaan met behulp van zowel live orderboekgegevens als handelsgegevens. In de volgende secties geven we voorbeelden van hoe u beide soorten informatie kunt verzamelen via websockets en REST API’s.

Prijs Ticker

Een prijskikker is iets dat de prijs op een consistente basis bijwerkt om de laatste prijs van het activum op een beurs te krijgen. De volgende voorbeelden geven een aantal voorbeelden van hoe u prijstickers kunt maken en openen.

Een eenvoudige prijsticker

Dit voorbeeld biedt een script voor de meest eenvoudige prijsticker. Deze ticker gebruikt REST API-aanroepen om toegang te krijgen tot prijsgegevens op de centrale. Dit eindpunt wordt bijgewerkt met een interval van 1 minuut, dus dat betekent dat de hoogst mogelijke frequentie voor het bijwerken van de ticker in dit voorbeeld 1 minuut is.

importeer garnalen

# Wijs openbare en geheime Shrimpy Master API-sleutels toe

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Maak de Shrimpy REST API-client

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Vraag de ticker aan voor alle activa op Binance

ticker = client.get_ticker (‘binance’)

Websocket Prijsticker

Complexer dan de eenvoudige prijsticker is de realtime websocket-ticker. Deze ticker maakt gebruik van de real-time websockets om op de hoogte te blijven van de laatste prijs op de beurs.

In tegenstelling tot de eenvoudige prijsticker die met een interval van 1 minuut wordt bijgewerkt, wordt deze prijsticker onmiddellijk bijgewerkt. Zodra de prijs op de beurs verandert, stuurt de websocket de update en wordt de nieuwe prijs door dit script ontvangen om weer te geven.

importeer garnalen

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Dit is een voorbeeld-handler, het drukt eenvoudig het inkomende bericht af naar de console

def error_handler (err):

print (err)

# Dit is een voorbeeld-handler, het drukt eenvoudig het inkomende bericht af naar de console

def handler (msg):

print (msg [‘content’] [0] [‘price’])

# Maak de websocket-client met behulp van het onbewerkte token dat is opgehaald door de REST API

api_client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

raw_token = api_client.get_token ()

client = shrimpy.ShrimpyWsClient (error_handler, raw_token [‘token’])

# De abonnementsgegevens voor de websocket

subscribe_data = {

"type"​ "abonneren",

"uitwisseling"​ "binance",

"paar-"​ "eth-btc",

"kanaal"​ "handel"​

# Begin met het verwerken van de Shrimpy websocket-stream!

client.connect ()

client.subscribe (subscribe_data, handler)

# Eenmaal voltooid, stopt u de client

client.disconnect ()

Ruil orderboeken

Nauwkeurige orderboeken op een beurs worden gebruikt door handelaren en cryptobots om de exacte order te bepalen die ze op de beurs willen plaatsen.

Bij het plaatsen van bestellingen is het altijd voordelig om realtime updates van het orderboek te hebben. Op die manier neemt u altijd beslissingen op basis van de meest up-to-date informatie.

Simpele Live Order Book Snapshot

De eenvoudigste manier om toegang te krijgen tot de orderboeken van een beurs is door het orderboek aan te vragen op het moment dat u een order gaat plaatsen..

Als u bijvoorbeeld een transactie wilt uitvoeren op het ETH / BTC-handelspaar, kunt u een verzoek indienen om het laatste orderboek voor deze markt op te halen door de REST API in te schakelen.

importeer garnalen

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Maak de API-client voor REST-aanroepen

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Haal het live orderboek op

orderbooks = client.get_orderbooks (

‘binance’, # exchange

‘ETH’, # base_symbol

‘BTC’, # quote_symbol

10 # limiet

Websocket Live Orderboek

In meer geavanceerde scenario’s zou het ideaal zijn om een ​​lokale kopie van het orderboek bij te houden die in realtime wordt bijgewerkt via websockets. Dit kan met behulp van de websocket voor het orderboek die beschikbaar is via de websocket API’s.

Verbinding maken met het ETH / BTC-paar zou er ongeveer zo uitzien als in het volgende voorbeeld.

importeer garnalen

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Dit is een voorbeeld-handler, het drukt eenvoudig het inkomende bericht af naar de console

def error_handler (err):

print (err)

# Dit is een voorbeeld-handler, het drukt eenvoudig het inkomende bericht af naar de console

def handler (msg):

print (msg)

# Maak de websocket-client door het onbewerkte token op te halen.

api_client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

raw_token = api_client.get_token ()

ws_client = shrimpy.ShrimpyWsClient (error_handler, raw_token [‘token’])

subscribe_data = {

"type"​ "abonneren",

"uitwisseling"​ "binance",

"paar-"​ "eth-btc",

"kanaal"​ "orderboek"​

# Begin met het verwerken van de Shrimpy websocket-stream!

ws_client.connect ()

ws_client.subscribe (subscribe_data, handler)

# Eenmaal voltooid, stopt u de client

ws_client.disconnect ()

Merk op dat dit voorbeeld niet beschrijft hoe u het orderboek lokaal kunt beheren, maar alleen hoe u toegang krijgt tot de gegevens via de websocket. Het ordenen van gegevens zou moeten gebeuren via aangepaste code op basis van hoe u de boeken wilt beheren.

In wezen vereist het beheer van de boeken een manier om de huidige staat van het boek bij te houden. Op die manier kunt u nieuwe bestellingen invoegen, oude bestellingen bijwerken en bestellingen indien nodig verwijderen op basis van de updates via de websocket.

Exchange-accountconnectiviteit

Om te kunnen handelen, hebben we toegang nodig tot een uitwisselingsaccount. Deze uitwisselingsrekening zal worden gebruikt om gegevens over de beschikbare saldi te verzamelen en de handelsstrategie uit te voeren.

Een Binance-account koppelen

Shrimpy biedt een handig gebruikersbeheersysteem waarmee u individuele Binance-accounts aan gebruikers kunt koppelen. Elke gebruiker kan maximaal 20 wisselaccounts hebben. Op die manier kunnen al uw wisselrekeningen samen worden beheerd.

Het koppelen van een uitwisselingsaccount aan Shrimpy is een eenmalige gebeurtenis. Dat betekent dat zodra het account is gekoppeld, Shrimpy de verbinding met de centrale voor dat account en niet moeten in de toekomst opnieuw worden gekoppeld. U kunt altijd uw gekoppelde accounts krijgen door de accounts te vermelden die aan een gebruiker zijn gekoppeld.

In dit voorbeeld zullen we onze eerste gebruiker aanmaken en vervolgens het uitwisselingsaccount koppelen. Zodra u uw eerste gebruiker heeft aangemaakt, u Niet doen opnieuw een gebruiker moeten aanmaken. U hebt altijd toegang tot uw gebruikers door een lijst te maken van de gebruikers die u heeft gemaakt.

# vereiste bibliotheken importeren

importeer garnalen

# wijs uw Shrimpy Master API-sleutels toe voor later gebruik

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# wijs uw uitwisselingssleutels toe waarvoor u toegang wilt tot de balansgegevens

exchange_name = "binance"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# maak de Shrimpy-client

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# maak een gebruiker aan die wordt gekoppeld aan onze uitwisseling

create_user_response = client.create_user (‘The Shrimp Master’)

user_id = create_user_response [‘id’]

# onze eerste uitwisseling koppelen zodat we toegang hebben tot balansgegevens

link_account_response = client.link_account (

gebruikersnaam,

exchange_name,

exchange_public_key,

exchange_secret_key

account_id = link_account_response [‘id’]

Binance-accountsaldi ophalen

Zodra het account is gekoppeld, begint Shrimpy met het verzamelen van gegevens van de uitwisseling met betrekking tot het uitwisselingsaccount. Dit kan tot 5 seconden, dus we raden aan om een ​​paar seconden te wachten (alleen voor de eerste koppeling) voordat u het volgende script gebruikt om toegang te krijgen tot de saldo-gegevens van de exchange-account die was gekoppeld.

Nadat de gegevens zijn verzameld, zal Shrimpy het saldo continu bijwerken terwijl transacties worden uitgevoerd, stortingen of opnames worden gedaan en andere bewerkingen op de rekening worden uitgevoerd.

In dit voorbeeld laten we zien hoe u het saldo van de Binance-rekening kunt ophalen.

importeer garnalen

# gebruik uw openbare en privésleutels van de Shrimpy API om de client te maken

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# opmerking: sinds we een gebruiker hebben gemaakt in ons laatste voorbeeldscript,

# we kunnen gewoon onze lijst met gebruikers ophalen.

gebruikers = client.list_users ()

first_user_id = gebruikers [0] [‘id’]

# haal de accounts op die aan deze gebruiker zijn gekoppeld

accounts = client.list_accounts (

first_user_id

first_account_id = accounts [0] [‘id’]

# toegang tot saldo-gegevens voor het gebruikersaccount dat u eerder hebt aangemaakt

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

Merk op hoe we de eindpunten hebben gebruikt om “gebruikerslijst” en “lijstaccounts” te gebruiken. Als u de account- en gebruikers-ID’s al heeft, kunt u die waarden ook gewoon invoeren zonder ze elke keer op te halen.

Een transactie uitvoeren op Binance

Ruilen kan ingewikkeld zijn. Verwarrende documentatie, inconsistente handelsregels en discrepanties tussen eindpunten kunnen ervoor zorgen dat het ontwikkelingsproces chaotisch wordt.

In de volgende voorbeelden zullen we enkele van de meest eenvoudige manieren opsplitsen om transacties uit te voeren op Binance. Zonder ingewikkelde logica kan Shrimpy u helpen bij het op dezelfde manier uitvoeren van een order op elke grote beurs.

Eenvoudige handel

De eenvoudigste manier om een ​​transactie met Shrimpy uit te voeren, is door het eindpunt “Create Trade” te gebruiken. Het enige dat dit eindpunt vereist, zijn de relevante account-ID’s en de twee activa waarmee u ‘van’ en ‘naar’ verhandelt.

Het ziet er ongeveer als volgt uit.

create_trade_response = client.create_trade (

user_id, # De ID van de gebruiker

account_id, # De ID van het account dat aan de gebruiker is gekoppeld

from_symbol, # Het activum dat u wilt verkopen

to_symbol, # De asset die u wilt kopen

from_native_amount # Hoeveel van de "van" activa die u wilt verkopen

Het resultaat is een eenvoudige manier om activa te kopen en verkopen zonder dat u zich zorgen hoeft te maken over de details van hoe de transacties worden uitgevoerd. U hoeft geen individuele limietorders te plaatsen, verschillende handelsparen te bepalen of de activa handmatig door verschillende koersvaluta’s te routeren. Shrimpy zorgt voor alles.

We kunnen dit eindpunt vervolgens aan het werk zetten door het in een voorbeeldscript te plaatsen. In dit voorbeeld zullen we alle activa onderzoeken die u op de beurs bezit. We zullen dan de lijst met activa die u bezit herhalen en ze allemaal verkopen aan een consolidatieactief (in dit geval BTC).

HOU OP! Als u dit script uitvoert, verkoopt u letterlijk alles wat u bezit op de beurs en koopt u BTC. Dit is geen hypothetisch script, dit is een echt voorbeeld dat echte transacties uitvoert op uw echte wisselrekening. Voer het script niet uit als u niet alles wat u bezit aan Bitcoin wilt verkopen.

importeer garnalen

# Gebruik uw openbare en privésleutels van de Shrimpy API om de client te maken

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Opmerking: sinds we een gebruiker hebben gemaakt in ons laatste voorbeeldscript,

# We kunnen gewoon onze lijst met gebruikers ophalen.

gebruikers = client.list_users ()

first_user_id = gebruikers [0] [‘id’]

# Haal de accounts op die aan deze gebruiker zijn gekoppeld

accounts = client.list_accounts (

first_user_id

first_account_id = accounts [0] [‘id’]

# Toegang tot balansgegevens voor het gebruikersaccount dat u eerder hebt aangemaakt

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

holdings = saldo [‘saldi’]

# Selecteer het activum waarvoor u wilt consolideren

consolidation_symbol = ‘BTC’

# Verkoop alle activa naast de consolidatieactiva

voor activa in deelnemingen:

asset_symbol = asset [‘symbool’]

asset_amount = asset [‘nativeValue’]

if asset_symbol! = consolidation_symbol:

print (‘Selling’ + str (asset_amount) + ‘of’ + asset_symbol)

create_trade_response = client.create_trade (

first_user_id,

first_account_id,

asset_symbol,

consolidation_symbol,

asset_amount

Slimme orderroutering

In het vorige voorbeeld hebben we geen gebruik gemaakt van intelligente routing. In wezen zal Shrimpy de activa “van” en “naar” identificeren, vervolgens de activa “van” aan BTC verkopen en vervolgens de activa “naar” van BTC kopen. Dit kan inefficiënt zijn als er alternatieve koersvaluta’s zijn die het actief zou kunnen gebruiken.

In veel gevallen is het gebruik van de slimme orderrouteringsoptie ideaal. Deze eenvoudige vlag vertelt Shrimpy om elke mogelijke route te evalueren bij het beslissen hoe we de ‘van’-activa moeten verhandelen en de’ naar’-activa moeten verwerven.

importeer garnalen

# Gebruik uw openbare en privésleutels van de Shrimpy API om de client te maken

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Opmerking: sinds we een gebruiker hebben gemaakt in ons laatste voorbeeldscript,

# We kunnen gewoon onze lijst met gebruikers ophalen.

gebruikers = client.list_users ()

first_user_id = gebruikers [0] [‘id’]

# Haal de accounts op die aan deze gebruiker zijn gekoppeld

accounts = client.list_accounts (

first_user_id

first_account_id = accounts [0] [‘id’]

# Toegang tot balansgegevens voor het gebruikersaccount dat u eerder hebt aangemaakt

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

# Voer een marktorder uit

smart_order_response = client.create_trade (

first_user_id, # user_id

first_account_id, # account_id

‘BTC’, # from_symbol

‘ETH’, # to_symbol

‘0.01’ # hoeveelheid van_symbool

True # schakel smart_routing in

Merk op dat het enige verschil de extra vlag in het verzoek is om slimme routering in te schakelen en deze in te stellen op ‘Waar’.

Kandelaars in kaart brengen

Het bouwen van een applicatie met een gebruikersinterface betekent dat we andere componenten nodig hebben om de huidige staat van de markt aan gebruikers te illustreren. Een voorbeeld van gegevens die de gebruiker mogelijk wenst te ontvangen, zijn kandelaargrafieken.

Candlestick-grafieken helpen traders te beslissen wanneer ze een actief moeten kopen of verkopen.

Shrimpy biedt toegang tot gratis endpoints voor toegang tot realtime candlestick-gegevens. Elke keer dat er een nieuwe transactie op de beurs wordt uitgevoerd, worden de kandelaars in realtime bijgewerkt. Deze kandelaars kunnen vervolgens met regelmatige tussenpozen worden gepolld om ze in de gebruikersinterface van uw applicatie weer te geven.

In het volgende voorbeeld zullen we de nieuwste candlesticks voor het ETH / BTC-handelspaar op de Binance-beurs bekijken. Ditzelfde eindpunt kan voor elke andere grote centrale worden gebruikt, dus er is geen verschil tussen het gebruik van Binance en andere uitwisselingen.

importeer garnalen

importeer plotly.graph_objects als go

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Verzamel de historische candlestick-gegevens

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

kaarsen = client.get_candles (

‘binance’, # exchange

‘ETH’, # base_trading_symbol

‘BTC’, # quote_trading_symbol

‘1d’ # interval

dates = []

open_data = []

high_data = []

low_data = []

close_data = []

# Formatteer de gegevens zodat ze overeenkomen met de plotbibliotheek

voor kaars in kaarsen:

dates.append (kaars [‘tijd’])

open_data.append (kaars [‘open’])

high_data.append (kaars [‘high’])

low_data.append (kaars [‘laag’])

close_data.append (kaars [‘close’])

# Teken de kandelaars

fig = go.Figure (data = [go.Candlestick (x = dates,

open = open_data, high = high_data,

low = low_data, close = close_data)])

fig.show ()

Alles samenvoegen

Er rest ons nog maar één ding. Dat is om alles wat we tot nu toe hebben besproken in één script samen te voegen. Dit script controleert de ticker voor het BTC / USDT-paar op Binance en voert een transactie uit om al je BTC te verkopen wanneer de waarde van BTC hoger is dan 10.000 USDT. Dit is een eenvoudig voorbeeld van hoe u de gegevens uit de websockets kunt combineren om een ​​handelsstrategie uit te voeren.

importeer garnalen

import tijd

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Wijs uw uitwisselingssleutels toe waarvoor u toegang wilt tot de saldogegevens

exchange_name = "binance"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# Maak de websocket-client

api_client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

raw_token = api_client.get_token ()

ws_client = shrimpy.ShrimpyWsClient (error_handler, raw_token [‘token’])

# Maak een gebruiker aan die aan onze uitwisseling wordt gekoppeld

# Sla deze stap over (of gebruik de "lijst gebruikers" endpoint) als je al een gebruiker hebt gemaakt

create_user_response = api_client.create_user (‘The Shrimp Master’)

user_id = create_user_response [‘id’]

# Koppel onze eerste uitwisseling zodat we toegang hebben tot balansgegevens

# Sla deze stap over (of gebruik de "lijst accounts" endpoint) als je al een account hebt gekoppeld

link_account_response = api_client.link_account (

gebruikersnaam,

exchange_name,

exchange_public_key,

exchange_secret_key

account_id = link_account_response [‘id’]

# Wacht terwijl Shrimpy gegevens verzamelt voor het uitwisselingsaccount

# Alleen vereist bij de eerste keer koppelen

time.sleep (5)

# Toegang tot balansgegevens voor het gebruikersaccount dat u eerder hebt aangemaakt

balance = api_client.get_balance (

user_id, # user_id

account_id # account_id

btcAmount = 0

voor activa in balans [‘saldi’]:

if asset [‘symbol’] = ‘BTC’:

btcAmount = asset [‘nativeValue’]

# Dit is een voorbeeld-handler, het print gewoon het inkomende bericht naar de console

def error_handler (err):

print (err)

# Dit is een voorbeeld-handler, het print gewoon het inkomende bericht naar de console

def handler (msg):

price = msg [‘content’] [0] [‘price’]

if int (prijs) > 10000:

smart_order_response = api_client.create_trade (

user_id, # user_id

account_id, # account_id

‘BTC’, # from_symbol

‘USDT’, # to_symbol

btcAmount # hoeveelheid from_symbol

True # schakel smart_routing in

subscribe_data = {

"type"​ "abonneren",

"uitwisseling"​ "binance",

"paar-"​ "btc-usdt",

"kanaal"​ "handel"​

# Begin met het verwerken van de Shrimpy websocket-stream!

ws_client.connect ()

ws_client.subscribe (subscribe_data, handler)

Conclusies

Gewapend met deze scripts is het mogelijk om een ​​onbeperkt aantal opwindende handelsbots op Binance te bouwen. Naarmate u meer dingen over handelen en de Shrimpy Trading API’s onderzoekt, kunt u andere nuttige eindpunten tegenkomen, zoals de eindpunten voor limietorders. Deze geven u meer controle over de bestellingen die u op de beurs plaatst.

We moedigen iedereen aan om alles wat we aanbieden te verkennen en suggesties te doen in onze Ontwikkelaar Telegram. De markt voor cryptocurrency is spannend en dit is slechts het begin van een nieuwe manier om activa te verhandelen.

Garnaal is een applicatie voor het samenstellen van aangepaste cryptocurrency-indexfondsen, het opnieuw in evenwicht brengen en beheren van een diverse portefeuille van digitale activa. Automatiseer uw portefeuille door te linken naar een van de 16 crypto-uitwisselingen die we ondersteunen.

Shrimpy’s Universal Crypto Exchange API’s zijn ontworpen voor ontwikkelaars. Integratie met onze uniforme API’s geeft u direct toegang tot uniforme eindpunten voor handel, gegevensverzameling, gebruikersbeheer en meer op elke grote cryptocurrency-uitwisseling.

Volg deze links om toegang te krijgen tot de volledige Python- en Node-bibliotheken:

Knooppunt

Python

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me