Erstellen von Crypto Trading Bots mit Python | von ShrimpyApp | Die Hauptstadt | Oktober 2020

Die Entwicklung von Trading Bots muss nicht kompliziert sein.

Sie haben die anderen Tutorials gelesen. Das ist wahrscheinlich der Grund, warum Sie hier sind. Sie suchen einen einfacheren Weg. Anstelle eines kryptischen Tutorials mit Tausenden von Codezeilen, nur um eine Verbindung zu einem Austausch herzustellen, möchten Sie ein schnelles Skript und eine einfache Logik.

Sie sind am richtigen Ort.

Dieses Tutorial wird so vollständig wie möglich sein, aber die ersten Schritte können weniger als 15 Minuten dauern.

Einige der Themen, die wir behandeln werden, sind:

• Sammeln von Preis- und Handelsdaten für Vermögenswerte
• Zugriff auf Schnappschüsse von Umtauschauftragsbüchern
• Ein Exchange-Konto verknüpfen
• Abrufen von Kontostanddaten von einem Umtauschkonto
• Einen Handel ausführen
• Kartenleuchter bekommen

Im weiteren Verlauf dieses Tutorials werden wir genaue Beispiele und Beispielcodes bereitstellen, wie Sie schnell mit der Ausführung allgemeiner Funktionen mit Trading Bots beginnen können.

Hinweis: Der gesamte in diesem Artikel bereitgestellte Code dient nur zu Beispielzwecken. Der Code sollte nicht in der Produktion verwendet werden. Wir werden keine Fehlerbehandlung anbieten oder Best Practices für Produktionscode diskutieren.

Zweck der Verwendung von Handelsbots

Trading Bots sind ideal für die Automatisierung von Handelsstrategien, die sich nur schwer manuell implementieren lassen. Diese automatisierten Strategien können schnelle Marktbewegungen, präzise Auftragsausführung und spezifische Konfigurationen nutzen.

Manuelles Handeln ist im Nachteil. Im Zeitalter der Computer haben Trading Bots erhebliche Fortschritte gegenüber dem manuellen Handel. In diesem Tutorial werden Sie mit den Tools ausgestattet, mit denen Sie Ihr eigenes automatisiertes Handelssystem implementieren können.

Bevor wir mit dem Handel beginnen können, müssen wir die erforderlichen Bibliotheken installieren, API-Schlüssel erhalten und unser Setup konfigurieren. Wenn Sie das Setup zum ersten Mal durchlaufen, kann es sich umständlich anfühlen, aber wir werden schnell feststellen, dass die Entwicklung ein Kinderspiel ist, nachdem unsere Umgebung fertig ist.

Melden Sie sich für die Entwickler-APIs an

Mach mit bei der Universelle Crypto Exchange-APIs indem Sie sich für ein neues Konto anmelden.

Hinweis: Das Ausführen von Trades über die Entwickler-APIs ist mit dem möglich $ 19 / Monat "persönlicher" Zahlungsplan.

API-Schlüssel erstellen und sicher speichern

Wählen Sie in der Anwendungsoberfläche auf der Seite „API-Schlüssel“ die Option zum Erstellen eines API-Hauptschlüssels aus.

In einem Popup werden Sie aufgefordert, Ihr Passwort und Ihren 2FA-Code einzugeben. Wenn Sie 2FA noch nicht aktiviert haben, können Sie dies auf der Registerkarte "Einstellungen" tun.

Der letzte Überprüfungsschritt ist eine Nachricht, die an Ihre E-Mail gesendet wird. Klicken Sie auf den Link in der E-Mail, die gesendet wird, um die Erstellung der API-Schlüssel zu überprüfen.

Ihre Entwickler-API-Schlüssel werden sichtbar, sobald Sie auf den an Ihre E-Mail gesendeten Link klicken.

Hinweis: Der öffentliche API-Schlüssel wird standardmäßig angezeigt, der private Schlüssel ist jedoch ausgeblendet. Nachdem Sie den privaten Schlüssel ausgewählt haben, wird der private Schlüssel nie wieder angezeigt. Stellen Sie sicher, dass Ihre API-Schlüssel sicher an einem sicheren Ort aufbewahrt werden. Wenn ein Teil Ihres Schlüssels verloren geht, können Sie jederzeit einen neuen Schlüssel von Grund auf neu erstellen.

