Jak zbudować bota Crypto Trading dla Binance (przy użyciu Pythona)

>

Binance i boty handlowe.

Świat nie widział bardziej kultowego duetu od czasów Berta i Erniego. Legendarna giełda została zalana wszelkiego rodzaju automatami handlowymi. Instytucje i zamożne osoby fizyczne realizują zaawansowane algorytmiczne strategie handlowe, podczas gdy inwestorzy automatyzują swój portfel. Stało się ekscytującym placem zabaw dla budowniczych.

Jednak wciąż jest wiele do zbudowania. Do tej pory opracowano tylko część niezbędnych usług, aw nadchodzącym roku nastąpi duży wzrost.

Jeśli chcesz zacząć uczestniczyć w tworzeniu botów handlowych, jest to najlepsze miejsce na rozpoczęcie. W tym artykule nauczymy Cię, jak uzyskać dostęp do danych rynkowych z giełdy, łączyć się z kontami giełdowymi w celu odczytywania danych bilansowych, przeprowadzać transakcje, wykresy świecowe, a nawet łączyć się z danymi giełdowymi w czasie rzeczywistym.

Jest wiele do omówienia, więc zaczynajmy!

Pierwsze kroki

Poniższe kroki rozbiją komponenty niezbędne do rozpoczęcia programowania skryptów Binance Python.

Instalowanie Shrimpy Python

Najpierw musimy zainstalować Shrimpy Python Library. Oficjalny Shrimpy Python GitHub można znaleźć tutaj.

Korzystając z Pip, możesz szybko zainstalować bibliotekę, korzystając z następującego.

pip install shrimpy-python

Klucze API Binance

Aby połączyć się z giełdą Binance, będziemy musieli wygenerować nowy klucz API za pośrednictwem giełdy. Można to zrobić postępując zgodnie z artykułem pomocy Binance API Key.

Po przejściu do kroku, w którym kopiujesz klucze API z Binance, możesz zatrzymać je i przechowywać w bezpiecznym miejscu (zamiast wklejać je do aplikacji Shrimpy Portfolio Management Application). Te klucze będą używane w naszych skryptach poprzez przypisanie ich do zmiennej, którą możemy przekazać naszemu klientowi po jej utworzeniu.

exchange_public_key = ‘…’

exchange_secret_key = ‘…’

Klucze API Shrimpy

Po utworzeniu kluczy API wymiany, musimy również wygenerować klucze API dla interfejsów API Shrimpy Universal Crypto Trading. Te klucze są generowane przez zarejestrowanie się w Shrimpy Developer APIs następnie postępując zgodnie z przedstawionym przewodnikiem tutaj.

Po utworzeniu kluczy przechowuj je w bezpiecznej lokalizacji i używaj ich w swoich skryptach Pythona w następujący sposób.

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

Wymiana danych

Uzyskanie dokładnych danych rynkowych to pierwszy krok do stworzenia bota do handlu kryptowalutami, który może wykonywać strategie w oparciu o sygnały, warunki rynkowe i ruchy cen.

Odbywa się to zazwyczaj przy użyciu zarówno danych z księgi zamówień na żywo, jak i danych handlowych. W kolejnych sekcjach przedstawimy przykłady, jak zbierać oba te typy informacji za pośrednictwem gniazd internetowych i interfejsów API REST.

Price Ticker

Pasek cenowy to coś, co konsekwentnie aktualizuje cenę, aby uzyskać najnowszą cenę aktywa na giełdzie. Poniższe przykłady przedstawiają kilka przykładów tworzenia i uzyskiwania dostępu do pasków cenowych.

Prosty pasek cenowy

Ten przykład dostarczy skrypt dla najprostszego rodzaju paska ceny. Ten pasek ruchu będzie korzystał z wywołań interfejsu API REST w celu uzyskania dostępu do danych cenowych na giełdzie. Ten punkt końcowy jest aktualizowany co 1 minutę, co oznacza, że ​​najwyższa możliwa częstotliwość aktualizowania paska w tym przykładzie to 1 minuta.

