Sådan oprettes en Crypto Trading Bot til Binance (Brug af Python)

>

Binance og handelsbots.

Verden har ikke set en mere ikonisk duo siden Bert og Ernie. Den legendariske børs er blevet oversvømmet med automatiserede handelsbots af alle slags. Institutioner og enkeltpersoner med høj nettoværdi udfører avancerede algoritmiske handelsstrategier, mens investorer automatiserer deres portefølje. Det er blevet en spændende legeplads for bygherrer.

Alligevel er der stadig meget at bygge. Kun en brøkdel af de nødvendige tjenester er udviklet indtil dette tidspunkt, og der vil være stor vækst i det kommende år.

Hvis du vil komme i gang med at deltage i udviklingen af ​​handelsbots, er dette det bedste sted at starte. I hele denne artikel vil vi lære dig, hvordan du får adgang til markedsdata fra børsen, opretter forbindelse til udvekslingskonti for at læse saldodata, udfører handler, kortlægger lysestager og endda opretter forbindelse til realtids-websockets for ticker-data.

Der er meget at dække, så lad os komme i gang!

Kom godt i gang

Følgende trin nedbryder de nødvendige komponenter for at begynde at programmere dine Binance Python-scripts.

Installation af Shrimpy Python

Først skal vi installere Shrimpy Python Library. Den officielle Shrimpy Python GitHub kan findes her.

Ved hjælp af Pip kan du hurtigt installere biblioteket ved hjælp af følgende.

pip installere rejer-python

Binance API-nøgler

For at oprette forbindelse til Binance-udvekslingen skal vi generere en ny API-nøgle gennem udvekslingen. Dette kan gøres ved at følge artikel om Binance API-nøglehjælp.

Når du er kommet til det trin, hvor du kopierer API-nøglerne ud af Binance, kan du stoppe og gemme dem et sikkert sted (i stedet for at indsætte dem i Shrimpy Portfolio Management Application). Disse nøgler vil blive brugt i vores scripts ved at tildele dem til en variabel, som vi kan overføre til vores klient, når den oprettes.

exchange_public_key = ‘…’

exchange_secret_key = ‘…’

Rejer API-nøgler

Efter udveksling af API-nøgler er oprettet, skal vi også generere API-nøgler til Shrimpy Universal Crypto Trading API’er. Disse nøgler genereres ved at tilmelde dig Shrimpy Developer API’er derefter følge guiden beskrevet her.

Når nøglerne er oprettet, skal du gemme dem et sikkert sted og bruge dem i dine Python-scripts på følgende måde.

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

Udveksle data

At få nøjagtige markedsdata er det første skridt til at skabe en crypto trading bot, der kan udføre strategier baseret på signaler, markedsforhold og prisbevægelser.

Dette gøres typisk ved hjælp af både live ordrebogsdata og handelsdata. I de følgende afsnit giver vi eksempler på, hvordan man samler begge disse typer information gennem websockets og REST API’er.

Pris Ticker

En pris ticker er noget, der opdaterer prisen på et ensartet grundlag for at få den seneste pris på aktivet på en børs. De følgende eksempler præsenterer et par eksempler på, hvordan man opretter og får adgang til pris tickers.

En simpel pris ticker

Dette eksempel giver et script til den mest enkle slags pris ticker. Denne ticker bruger REST API-opkald til at få adgang til prisdata på børsen. Dette slutpunkt opdateres med et minuts interval, så det betyder, at den højest mulige frekvens for opdatering af tickeren i dette eksempel er 1 minut.

importere rejer

# Tildel offentlige og hemmelige Shrimpy Master API-nøgler

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Opret Shrimpy REST API-klienten

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Anmod om ticker for alle aktiver på Binance

ticker = client.get_ticker (‘binance’)

Ticker til websocketpris

Mere kompleks end den enkle pris ticker er realtids websocket ticker. Denne ticker udnytter real-time websockets for at holde sig opdateret med den nyeste pris på børsen.

I modsætning til den enkle pris ticker, der opdateres med et minuts interval, opdateres denne pris ticker med det samme. Så snart prisen ændres på børsen, sender websocket opdateringen, og den nye pris modtages af dette script til visning.

importere rejer

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Dette er en prøvehåndterer, den udskriver simpelthen den indgående besked til konsollen

def error_handler (err):