Zeigen Sie diese API-Schlüssel niemals jemandem, es sei denn, Sie möchten, dass sie die vollständige Kontrolle über Ihr Konto haben.

Schließlich gibt es nur noch einen Schritt zum Einrichten unserer API-Schlüssel. In diesem Schritt werden alle für die API-Schlüssel möglichen Berechtigungen aktiviert. Diese Berechtigungen können später geändert werden. Für dieses Lernprogramm müssen jedoch alle Berechtigungen aktiviert sein.

Nachdem wir unsere API-Schlüssel erfolgreich eingerichtet haben, abonnieren wir den "persönlichen" Plan für 19 US-Dollar pro Monat. Dies ist erforderlich, um die Trades in diesem Tutorial auszuführen.

Das war's für das API-Schlüssel-Setup!

Richten Sie Ihre Python-Umgebung ein

Nachdem wir unsere API-Schlüssel haben, ist es Zeit, unsere Python-Umgebung einzurichten. Beginnen Sie mit der Installation einer beliebigen Version von Python 3. Installieren Sie nach der Installation von Python 3 die Shrimpy Python Library, indem Sie den folgenden Befehl ausführen.

pip install shrimpy-python

Es gibt einige andere Bibliotheken, die wir für die verschiedenen Tutorial-Skripte benötigen. Installieren Sie zusätzlich zur Shrimpy Python Library Pandas und Plotly.

pip install pandas
pip install plotly==4.1.0

Erstellen Sie unsere Exchange-API-Schlüssel

Richtig, es gibt weitere API-Schlüssel, die wir benötigen, bevor wir an einer Börse handeln. Zusätzlich zu den Shrimpy-API-Schlüsseln müssen beim Austausch unserer Wahl API-Schlüssel erstellt werden.

Keine Sorge, sobald diese Schlüssel mit Shrimpy verbunden sind, müssen wir sie nicht mehr behalten. Shrimpy verwaltet unsere API-Schlüssel automatisch für uns, sodass wir kein eigenes API-Schlüsselverwaltungssystem implementieren müssen.

Das Erstellen eines Exchange-API-Schlüssels sollte in Ihrem Exchange-Konto erfolgen. Hier finden Sie Tutorials zum Zugriff auf API-Schlüssel von jedem Austausch.

Nachdem Sie den Schritt erreicht haben, in dem der API-Schlüssel aus dem Austausch kopiert wird, können Sie den Hilfeartikel zu diesem Zeitpunkt nicht mehr befolgen und zu diesem Artikel zurückkehren. Stellen Sie sicher, dass Sie Ihre Exchange-API-Schlüssel sicher gespeichert haben, damit wir sie bei Bedarf in unsere Python-Skripte einbinden können.

Unser Setup ist abgeschlossen, es ist also Zeit, Code zu schreiben! Dies ist der aufregende Teil. Schnallen Sie sich an und machen Sie sich bereit, Ihre Kryptowährung zu automatisieren.

Kommentar: Ihr Shrimpy API-Schlüssel sollte sicher aufbewahrt werden, wo Sie darauf zugreifen können. Wenn Sie die folgenden Zeilen in einem Skript sehen, sollten Sie das… durch Ihr tatsächliches ersetzen Shrimpy API-Schlüssel. Beachten Sie, dass das Wort "Secret" beim Verweisen auf API-Schlüssel mit "Private" austauschbar ist.

shrimpy_public_key = '...'
shrimpy_secret_key = '...'

Kommentar: Ihr API-Schlüssel austauschen sollte sicher aufbewahrt werden, wo Sie darauf zugreifen können. Wenn Sie die folgenden Zeilen in einem Skript sehen, sollten Sie das… durch Ihr tatsächliches ersetzen API-Schlüssel austauschen. Beachten Sie, dass das Wort "Secret" beim Verweisen auf API-Schlüssel mit "Private" austauschbar ist.

exchange_public_key = '...'
exchange_secret_key = '...'

Sammeln Sie Preisdaten von der Börse

Wir werden zunächst die Skripte behandeln, die Sie benötigen, um mit dem Sammeln von Daten aus dem Austausch zu beginnen.