import krewetek

# Przypisz publiczne i tajne klucze API Shrimpy Master

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Utwórz klienta Shrimpy REST API

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Poproś o ticker dla wszystkich aktywów na Binance

ticker = client.get_ticker (‘binance’)

Websocket Price Ticker

Bardziej skomplikowany niż zwykły pasek cenowy jest pasek cenowy w czasie rzeczywistym. Ten pasek ruchu wykorzystuje gniazda sieciowe w czasie rzeczywistym, aby być na bieżąco z najnowszymi cenami na giełdzie.

W przeciwieństwie do prostego paska ceny, który jest aktualizowany co 1 minutę, ten pasek ceny będzie aktualizowany natychmiast. Jak tylko cena zmieni się na giełdzie, websocket wyśle ​​aktualizację, a nowa cena otrzyma ten skrypt do wyświetlenia.

import krewetek

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# To jest przykładowa obsługa, po prostu drukuje przychodzącą wiadomość na konsolę

def error_handler (err):

print (err)

# To jest przykładowa obsługa, po prostu drukuje przychodzącą wiadomość na konsolę

def handler (msg):

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

# Utwórz klienta websocket przy użyciu surowego tokenu pobranego przez 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’])

# Dane subskrypcji dla Websocket

subscribe_data = {

"rodzaj": "Subskrybuj",

"Wymieniać się": "binance",

"para": "eth-btc",

"kanał": "handel"}

# Rozpocznij przetwarzanie strumienia Shrimpy Websocket!

client.connect ()

client.subscribe (subscribe_data, handler)

# Po zakończeniu zatrzymaj klienta

client.disconnect ()

Książki zleceń wymiany

Dokładne księgi zamówień na giełdzie są używane przez handlowców i boty kryptograficzne do określenia dokładnej kolejności, którą chcieliby złożyć na giełdzie.

Podczas składania zamówień zawsze warto mieć aktualizacje księgi zamówień w czasie rzeczywistym. W ten sposób zawsze podejmujesz decyzje w oparciu o najbardziej aktualne informacje.

Prosta migawka książki zamówień na żywo

Najprostszym sposobem uzyskania dostępu do ksiąg zamówień giełdy jest poproszenie o książkę zamówień w momencie składania zamówienia.

Na przykład, jeśli chcesz wykonać transakcję na parze handlowej ETH / BTC, możesz poprosić o uzyskanie najnowszego arkusza zleceń dla tego rynku, wywołując REST API.

import krewetek

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Utwórz klienta API dla wywołań REST

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Pobierz książkę zamówień na żywo

orderbooks = client.get_orderbooks (

‘binance’, # wymiana

„ETH”, # base_symbol

„BTC”, # quote_symbol

Limit 10 #

)

Książka zamówień Websocket Live

W bardziej zaawansowanych scenariuszach idealnie byłoby utrzymywać lokalną kopię księgi zamówień, która jest aktualizowana w czasie rzeczywistym za pośrednictwem gniazd internetowych. Można to zrobić za pomocą websocket księgi zamówień dostępnego za pośrednictwem interfejsów API websocket.

Podłączenie do pary ETH / BTC wyglądałoby mniej więcej tak, jak w poniższym przykładzie.

import krewetek

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# To jest przykładowa obsługa, po prostu drukuje przychodzącą wiadomość na konsolę

def error_handler (err):

print (err)

# To jest przykładowa obsługa, po prostu drukuje przychodzącą wiadomość na konsolę

def handler (msg):

drukuj (msg)

# Utwórz klienta websocket, pobierając surowy token.

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 = {

"rodzaj": "Subskrybuj",

"Wymieniać się": "binance",

"para": "eth-btc",

"kanał": "księga zamówień"}

# Rozpocznij przetwarzanie strumienia Shrimpy Websocket!