udskrive (fejle)

# Dette er en prøvehåndterer, den udskriver simpelthen den indgående besked til konsollen

def handler (msg):

udskriv (msg [‘indhold’] [0] [‘pris’])

# Opret websocket-klienten ved hjælp af det rå token, der er hentet af REST API

api_client = rejer.ShrimpyApiClient (rejer_offentlig_nøgle, rejer_sekret_nøgle)

raw_token = api_client.get_token ()

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

# Abonnementsdata for websocket

subscribe_data = {

"type": "abonnere",

"udveksling": "binance",

"par": "eth-btc",

"kanal": "handle"}

# Start behandlingen af ​​Shrimpy websocket-strømmen!

client.connect ()

client.subscribe (subscribe_data, handler)

# Når du er færdig, skal du stoppe klienten

client.disconnect ()

Udveksle ordrebøger

Præcise ordrebøger på en børs bruges af handlende og kryptobots til at bestemme den nøjagtige ordre, de gerne vil placere på børsen.

Når du afgiver ordrer, er det altid gavnligt at have opdateringer i realtid til ordrebogen. På den måde tager du altid beslutninger baseret på de mest opdaterede oplysninger.

Simpelt øjebliksbillede af Live Order Book

Den mest enkle måde at få adgang til en børs ordrebøger er at anmode om ordrebogen på det tidspunkt, du skal placere en ordre.

For eksempel, hvis du vil udføre en handel på ETH / BTC-handelsparret, kan du anmode om at få den nyeste ordrebog til dette marked ved at ringe til REST API.

importere rejer

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Opret API-klienten til REST-opkald

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Hent live ordrebogen

ordrebøger = client.get_orderbooks (

‘binance’, # udveksling

‘ETH’, # base_symbol

‘BTC’, # quote_symbol

10 # grænse

)

Websocket Live ordrebog

I mere avancerede scenarier ville det være ideelt at vedligeholde en lokal kopi af ordrebogen, der opdateres i realtid via websockets. Dette kan gøres ved hjælp af ordrebogen websocket, der er tilgængelig via websocket API’erne.

Forbindelse til ETH / BTC-paret vil se ud som det følgende eksempel.

importere rejer

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Dette er en prøvehåndterer, den udskriver simpelthen den indgående besked til konsollen

def error_handler (err):

udskrive (fejle)

# Dette er en prøvehåndterer, den udskriver simpelthen den indgående besked til konsollen

def handler (msg):

udskrive (msg)

# Opret websocket-klienten ved at få det rå token.

api_client = rejer.ShrimpyApiClient (rejer_offentlig_nøgle, rejer_sekret_nøgle)

raw_token = api_client.get_token ()

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

subscribe_data = {

"type": "abonnere",

"udveksling": "binance",

"par": "eth-btc",

"kanal": "ordrebog"}

# Start behandlingen af ​​Shrimpy websocket-strømmen!

ws_client.connect ()

ws_client.subscribe (subscribe_data, handler)

# Når du er færdig, skal du stoppe klienten

ws_client.disconnect ()

Bemærk, at dette eksempel ikke beskriver, hvordan man styrer ordrebogen lokalt, men kun hvordan man får adgang til dataene via websocket. Organiseringen af ​​data skal ske gennem brugerdefineret kode baseret på, hvordan du vil administrere bøgerne.

I det væsentlige kræver administration af bøgerne en måde at holde styr på bogens aktuelle tilstand. På den måde kan du indsætte nye ordrer, opdatere gamle ordrer og slette ordrer efter behov baseret på opdateringerne via websocket.

Forbindelse til Exchange-konto

For at kunne handle har vi brug for adgang til en vekselkonto. Denne udvekslingskonto vil blive brugt til at indsamle data om de tilgængelige saldi og udføre handelsstrategien.

Tilknytning af en Binance-konto

Shrimpy giver et praktisk brugerstyringssystem, hvor du kan linke individuelle Binance-konti til brugere. Hver bruger kan opretholde op til 20 udvekslingskonti. På den måde kan alle dine byttekonti styres sammen.

Det er en engangshændelse at linke en vekselkonto til Shrimpy. Det betyder, at når først kontoen er blevet linket, opretholder Shrimpy forbindelsen til børsen for den konto og ikke kræver genlinkning i fremtiden. Du kan altid hente dine sammenkædede konti ved at angive de konti, der er knyttet til en bruger.