Obwohl der Handel unser oberstes Ziel ist, benötigen wir Daten, um zu entscheiden, wann der geeignete Zeitpunkt für den Handel ist. Es ist auch erforderlich, Auftragsbuchdaten zu haben, um die genaue Bestellung zu berechnen, die wir aufgeben möchten.

Einfache Preis-Ticker-Daten erhalten

Wenn keine Präzision erforderlich ist, können wir den Tickerpreis verwenden. Der einfache Preisticker ist ideal für Anzeigezwecke und um einen allgemeinen Überblick über den Preis eines Vermögenswerts zu erhalten.

Der einfache Preisticker sollte nicht verwendet werden, um Handelsentscheidungen zu treffen.

import shrimpyshrimpy_public_key = '...'
shrimpy_secret_key = '...'client = shrimpy.ShrimpyApiClient(shrimpy_public_key, shrimpy_secret_key)ticker = client.get_ticker('binance')

Nachdem Sie dieses Skript gesehen haben, fragen Sie sich möglicherweise: „Das ist es?”.

Das ist es sicher!

Erhöhen wir die Intensität, indem wir mithilfe von Websockets direkt in ein Preis-Ticker-Beispiel eintauchen.

Erhalten eines Live-Preistickers mithilfe von Websockets

Die Handelswebsockets können verwendet werden, um einen Live-Preis-Feed für Vermögenswerte zu erhalten. Diese Live-Updates sind die genauen Trades, die an der Börse ausgeführt werden. Diese Live-Daten kann verwendet werden, um zu entscheiden, wann gehandelt werden soll.

Da der Prozess zum Herstellen einer Verbindung zu Websockets etwas aufwändiger ist, ist das Skript für Live-Aktualisierungen der Websocket-Preise etwas länger als im vorherigen Beispiel.

import shrimpyshrimpy_public_key = '...'
shrimpy_secret_key = '...'# This is a sample handler, it simply prints the incoming message to the console
def error_handler(err):
print(err)# This is a sample handler, it simply prints the incoming message to the console
def handler(msg):
print(msg('content')(0)('price'))api_client = shrimpy.ShrimpyApiClient(shrimpy_public_key, shrimpy_secret_key)
raw_token = api_client.get_token()
client = shrimpy.ShrimpyWsClient(error_handler, raw_token('token'))subscribe_data = {
"type": "subscribe",
"exchange": "binance",
"pair": "ltc-btc",
"channel": "trade"
}# Start processing the Shrimpy websocket stream!
client.connect()
client.subscribe(subscribe_data, handler)# Once complete, stop the client
client.disconnect()

Hinweis: Die Zeile "client.disconnect ()" sollte aufgerufen werden, nachdem Sie alle Daten über den Websocket gesammelt haben. Wenn Sie dieses Skript unverändert ausführen, wird der Websocket direkt nach dem Herstellen der Verbindung getrennt. Entfernen Sie diese Zeile, bevor Sie das Skript ausführen.

Dieses Skript war mehr involviert, aber nicht viel. In den folgenden Beispielen werden wir mit Datenskripten fortfahren, die Live-Auftragsbücher sammeln. Ein Auftragsbuch enthält die genauen Bestellungen, die an der Börse verfügbar sind.

Auftragsbücher sind für den Handel erforderlich, daher sind diese nächsten Beispiele wichtig zu verstehen.

Schnappschuss des Live-Auftragsbuchs

Mit den restlichen Endpunkten können wir den neuesten Schnappschuss des Auftragsbuchs abrufen. Dies ist ideal für Personen, die keine Verbindung zum Orderbuch-Websocket herstellen können, aber dennoch handeln möchten.

import shrimpyshrimpy_public_key = '...'
shrimpy_secret_key = '...'client = shrimpy.ShrimpyApiClient(shrimpy_public_key, shrimpy_secret_key)orderbooks = client.get_orderbooks(
'bittrex',  # exchange
'XLM',      # base_symbol
'BTC',      # quote_symbol
10          # limit
)

So einfach ist das!

Sie können jetzt die verfügbaren Bestellungen an der Börse anzeigen.

Live-Aktualisierungen des Auftragsbuchs über einen Websocket