ws_client.connect ()

ws_client.subscribe (subscribe_data, handler)

# Po zakończeniu zatrzymaj klienta

ws_client.disconnect ()

Zwróć uwagę, że w tym przykładzie nie opisano, jak lokalnie zarządzać portfelem zamówień, a jedynie, jak uzyskać dostęp do danych za pośrednictwem gniazda internetowego. Organizacja danych musiałaby odbywać się za pomocą niestandardowego kodu w oparciu o sposób zarządzania książkami.

Zasadniczo zarządzanie książkami będzie wymagało sposobu śledzenia aktualnego stanu książki. W ten sposób możesz wstawiać nowe zamówienia, aktualizować stare zamówienia i usuwać zamówienia, jeśli to konieczne, na podstawie aktualizacji za pośrednictwem sieci Web.

Łączność z kontem Exchange

Aby handlować, potrzebujemy dostępu do konta wymiany. To konto giełdowe będzie używane do zbierania danych o dostępnych saldach i realizacji strategii handlowej.

Łączenie konta Binance

Shrimpy zapewnia wygodny system zarządzania użytkownikami, w którym możesz łączyć indywidualne konta Binance z użytkownikami. Każdy użytkownik może mieć do 20 kont giełdowych. W ten sposób wszystkimi swoimi kontami giełdowymi można zarządzać razem.

Połączenie konta giełdowego z Shrimpy jest wydarzeniem jednorazowym. Oznacza to, że po połączeniu konta Shrimpy będzie utrzymywać połączenie z giełdą dla tego konta i nie wymagają ponownego łączenia w przyszłości. Zawsze możesz uzyskać swoje połączone konta, wymieniając konta, które są połączone z użytkownikiem.

W tym przykładzie utworzymy naszego pierwszego użytkownika, a następnie połączymy konto wymiany. Po utworzeniu pierwszego użytkownika Ty nie rób trzeba ponownie utworzyć innego użytkownika. Zawsze możesz uzyskać dostęp do swoich użytkowników, wyświetlając utworzonych przez siebie użytkowników.

# importuj wymagane biblioteki

import krewetek

# przypisz klucze Shrimpy Master API do późniejszego użytku

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# przypisz klucze giełdy, dla których chcesz uzyskać dostęp do danych salda

exchange_name = "binance"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# utwórz klienta Shrimpy

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# utwórz użytkownika, który będzie powiązany z naszą giełdą

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

user_id = create_user_response [‘id’]

# połącz naszą pierwszą giełdę, abyśmy mogli uzyskać dostęp do danych salda

link_account_response = client.link_account (

identyfikator użytkownika,

exchange_name,

exchange_public_key,

exchange_secret_key

)

account_id = link_account_response [‘id’]

Odzyskiwanie sald kont Binance

Jak tylko konto zostanie połączone, Shrimpy zacznie zbierać dane z giełdy dotyczące konta wymiany. Może to zająć do 5 sekund, dlatego zalecamy odczekanie kilku sekund (tylko na początkowe połączenie) przed użyciem następnego skryptu w celu uzyskania dostępu do danych salda połączonego konta giełdowego.

Po zebraniu danych Shrimpy będzie stale aktualizować saldo w miarę wykonywania transakcji, dokonywania wpłat lub wypłat, a także wykonywania innych operacji na koncie.

W tym przykładzie pokazujemy, jak odzyskać saldo konta Binance.

import krewetek

# użyj publicznych i prywatnych kluczy Shrimpy API, aby stworzyć klienta

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# uwaga: ponieważ stworzyliśmy użytkownika w naszym ostatnim przykładowym skrypcie,

# możemy po prostu pobrać naszą listę użytkowników.

users = client.list_users ()

first_user_id = użytkownicy [0] [‘id’]

# pobrać konta powiązane z tym użytkownikiem

accounts = client.list_accounts (

first_user_id

)

first_account_id = konta [0] [‘id’]