I dette eksempel opretter vi vores første bruger og linker derefter udvekslingskontoen. Når du opretter din første bruger, skal du lade være med har brug for at oprette en anden bruger igen. Du kan altid få adgang til dine brugere ved at angive de brugere, du har oprettet.

# import krævede biblioteker

importere rejer

# tildel dine Shrimpy Master API-nøgler til senere brug

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# tildel dine udvekslingsnøgler, som du ønsker at få adgang til balancedataene for

exchange_name = "binance"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# Opret Shrimpy-klienten

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Opret en bruger, der vil blive linket til vores udveksling

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

user_id = create_user_response [‘id’]

# link vores første udveksling, så vi kan få adgang til balancedata

link_account_response = client.link_account (

bruger ID,

udvekslingsnavn,

exchange_public_key,

exchange_secret_key

)

account_id = link_account_response [‘id’]

Henter saldoer på Binance-konti

Så snart kontoen er linket, begynder Shrimpy at indsamle data fra børsen vedrørende udvekslingskontoen. Dette kan tage op til 5 sekunder, så vi anbefaler at vente et par sekunder (kun på den oprindelige sammenkædning), inden du bruger det næste script til at få adgang til saldodataene for den udvekslingskonto, der var linket.

Når dataene er indsamlet, opdaterer Shrimpy løbende saldoen, når handler udføres, indskud eller udbetalinger foretages, og andre handlinger udføres på kontoen.

I dette eksempel demonstrerer vi, hvordan du henter Binance-kontosaldoen.

importere rejer

# brug din Shrimpy API offentlige og private nøgler til at oprette klienten

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# note: da vi oprettede en bruger i vores sidste eksempel-script,

# vi kan bare hente vores liste over brugere.

brugere = client.list_users ()

first_user_id = brugere [0] [‘id’]

# hent de konti, der er knyttet til denne bruger

konti = client.list_accounts (

første_bruger_id

)

first_account_id = konti [0] [‘id’]

# adgangsbalancedata for den brugerkonto, du tidligere har oprettet

balance = klient.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

Læg mærke til, hvordan vi brugte slutpunkterne til at “liste brugere” og “listekonti”. Hvis du allerede har konto- og bruger-id’erne, kan du blot indtaste disse værdier også uden at hente dem hver gang.

Udførelse af en handel på binance

Udveksling kan være kompliceret. Forvirrende dokumentation, inkonsekvente handelsregler og uoverensstemmelser på tværs af slutpunkter kan få udviklingsprocessen til at være kaotisk.

I de følgende eksempler vil vi nedbryde nogle af de mest enkle måder at udføre handler på Binance på. Uden nogen kompleks logik kan Shrimpy hjælpe dig med at udføre en ordre på hver større børs på en identisk måde.

Enkel handel

Den mest enkle måde at udføre en handel med Shrimpy på er at bruge slutpunktet “Opret handel”. Alt dette slutpunkt kræver er de relevante konto-id’er og de to aktiver, du vil handle “fra” og “til”.

Det vil se ud som det følgende.

create_trade_response = client.create_trade (

user_id, # Brugerens id

account_id, # ID’et for den konto, der er knyttet til brugeren

from_symbol, # Det aktiv, du vil sælge

til_symbol, # Det aktiv, du vil købe

from_native_amount # Hvor meget af "fra" aktiv, du vil sælge

)

Resultatet er en enkel måde at købe og sælge aktiver uden at bekymre sig om detaljerne i, hvordan handlerne udføres. Du behøver ikke placere individuelle grænseordrer, bestemme forskellige handelspar eller manuelt dirigere aktiverne gennem forskellige tilbudsvalutaer. Rejer tager sig af alt.

Vi kan derefter sætte dette slutpunkt i arbejde ved at sætte det i et eksempel på et script. I dette eksempel vil vi undersøge alle de aktiver, du har på børsen. Vi gentager derefter listen over aktiver, du ejer, og sælger dem alle til et konsolideringsaktiv (i dette tilfælde BTC).

HOLD OP! At køre dette script vil bogstaveligt talt sælge alt hvad du ejer på børsen og købe BTC. Dette er ikke et hypotetisk script, dette er et rigtigt eksempel, der udfører rigtige handler på din rigtige valutakonto. Kør ikke scriptet, hvis du ikke vil sælge alt, hvad du ejer, til Bitcoin.