Da der Endpunkt für Orderbuch-Snapshots erfordern würde, dass Ihr Handelsbot ständig nach den neuesten Updates fragt, ist es möglicherweise einfacher, den Websocket zu abonnieren und eine lokale Kopie des Orderbuchs kontinuierlich zu aktualisieren.

Jedes Mal, wenn sich das Auftragsbuch ändert, sendet Shrimpy sofort Updates über den Websocket. So bleiben Sie immer auf dem Laufenden.

import shrimpyshrimpy_public_key = '...'
shrimpy_secret_key = '...'# This is a sample handler, it simply prints the incoming message to the console
def error_handler(err):
print(err)# This is a sample handler, it simply prints the incoming message to the console
def handler(msg):
print(msg)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": "subscribe",
"exchange": "binance",
"pair": "eth-btc",
"channel": "orderbook"
}# Start processing the Shrimpy websocket stream!
ws_client.connect()
ws_client.subscribe(subscribe_data, handler)# Once complete, stop the client
ws_client.disconnect()

Hinweis: Die Zeile "client.disconnect ()" sollte aufgerufen werden, nachdem Sie alle Daten über den Websocket gesammelt haben. Wenn Sie dieses Skript unverändert ausführen, wird der Websocket direkt nach dem Herstellen der Verbindung getrennt. Entfernen Sie diese Zeile, bevor Sie das Skript ausführen.

In diesen Beispielen wird nicht erläutert, wie das Auftragsbuch verwaltet wird. Daher müssen Sie Ihre eigene Strategie für die Verwaltung der lokalen Kopie des Auftragsbuchs bei Verwendung des Websockets entwickeln.

Stellen Sie eine Verbindung zu Ihrem Exchange-Konto her

Wir nähern uns dem Handel. Bevor wir handeln können, müssen wir unser Umtauschkonto mit Shrimpy verbinden. Zu Beginn dieses Tutorials haben Sie einen API-Schlüssel für Ihren bevorzugten Austausch erstellt. Dies ist die Zeit, um herauszufinden, wo Sie diese Schlüssel sicher aufbewahrt haben.

Dieses Skript verbindet Ihr Exchange-Konto mit Shrimpy, sodass Ihr Konto über Shrimpy verwaltet werden kann. Nachdem dieses Skript einmal für Ihr Exchange-Konto ausgeführt wurde, müssen Sie es nicht erneut ausführen.

# import required libraries
import shrimpy# assign your Shrimpy Master API keys for later use
shrimpy_public_key = '...'
shrimpy_secret_key = '...'# assign your exchange keys for which you wish to access the balance data
exchange_name = "bittrex"
exchange_public_key = '...'
exchange_secret_key = '...'# create the Shrimpy client
client = shrimpy.ShrimpyApiClient(shrimpy_public_key, shrimpy_secret_key)# create a user which will be linked to our exchange
create_user_response = client.create_user('The Shrimp Master')
user_id = create_user_response('id')# link our first exchange so we can access balance data
link_account_response = client.link_account(
user_id,
exchange_name,
exchange_public_key,
exchange_secret_key
)account_id = link_account_response('id')

Wenn Sie dieses Skript mehrmals ausführen, wird dasselbe Exchange-Konto mehrmals verknüpft. Das wollen wir nicht. Führen Sie dieses Skript daher nur einmal für jedes Exchange-Konto aus.

Möglicherweise stellen Sie auch fest, dass wir in diesem Skript einen „Benutzer“ erstellt haben. Wir möchten nur einen "Benutzer" erstellen, führen Sie diese Zeilen also nicht mehr als einmal aus.

In diesem ausführlichen Artikel erfahren Sie mehr über Benutzer.

Kontostand abrufen

Wir müssen nicht nur entscheiden, wann und zu welchem ​​Preis gehandelt werden soll, sondern auch wissen, wie viel wir können handeln. Dies wird durch die Erfassung unserer Saldodaten aus der Börse ermittelt.

Da wir zuvor unser Exchange-Konto mit Shrimpy verknüpft und einen Benutzer erstellt haben, können wir Informationen zu unserem Konto abrufen.