# dostęp do danych salda dla wcześniej utworzonego konta użytkownika

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

Zwróć uwagę, jak użyliśmy punktów końcowych do „listy użytkowników” i „listy kont”. Jeśli masz już konto i identyfikatory użytkowników, możesz po prostu wprowadzić te wartości bez pobierania ich za każdym razem.

Wykonywanie transakcji na Binance

Wymiana może być skomplikowana. Myląca dokumentacja, niespójne reguły handlowe i rozbieżności między punktami końcowymi mogą powodować chaos w procesie rozwoju.

W poniższych przykładach omówimy niektóre z najprostszych sposobów wykonywania transakcji na Binance. Bez skomplikowanej logiki Shrimpy może pomóc Ci wykonać zlecenie na każdej większej giełdzie w identyczny sposób.

Prosty handel

Najprostszym sposobem zawarcia transakcji z Shrimpy jest użycie punktu końcowego „Utwórz wymianę”. Wszystko, czego wymaga ten punkt końcowy, to odpowiednie identyfikatory kont i dwa aktywa, z których będziesz handlować „od” i „do”.

Będzie wyglądać mniej więcej tak.

create_trade_response = client.create_trade (

user_id, # Identyfikator użytkownika

account_id, # Identyfikator konta połączonego z użytkownikiem

from_symbol, # Zasób, który chcesz sprzedać

to_symbol, # Zasób, który chcesz kupić

from_native_amount # Ile z "od" aktywa, które chcesz sprzedać

)

Rezultatem jest prosty sposób kupowania i sprzedawania aktywów bez martwienia się o specyfikę wykonywania transakcji. Nie musisz składać indywidualnych zleceń z limitem, określać różnych par handlowych ani ręcznie kierować aktywów przez różne waluty kwotowane. Shrimpy zadba o wszystko.

Następnie możemy uruchomić ten punkt końcowy, umieszczając go w przykładowym skrypcie. W tym przykładzie zbadamy wszystkie aktywa, które posiadasz na giełdzie. Następnie przejrzymy listę posiadanych aktywów i sprzedamy je wszystkie do składnika aktywów konsolidacyjnych (w tym przypadku BTC).

ZATRZYMAĆ! Uruchomienie tego skryptu dosłownie sprzedaje wszystko, co posiadasz na giełdzie i kupuje BTC. To nie jest hipotetyczny skrypt, to prawdziwy przykład, który wykonuje prawdziwe transakcje na Twoim prawdziwym rachunku giełdowym. Nie uruchamiaj skryptu, jeśli nie chcesz sprzedawać Bitcoinowi wszystkiego, co posiadasz.

import krewetek

# Użyj publicznego i prywatnego klucza Shrimpy API, aby stworzyć klienta

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Uwaga: ponieważ utworzyliśmy użytkownika w naszym ostatnim przykładowym skrypcie,

# Możemy po prostu pobrać naszą listę użytkowników.

users = client.list_users ()

first_user_id = użytkownicy [0] [‘id’]

# Pobierz konta powiązane z tym użytkownikiem

accounts = client.list_accounts (

first_user_id

)

first_account_id = konta [0] [‘id’]

# Dostęp do danych salda dla wcześniej utworzonego konta użytkownika

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

holdingi = saldo [‘salances’]

# Wybierz aktywa, dla których chcesz skonsolidować

Consolidation_symbol = ‘BTC’

# Sprzedaj wszystkie aktywa poza aktywami konsolidacyjnymi

dla aktywów w holdingach:

asset_symbol = asset [‘symbol’]

asset_amount = asset [‘nativeValue’]

if asset_symbol! = Consolidation_symbol:

print (‘Sprzedawanie’ + str (kwota_zasobu) + ‘z’ + symbol_zasobu)

create_trade_response = client.create_trade (

first_user_id,

first_account_id,

symbol_zasobu,

symbol_konsolidacji,

kwota_zasobu

)