importere rejer

# Brug din Shrimpy API offentlige og private nøgler til at oprette klienten

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Bemærk: da vi oprettede en bruger i vores sidste eksempel-script,

# Vi kan bare hente vores liste over brugere.

brugere = client.list_users ()

first_user_id = brugere [0] [‘id’]

# Hent de konti, der er knyttet til denne bruger

konti = client.list_accounts (

første_bruger_id

)

first_account_id = konti [0] [‘id’]

# Få adgang til saldodata for den brugerkonto, du tidligere har oprettet

balance = klient.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

beholdninger = balance [‘saldi’]

# Vælg det aktiv, som du vil konsolidere for

consolidation_symbol = ‘BTC’

# Sælg hvert aktiv udover konsolideringsaktivet

for aktiv i beholdninger:

asset_symbol = aktiv [‘symbol’]

asset_amount = aktiv [‘nativeValue’]

hvis aktiv_symbol! = konsolideringssymbol:

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

create_trade_response = client.create_trade (

første_bruger_id,

første_konto_id,

aktiv_symbol,

konsolideringssymbol,

aktiv_beløb

)

Smart ordrerute

I det foregående eksempel brugte vi ingen intelligent routing. I det væsentlige vil Shrimpy identificere aktivet “fra” og “til” og derefter sælge “fra” aktivet til BTC og derefter købe “til” aktivet fra BTC. Dette kan være ineffektivt, hvis der er alternative prisvalutaer, som aktivet kan bruge.

I mange tilfælde ville det være ideelt at bruge indstillingen til smart ordrerute. Dette enkle flag fortæller Shrimpy at evaluere alle mulige ruter, når vi beslutter, hvordan vi skal handle “fra” aktivet og erhverve “til” aktivet.

importere rejer

# Brug din Shrimpy API offentlige og private nøgler til at oprette klienten

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Bemærk: da vi oprettede en bruger i vores sidste eksempel-script,

# Vi kan bare hente vores liste over brugere.

brugere = client.list_users ()

first_user_id = brugere [0] [‘id’]

# Hent de konti, der er knyttet til denne bruger

konti = client.list_accounts (

første_bruger_id

)

first_account_id = konti [0] [‘id’]

# Få adgang til saldodata for den brugerkonto, du tidligere har oprettet

balance = klient.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

# Udfør en markedsordre

smart_order_response = client.create_trade (

first_user_id, # user_id

første_konto_id, # konto_id

‘BTC’, # fra_symbol

‘ETH’, # til_symbol

‘0,01’ # mængde fra_symbol

True # aktiver smart_routing

)

Læg mærke til, hvordan den eneste forskel er det ekstra flag i anmodningen om at aktivere smart routing og indstille den til “True”.

Kortlægning af lysestager

Opbygning af en applikation med en brugergrænseflade betyder, at vi har brug for andre komponenter for at illustrere brugernes aktuelle markedstilstand. Et eksempel på data, som brugeren muligvis ønsker at modtage, er lysestage-diagrammer.

Lysestakskort hjælper handlende med at beslutte, hvornår de skal købe eller sælge et aktiv.

Shrimpy giver adgang til gratis slutpunkter for at få adgang til lysestage-data i realtid. Hver gang en ny handel udføres på børsen, opdateres lysestagerne i realtid. Disse lysestager kan derefter polles med jævne mellemrum for at vise dem i brugergrænsefladen i din applikation.

I det følgende eksempel afstemmer vi de seneste lysestager til ETH / BTC-handelsparret på Binance-børsen. Det samme slutpunkt kan bruges til enhver anden større udveksling, så der er ingen forskel mellem at bruge Binance og andre udvekslinger.

importere rejer

import plotly.graph_objects as go

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Saml de historiske lysestage-data

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

stearinlys = client.get_candles (

‘binance’, # udveksling

‘ETH’, # base_trading_symbol

‘BTC’, # quote_trading_symbol

‘1d’ # interval

)

datoer = []

open_data = []

high_data = []

lave data = []

close_data = []

# Formater dataene, så de passer til plotbiblioteket

til stearinlys i stearinlys:

dates.append (stearinlys [‘tid’])