import shrimpy# use your Shrimpy API public and private keys to create the client
shrimpy_public_key = '...'
shrimpy_secret_key = '...'client = shrimpy.ShrimpyApiClient(shrimpy_public_key, shrimpy_secret_key)# note: since we created a user in our last example script, 
# we can just retrieve our list of users.
users = client.list_users()
first_user_id = users(0)('id')# retrieve the accounts associated with this user
accounts = client.list_accounts(
first_user_id
)
first_account_id = accounts(0)('id')# access balance data for the user account you previously created
balance = client.get_balance(
first_user_id,   # user_id
first_account_id # account_id
)

Da haben wir es, wir haben jetzt genug Informationen, um Trades zu machen!

Ausführung einer Smart Market Order an der Börse

Denken Sie daran, dass dies nur Beispiele sind, bevor wir unseren ersten Trade ausführen. Das Ausführen dieser Beispiele führt dazu, dass tatsächliche Trades auf Ihrem Konto ausgeführt werden. Das heißt du werden Handelsgebühren anfallen, möglicherweise Geld verlieren, wenn der von Ihnen gekaufte Vermögenswert an Wert verliert, und andere mit dem Handel verbundene Risiken.

Die bereitgestellten Skripte dienen beispielsweise Zwecken und sind nicht für die Produktion geeignet.

Warnung: Das folgende Skript wird verkauft alles Sie besitzen an der Börse und kaufen Bitcoin. Wenn Sie nicht möchten, dass dies auf Ihrem Konto geschieht, unterlassen Sie Führen Sie dieses Skript aus.

import shrimpy# use your Shrimpy API public and private keys to create the client
shrimpy_public_key = '...'
shrimpy_secret_key = '...'client = shrimpy.ShrimpyApiClient(shrimpy_public_key, shrimpy_secret_key)# note: since we created a user in our last example script, 
# we can just retrieve our list of users.
users = client.list_users()
first_user_id = users(0)('id')# retrieve the accounts associated with this user
accounts = client.list_accounts(
first_user_id
)
first_account_id = accounts(0)('id')# access balance data for the user account you previously created
balance = client.get_balance(
first_user_id,   # user_id
first_account_id # account_id
)holdings = balance('balances')# select the asset for which you would like to consolidate
consolidation_symbol = 'BTC'# sell every asset besides the consolidation asset
for asset in holdings:
asset_symbol = asset('symbol')
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
)

Trades mit Smart Order Routing ausführen

Die Entwicklung des Handels ist intelligentes Order Routing. Anstatt einfach Marktaufträge an der Börse zu platzieren, um Geld zu bewegen, bietet Shrimpy eine integrierte Smart Order Routing-Infrastruktur.

On-Demand-Smart-Order-Routing ist ein Meilenstein für die Kryptowährungsbranche. Das nächste Skript zeigt also, wie einfach die Verwendung ist.

import shrimpy# use your Shrimpy API public and private keys to create the client
shrimpy_public_key = '...'
shrimpy_secret_key = '...'client = shrimpy.ShrimpyApiClient(shrimpy_public_key, shrimpy_secret_key)# note: since we created a user in our last example script, 
# we can just retrieve our list of users.
users = client.list_users()
first_user_id = users(0)('id')# retrieve the accounts associated with this user
accounts = client.list_accounts(
first_user_id
)
first_account_id = accounts(0)('id')# access balance data for the user account you previously created
balance = client.get_balance(
first_user_id,   # user_id
first_account_id # account_id
)# execute a market order
smart_order_response = client.create_trade(
first_user_id,    # user_id
first_account_id, # account_id
'BTC',            # from_symbol
'ETH',            # to_symbol
'0.01'            # amount of from_symbol
True              # enable smart_routing
)

Hinweis: Die einzige Änderung, die für die Auftragserteilung vorgenommen wurde, bestand darin, "Smart Order Routing" auf "True" zu setzen.

Dieses Skript leitet Ihre Bestellungen auf intelligente Weise von einem Asset zu einem anderen weiter. So einfach ist das.

Das ist alles, was wir für die Handelsbeispiele haben. Bevor wir diese Beispiel-Tutorials schließen, schauen wir uns an, wie wir Charting-Kerzenhalter sammeln können.

Sammeln von Kerzen für die Darstellung der Vermögenspreise