Inteligentne kierowanie zamówień

W poprzednim przykładzie nie używaliśmy żadnego inteligentnego routingu. Zasadniczo Shrimpy zidentyfikuje aktywa „od” i „do”, a następnie sprzeda aktywa „od” do BTC, a następnie kupi aktywa „do” od BTC. Może to być nieefektywne, jeśli istnieją alternatywne waluty kwotowania, które można wykorzystać w aktywach.

W wielu przypadkach idealne byłoby użycie opcji inteligentnego kierowania zamówień. Ta prosta flaga mówi Shrimpy’emu, aby ocenił każdą możliwą trasę przy podejmowaniu decyzji, w jaki sposób powinniśmy handlować zasobem „od” i nabywać aktywa „do”.

import krewetek

# Użyj publicznego i prywatnego klucza Shrimpy API, aby stworzyć klienta

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Uwaga: ponieważ utworzyliśmy użytkownika w naszym ostatnim przykładowym skrypcie,

# Możemy po prostu pobrać naszą listę użytkowników.

users = client.list_users ()

first_user_id = użytkownicy [0] [‘id’]

# Pobierz konta powiązane z tym użytkownikiem

accounts = client.list_accounts (

first_user_id

)

first_account_id = konta [0] [‘id’]

# Dostęp do danych salda dla wcześniej utworzonego konta użytkownika

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

# Wykonaj zlecenie rynkowe

smart_order_response = client.create_trade (

first_user_id, # user_id

first_account_id, # account_id

„BTC”, # from_symbol

„ETH”, # to_symbol

‘0,01’ # kwota from_symbol

True # włącz smart_routing

)

Zwróć uwagę, że jedyną różnicą jest dodatkowa flaga w żądaniu włączenia inteligentnego routingu i ustawienie jej na „True”.

Wykresy świeczników

Zbudowanie aplikacji z interfejsem użytkownika oznacza, że ​​będziemy potrzebować innych komponentów, aby zobrazować użytkownikom aktualny stan rynku. Jednym z przykładów danych, które użytkownik może chcieć otrzymać, są wykresy świecowe.

Wykresy świecowe pomagają inwestorom zdecydować, kiedy powinni kupić lub sprzedać aktywa.

Shrimpy zapewnia dostęp do bezpłatnych punktów końcowych w celu uzyskania dostępu do danych świecowych w czasie rzeczywistym. Za każdym razem, gdy na giełdzie wykonywana jest nowa transakcja, świece są aktualizowane w czasie rzeczywistym. Te świece mogą być następnie odpytywane w regularnych odstępach czasu w celu wyświetlenia ich w interfejsie użytkownika aplikacji.

W poniższym przykładzie będziemy sondować najnowsze świece dla pary handlowej ETH / BTC na giełdzie Binance. Ten sam punkt końcowy może być używany na każdej innej głównej giełdzie, więc nie ma różnicy między korzystaniem z Binance a innymi giełdami.

import krewetek

importuj plotly.graph_objects jako go

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Zbierz historyczne dane świecowe

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

świece = client.get_candles (

‘binance’, # wymiana

„ETH”, # base_trading_symbol

„BTC”, # quote_trading_symbol

Interwał # 1d

)

daty = []

open_data = []

high_data = []

low_data = []

close_data = []

# Sformatuj dane, aby pasowały do ​​biblioteki wydruku

dla świec w świecach:

daty.append (świeca [‘czas’])

open_data.append (świeca [‘otwórz’])

high_data.append (candle [‘high’])

low_data.append (świeca [‘niski’])

close_data.append (świeca [‘zamknij’])

# Wykreśl świeczniki

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

open = open_data, high = high_data,

low = low_data, close = close_data)])

fig.show ()

Kładąc wszystko razem