open_data.append (lys [‘åben’])

high_data.append (candle [‘high’])

low_data.append (candle [‘low’])

close_data.append (stearinlys [‘luk’])

# Plot lysestagerne

fig = go.Figur (data = [go.Candlestick (x = datoer),

open = open_data, high = high_data,

low = low_data, close = close_data)])

fig. show ()

Samler det hele

Der er kun én ting tilbage for os at gøre. Det er for at sætte alt, hvad vi hidtil har diskuteret, sammen i et enkelt script. Dette script overvåger tickeren for BTC / USDT-parret på Binance og udfører en handel for at sælge alle dine BTC, når værdien af ​​BTC er gået over 10.000 USDT. Dette er et simpelt eksempel på, hvordan du kan kombinere data fra websockets til at udføre en handelsstrategi.

importere rejer

importtid

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Tildel dine udvekslingsnøgler, som du ønsker at få adgang til balancedataene for

exchange_name = "binance"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# Opret websocket-klienten

api_client = rejer.ShrimpyApiClient (rejer_offentlig_nøgle, rejer_sekret_nøgle)

raw_token = api_client.get_token ()

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

# Opret en bruger, der vil blive linket til vores udveksling

# Spring dette trin over (eller brug "liste brugere" slutpunkt), hvis du allerede har oprettet en bruger

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

user_id = create_user_response [‘id’]

# Link vores første udveksling, så vi kan få adgang til balancedata

# Spring dette trin over (eller brug "liste konti" slutpunkt), hvis du allerede har linket en konto

link_account_response = api_client.link_account (

bruger ID,

udvekslingsnavn,

exchange_public_key,

exchange_secret_key

)

account_id = link_account_response [‘id’]

# Vent mens Shrimpy indsamler data til udvekslingskontoen

# Kræves kun første gang linking

time.sleep (5)

# Få adgang til saldodata for den brugerkonto, du tidligere har oprettet

balance = api_client.get_balance (

user_id, # user_id

konto_id # konto_id

)

btcAmount = 0

for aktiv i balance [‘saldi’]:

hvis aktiv [‘symbol’] = ‘BTC’:

btcAmount = aktiv [‘nativeValue’]

# Dette er en prøvehåndterer, den udskriver simpelthen den indgående besked til konsollen

def error_handler (err):

udskrive (fejle)

# Dette er en prøvehåndterer, den udskriver simpelthen den indgående besked til konsollen

def handler (msg):

pris = msg [‘indhold’] [0] [‘pris’]

hvis int (pris) > 10000:

smart_order_response = api_client.create_trade (

user_id, # user_id

konto_id, # konto_id

‘BTC’, # fra_symbol

‘USDT’, # til_symbol

btcAmount # mængde fra_symbol

True # aktiver smart_routing

)

subscribe_data = {

"type": "abonnere",

"udveksling": "binance",

"par": "btc-usdt",

"kanal": "handle"}

# Start behandlingen af ​​Shrimpy websocket-strømmen!

ws_client.connect ()

ws_client.subscribe (subscribe_data, handler)

Konklusioner

Bevæbnet med disse scripts er det muligt at opbygge et hvilket som helst antal spændende handelsbots på Binance. Når du udforsker flere ting om handel og Shrimpy Trading API’er, kan du finde andre nyttige slutpunkter, som f.eks. Grænsefladens slutpunkter. Disse giver dig bedre kontrol over de ordrer, du placerer på børsen.

Vi opfordrer alle til at udforske alt, hvad vi tilbyder, og komme med forslag i vores Udvikler Telegram. Markedet for kryptokurrency er spændende, og dette er kun begyndelsen på en ny måde at handle aktiver på.

Rejer er en applikation til opførelse af tilpassede kryptokurrencyindeksfonde, genbalancering og styring af en forskellig portefølje af digitale aktiver. Automatiser din portefølje ved at linke til nogen af ​​de 16 krypto-udvekslinger, vi understøtter.

Shrimpys Universal Crypto Exchange API’er er designet til udviklere. Integrering med vores samlede API’er giver dig øjeblikkelig adgang til ensartede slutpunkter til handel, dataindsamling, brugeradministration og mere på tværs af alle større kryptokurrencyudvekslinger.

For at få adgang til de komplette Python- og Node-biblioteker skal du følge disse links:

Node

Python

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