Händler, die entscheiden, wann sie handeln möchten, wenden sich häufig Candlestick-Charts zu. Diese Diagramme geben einen Überblick darüber, wie sich der Preis eines Vermögenswerts im Laufe der Zeit verändert hat. Der Zugriff auf diese Daten über die Shrimpy-APIs ist ebenfalls einfach.

import shrimpy
import plotly.graph_objects as go# sign up for the Shrimpy Developer APIs for your free API keys
shrimpy_public_key = '...'
shrimpy_secret_key = '...'# collect the historical candlestick data
client = shrimpy.ShrimpyApiClient(shrimpy_public_key, shrimpy_secret_key)
candles = client.get_candles(
'bittrex', # exchange
'XRP',     # base_trading_symbol
'BTC',     # quote_trading_symbol
'1d'       # interval
)dates = ()
open_data = ()
high_data = ()
low_data = ()
close_data = ()# format the data to match the plotting library
for candle in candles:
dates.append(candle('time'))
open_data.append(candle('open'))
high_data.append(candle('high'))
low_data.append(candle('low'))
close_data.append(candle('close'))# plot the candlesticks
fig = go.Figure(data=(go.Candlestick(x=dates,
open=open_data, high=high_data,
low=low_data, close=close_data)))
fig.show()

Im obigen Beispiel werden die Diagrammleuchter mithilfe der Plotbibliothek gezeichnet.

Nachdem wir nun Zugriff auf all diese verschiedenen Endpunkte und Handelsoptionen haben, stellen wir alles für ein letztes Beispielskript zusammen.

Ein letztes Beispielskript zusammenstellen

Das endgültige Skript bewertet das BTC / USDT-Handelspaar und führt einen Handel aus, wenn Bitcoin 11.000 USDT erreicht.

import shrimpy
import timeshrimpy_public_key = '...'
shrimpy_secret_key = '...'# assign your exchange keys for which you wish to access the balance data
exchange_name = "bittrex"
exchange_public_key = '...'
exchange_secret_key = '...'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'))# create a user which will be linked to our exchange
# skip this step if you've already created a user
create_user_response = api_client.create_user('The Shrimp Master')
user_id = create_user_response('id')# link our first exchange so we can access balance data
# skip this step if you've already linked an account
link_account_response = api_client.link_account(
user_id,
exchange_name,
exchange_public_key,
exchange_secret_key
)account_id = link_account_response('id')# wait while Shrimpy collects data for the exchange account
# only required the first time linking
time.sleep(5)# access balance data for the user account you previously created
balance = api_client.get_balance(
user_id,   # user_id
account_id # account_id
)btcAmount = 0for asset in balance('balances'):
if asset('symbol') = 'BTC':
btcAmount = asset('nativeValue')# This is a sample handler, it simply prints the incoming message to the console
def error_handler(err):
print(err)# This is a sample handler, it simply prints the incoming message to the console
def handler(msg):
price = msg('content')(0)('price')
if int(price) > 11000:
smart_order_response = api_client.create_trade(
user_id,    # user_id
account_id, # account_id
'BTC',            # from_symbol
'USDT',           # to_symbol
btcAmount         # amount of from_symbol
True              # enable smart_routing
)subscribe_data = {
"type": "subscribe",
"exchange": "binance",
"pair": "btc-usdt",
"channel": "trade"
}# Start processing the Shrimpy websocket stream!
ws_client.connect()
ws_client.subscribe(subscribe_data, handler)

Erinnerung: Diese Skripte dienen nur zu Beispielzwecken. Es handelt sich nicht um Skripte für die Produktion, die in einer vollständigen Anwendung verwendet werden sollten. Wir müssen daran denken, Randfälle, Fehler und Fehlerzustände zu behandeln. Dieses Skript macht keines dieser Dinge.

Wir haben nicht genügend Beispiele, um mit der Entwicklung unseres kompletten Handelsbots zu beginnen. Verwenden Sie diese Skripte als Referenzmaterial, wenn Sie anfangen, um eine Vorstellung davon zu erhalten, wie Sie mit den Shrimpy Developer-APIs auf Daten zugreifen und Trades ausführen können.

Genießen Sie die Einfachheit der APIs und verhindern Sie, dass Sie bei jedem Austausch Probleme mit der Integration der Infrastruktur haben.

Weitere Informationen zu den APIs finden Sie auf der Website Universal Crypto Trading APIs.