Została nam tylko jedna rzecz do zrobienia. To wszystko, o czym rozmawialiśmy do tej pory, zostało zebrane w jednym scenariuszu. Ten skrypt będzie monitorował ticker dla pary BTC / USDT na Binance i przeprowadzi transakcję sprzedaży wszystkich Twoich BTC, gdy wartość BTC przekroczy 10000 USDT. To jest prosty przykład tego, jak można połączyć dane z gniazd internetowych w celu realizacji strategii handlowej.

import krewetek

czas importu

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Przypisz klucze giełdy, dla których chcesz uzyskać dostęp do danych salda

exchange_name = "binance"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# Utwórz klienta Websocket

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’])

# Utwórz użytkownika, który będzie powiązany z naszą giełdą

# Pomiń ten krok (lub użyj rozszerzenia "lista użytkowników" endpoint), jeśli już utworzyłeś użytkownika

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

user_id = create_user_response [‘id’]

# Połącz naszą pierwszą giełdę, abyśmy mogli uzyskać dostęp do danych salda

# Pomiń ten krok (lub użyj rozszerzenia "lista kont" punkt końcowy), jeśli konto zostało już połączone

link_account_response = api_client.link_account (

identyfikator użytkownika,

exchange_name,

exchange_public_key,

exchange_secret_key

)

account_id = link_account_response [‘id’]

# Poczekaj, aż Shrimpy zbierze dane do konta wymiany

# Wymagane tylko przy pierwszym łączeniu

time.sleep (5)

# Dostęp do danych salda dla wcześniej utworzonego konta użytkownika

balance = api_client.get_balance (

user_id, # user_id

account_id # account_id

)

btcAmount = 0

dla aktywów w saldzie [„salda”]:

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

btcAmount = asset [‘nativeValue’]

# To jest przykładowa obsługa, po prostu drukuje przychodzącą wiadomość na konsolę

def error_handler (err):

print (err)

# To jest przykładowa obsługa, po prostu drukuje przychodzącą wiadomość na konsolę

def handler (msg):

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

jeśli int (cena) > 10000:

smart_order_response = api_client.create_trade (

user_id, # user_id

account_id, # account_id

„BTC”, # from_symbol

„USDT”, # to_symbol

btcAmount # kwota from_symbol

True # włącz smart_routing

)

subscribe_data = {

"rodzaj": "Subskrybuj",

"Wymieniać się": "binance",

"para": "btc-usdt",

"kanał": "handel"}

# Rozpocznij przetwarzanie strumienia Shrimpy Websocket!

ws_client.connect ()

ws_client.subscribe (subscribe_data, handler)

Wnioski

Uzbrojeni w te skrypty, możliwe jest zbudowanie dowolnej liczby ekscytujących botów handlowych na Binance. Gdy odkryjesz więcej rzeczy na temat handlu i API Shrimpy Trading, możesz znaleźć inne przydatne punkty końcowe, takie jak punkty końcowe zleceń z limitem. Zapewniają one lepszą kontrolę nad zleceniami, które składasz na giełdzie.

Zachęcamy wszystkich do zapoznania się ze wszystkim, co oferujemy i przedstawienia sugestii w naszym Deweloper Telegram. Rynek kryptowalut jest ekscytujący, a to dopiero początek nowego sposobu handlu aktywami.

Krewetki to aplikacja do konstruowania niestandardowych funduszy indeksów kryptowalut, równoważenia i zarządzania zróżnicowanym portfelem aktywów cyfrowych. Zautomatyzuj swoje portfolio, łącząc się z dowolną z 16 obsługiwanych przez nas giełd kryptowalut.

Shrimpy’s Universal Crypto Exchange APIs są przeznaczone dla programistów. Integracja z naszymi ujednoliconymi interfejsami API zapewnia natychmiastowy dostęp do jednolitych punktów końcowych w celu handlu, gromadzenia danych, zarządzania użytkownikami i nie tylko na każdej większej giełdzie kryptowalut.

Aby uzyskać dostęp do wszystkich bibliotek Python i Node, skorzystaj z tych linków:

Węzeł

Pyton

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