Hvordan lage en Crypto Trading Bot for Binance (ved hjelp av Python)

>

Binance og trading bots.

Verden har ikke sett en mer ikonisk duo siden Bert og Ernie. Den legendariske børsen har blitt oversvømmet med automatiserte handelsroboter av alle slag. Institusjoner og enkeltpersoner med høy nettoverdi utfører avanserte algoritmiske handelsstrategier mens investorer automatiserer porteføljen. Det har blitt en spennende lekeplass for byggherrer.

Likevel er det fortsatt mye å bygge. Bare en brøkdel av de nødvendige tjenestene er utviklet frem til dette punktet, og det vil være mye vekst det kommende året.

Hvis du vil komme i gang med å delta i utviklingen av trading bots, er dette det beste stedet å starte. Gjennom denne artikkelen vil vi lære deg hvordan du får tilgang til markedsdata fra sentralen, koble til utvekslingskontoer for å lese saldodata, utføre handler, kartlegge lysestaker, og til og med koble til sanntidsnettsteder for ticker-data.

Det er mye å dekke, så la oss komme i gang!

Starter

Følgende trinn vil bryte ned de nødvendige komponentene for å begynne å programmere Binance Python-skriptene.

Installere Shrimpy Python

Først må vi installere Shrimpy Python Library. Den offisielle Shrimpy Python GitHub kan bli funnet her.

Ved hjelp av Pip kan du raskt installere biblioteket ved hjelp av følgende.

pip installere reker-python

Binance API-nøkler

For å koble til Binance-sentralen, må vi generere en ny API-nøkkel gjennom sentralen. Dette kan gjøres ved å følge artikkelen om Binance API-nøkkelhjelp.

Etter at du har kommet til trinnet der du kopierer API-nøklene ut av Binance, kan du stoppe og lagre dem på et sikkert sted (i stedet for å lime dem inn i Shrimpy Portfolio Management Application). Disse nøklene vil bli brukt i skriptene våre ved å tilordne dem til en variabel som vi kan overføre til klienten når den er opprettet.

exchange_public_key = ‘…’

exchange_secret_key = ‘…’

Reker API-nøkler

Etter at API-nøklene for utveksling er opprettet, må vi også generere API-nøkler for Shrimpy Universal Crypto Trading API. Disse nøklene genereres ved å registrere deg for Shrimpy Developer APIs følg deretter guiden beskrevet her.

Når nøklene er opprettet, lagrer du dem på et sikkert sted og bruker dem i Python-skriptene på følgende måte.

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

Utveksle data

Å få nøyaktige markedsdata er det første trinnet for å lage en krypto trading bot som kan utføre strategier basert på signaler, markedsforhold og prisbevegelser.

Dette gjøres vanligvis ved hjelp av både live ordreboksdata og handelsdata. I de følgende avsnittene vil vi gi eksempler på hvordan du kan samle begge disse typene informasjoner via websockets og REST APIer.

Pris Ticker

En pris ticker er noe som oppdaterer prisen på en jevnlig basis for å få den siste prisen på eiendelen på en børs. Følgende eksempler vil presentere et par eksempler på hvordan du oppretter og får tilgang til prismerker.

En enkel pris ticker

Dette eksemplet vil gi et skript for den mest enkle prisen. Denne tickeren vil bruke REST API-anrop for å få tilgang til prisdata på sentralen. Dette endepunktet oppdateres med et minutts intervall, så det betyr at den høyest mulige frekvensen for oppdatering av tickeren i dette eksemplet er 1 minutt.

importer reker

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

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Opprett Shrimpy REST API-klienten

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Be om ticker for alle eiendeler på Binance

ticker = client.get_ticker (‘binance’)

Websocket Pris Ticker

Den mer sentrale tickeren er sanntids. Denne tickeren utnytter sanntids websockets for å holde deg oppdatert med den siste prisen på børsen.

I motsetning til den enkle prismarkøren som oppdateres i løpet av 1 minutt, vil denne prislisten oppdateres umiddelbart. Så snart prisen endres på børsen, vil websocket sende oppdateringen, og den nye prisen vil bli mottatt av dette skriptet for å vise.

importer reker

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Dette er en prøvehåndterer, den skriver bare innkommende melding til konsollen

def error_handler (err):

skrive ut (feile)

# Dette er en prøvehåndterer, den skriver bare innkommende melding til konsollen

def handler (msg):

skriv ut (msg [‘content’] [0] [‘price’])

# Opprett websocket-klienten ved hjelp av rå token hentet av REST API

api_client = reker.ShrimpyApiClient (reker_offisiell_key, reker_secret_key)

raw_token = api_client.get_token ()

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

# Abonnementsdata for websocket

subscribe_data = {

"type": "abonnere",

"Utveksling": "binance",

"par": "eth-btc",

"kanal": "handel"}

# Begynn å behandle Shrimpy websocket-strømmen!

client.connect ()

client.subscribe (subscribe_data, handler)

# Når du er ferdig, stopper du klienten

klient. koble fra ()

Bytt ordrebøker

Nøyaktige ordrebøker på en børs brukes av handelsmenn og kryptoboter for å bestemme den nøyaktige ordren de ønsker å plassere på børsen.

Når du legger inn bestillinger, er det alltid gunstig å ha sanntidsoppdateringer til ordreboken. På den måten tar du alltid avgjørelser basert på den mest oppdaterte informasjonen.

Enkelt øyeblikksbilde av Live Order Book

Den enkleste måten å få tilgang til en børs ordrebøker er å be om ordreboken på det tidspunktet du skal bestille..

Hvis du for eksempel vil utføre en handel på ETH / BTC-handelsparet, kan du be om å få den siste ordreboken for dette markedet ved å ringe inn i REST API.

importer reker

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Opprett API-klienten for REST-samtaler

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Hent live ordreboken

ordrebøker = client.get_orderbooks (

‘binance’, # exchange

‘ETH’, # base_symbol

‘BTC’, # quote_symbol

10 # grense

)

Websocket Live Order Book

I mer avanserte scenarier vil det være ideelt å opprettholde en lokal kopi av ordreboken som oppdateres i sanntid via websockets. Dette kan gjøres ved hjelp av bestillingsbokens nettstikkontakt som er tilgjengelig via websocket-API-ene.

Å koble til ETH / BTC-paret vil se ut som følgende eksempel.

importer reker

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Dette er en prøvehåndterer, den skriver bare innkommende melding til konsollen

def error_handler (err):

skrive ut (feile)

# Dette er en prøvehåndterer, den skriver bare innkommende melding til konsollen

def handler (msg):

skriv ut (msg)

# Opprett websocket-klienten ved å få rå token.

api_client = reker.ShrimpyApiClient (reker_offisiell_key, reker_secret_key)

raw_token = api_client.get_token ()

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

subscribe_data = {

"type": "abonnere",

"Utveksling": "binance",

"par": "eth-btc",

"kanal": "bestillingsbok"}

# Begynn å behandle Shrimpy websocket-strømmen!

ws_client.connect ()

ws_client.subscribe (subscribe_data, handler)

# Når du er ferdig, stopper du klienten

ws_client.disconnect ()

Legg merke til at dette eksemplet ikke beskriver hvordan du administrerer ordreboken lokalt, men bare hvordan du får tilgang til dataene via websocket. Organiseringen av data må gjøres gjennom tilpasset kode basert på hvordan du vil administrere bøkene.

I hovedsak vil administrering av bøkene kreve en måte å holde rede på bokens nåværende tilstand. På den måten kan du sette inn nye ordrer, oppdatere gamle ordrer og slette bestillinger etter behov basert på oppdateringene via websocket.

Tilkobling til byttekontoer

For å handle, trenger vi tilgang til en byttekonto. Denne byttekontoen vil bli brukt til å samle inn data om tilgjengelige saldoer og utføre handelsstrategien.

Koble til en Binance-konto

Shrimpy tilbyr et praktisk brukeradministrasjonssystem der du kan koble individuelle Binance-kontoer til brukere. Hver bruker kan opprettholde 20 byttekontoer. På den måten kan alle byttekontoer administreres sammen.

Det er en engangshendelse å koble en byttekonto til Shrimpy. Det betyr at når kontoen er koblet til, vil Shrimpy opprettholde forbindelsen til børsen for den kontoen og ikke krever re-linking i fremtiden. Du kan alltid få de tilknyttede kontoene dine ved å liste opp kontoene som er koblet til en bruker.

I dette eksemplet oppretter vi vår første bruker, og kobler deretter byttekontoen. Når du oppretter din første bruker, vil du ikke trenger å opprette en annen bruker igjen. Du kan alltid få tilgang til brukerne dine ved å liste opp brukerne du har opprettet.

# importer nødvendige biblioteker

importer reker

# tilordne API-nøklene til Shrimpy Master for senere bruk

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# tilordne vekslingsnøklene du vil ha tilgang til balansedataene for

exchange_name = "binance"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# opprett Shrimpy-klienten

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# opprett en bruker som vil bli koblet til sentralen vår

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

user_id = create_user_response [‘id’]

# koble vår første utveksling slik at vi får tilgang til balansedata

link_account_response = client.link_account (

bruker-ID,

exchange_name,

exchange_public_key,

exchange_secret_key

)

account_id = link_account_response [‘id’]

Henter saldoer på Binance-kontoer

Så snart kontoen er koblet til, vil Shrimpy begynne å samle inn data fra sentralen angående byttekontoen. Dette kan ta opp til 5 sekunder, så vi anbefaler å vente noen sekunder (bare for den første koblingen) før du bruker neste skript for å få tilgang til saldodataene for vekslingskontoen som var koblet.

Etter at dataene er samlet inn, vil Shrimpy kontinuerlig oppdatere saldoen når handler utføres, innskudd eller uttak blir gjort, og andre operasjoner gjøres på kontoen.

I dette eksemplet demonstrerer vi hvordan du henter Binance-kontosaldoen.

importer reker

# bruk Shrimpy API offentlige og private nøkler for å opprette klienten

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# note: siden vi opprettet en bruker i det siste eksemplet på skriptet,

# vi kan bare hente listen over brukere.

brukere = client.list_users ()

first_user_id = brukere [0] [‘id’]

# hente kontoene som er tilknyttet denne brukeren

kontoer = client.list_accounts (

første_bruker_id

)

first_account_id = kontoer [0] [‘id’]

# tilgangsbalansedata for brukerkontoen du tidligere opprettet

balanse = klient.get_balanse (

first_user_id, # user_id

first_account_id # account_id

)

Legg merke til hvordan vi brukte endepunktene til å “liste brukere” og “listekontoer”. Hvis du allerede har konto- og bruker-ID-ene, kan du bare legge inn disse verdiene også uten å hente dem hver gang.

Gjennomføre en handel på Binance

Utveksling kan være komplisert. Forvirrende dokumentasjon, inkonsekvente handelsregler og avvik på tvers av endepunkter kan føre til at utviklingsprosessen blir kaotisk.

I de følgende eksemplene vil vi bryte ned noen av de mest enkle måtene å utføre handler på Binance. Uten noen kompleks logikk kan Shrimpy hjelpe deg med å utføre en ordre på alle større børser på identisk måte.

Enkel handel

Den enkleste måten å utføre en handel med Shrimpy på er å bruke endepunktet “Create Trade”. Alt dette endepunktet krever er relevante konto-ID-er og de to eiendelene du vil handle “fra” og “til”.

Det vil se ut som følgende.

create_trade_response = client.create_trade (

user_id, # IDen til brukeren

account_id, # ID for kontoen som er knyttet til brukeren

from_symbol, # Eiendelen du vil selge

til_symbol, # Eiendelen du vil kjøpe

fra_nativ_beløp # Hvor mye av "fra" eiendel du vil selge

)

Resultatet er en enkel måte å kjøpe og selge eiendeler uten å bekymre seg for detaljene i hvordan handler utføres. Du trenger ikke å plassere individuelle begrensningsordrer, bestemme forskjellige handelspar eller manuelt dirigere eiendelene gjennom forskjellige kursvalutaer. Reker vil ta seg av alt.

Vi kan deretter sette dette endepunktet i bruk ved å sette det inn i et eksempel på et skript. I dette eksemplet vil vi undersøke alle eiendelene du har på børsen. Vi vil deretter gjenta listen over eiendeler du eier og selge dem alle til et konsolideringsmiddel (i dette tilfellet BTC).

STOPPE! Å kjøre dette skriptet vil bokstavelig talt selge alt du eier på børsen og kjøpe BTC. Dette er ikke et hypotetisk skript, dette er et reelt eksempel som utfører reelle handler på din virkelige valutakonto. Ikke kjør skriptet hvis du ikke vil selge alt du eier til Bitcoin.

importer reker

# Bruk Shrimpy API offentlige og private nøkler for å opprette klienten

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Merk: siden vi opprettet en bruker i det siste eksemplet på skriptet,

# Vi kan bare hente listen over brukere.

brukere = client.list_users ()

first_user_id = brukere [0] [‘id’]

# Hent kontoene som er tilknyttet denne brukeren

kontoer = client.list_accounts (

første_bruker_id

)

first_account_id = kontoer [0] [‘id’]

# Få tilgang til saldodata for brukerkontoen du tidligere opprettet

balanse = klient.get_balanse (

first_user_id, # user_id

first_account_id # account_id

)

beholdninger = saldo [‘balanserer’]

# Velg eiendelen du vil konsolidere for

consolidation_symbol = ‘BTC’

# Selg alle eiendeler i tillegg til konsolideringselementet

for eiendel i beholdninger:

asset_symbol = ressurs [‘symbol’]

asset_amount = asset [‘nativeValue’]

if asset_symbol! = consolidation_symbol:

skriv ut (‘Selling’ + str (asset_amount) + ‘of’ + asset_symbol)

create_trade_response = client.create_trade (

første_bruker_id,

første_konto_id,

asset_symbol,

konsolidering_symbol,

eiendelsbeløp

)

Smart bestillingsruting

I forrige eksempel brukte vi ingen intelligent ruting. I hovedsak vil Shrimpy identifisere “fra” og “til” eiendelen, deretter selge “fra” eiendelen til BTC, og deretter kjøpe “til” eiendelen fra BTC. Dette kan være ineffektivt hvis det er alternative kursvalutaer som eiendelen kan bruke.

I mange tilfeller vil det være ideelt å bruke alternativet for smart ordrerute. Dette enkle flagget forteller Shrimpy å evaluere alle mulige ruter når vi bestemmer hvordan vi skal handle “fra” eiendelen og anskaffe “til” eiendelen.

importer reker

# Bruk Shrimpy API offentlige og private nøkler for å opprette klienten

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Merk: siden vi opprettet en bruker i det siste eksemplet på skriptet,

# Vi kan bare hente listen over brukere.

brukere = client.list_users ()

first_user_id = brukere [0] [‘id’]

# Hent kontoene som er tilknyttet denne brukeren

kontoer = client.list_accounts (

første_bruker_id

)

first_account_id = kontoer [0] [‘id’]

# Få tilgang til saldodata for brukerkontoen du tidligere opprettet

balanse = klient.get_balanse (

first_user_id, # user_id

first_account_id # account_id

)

# Utfør en markedsordre

smart_order_response = client.create_trade (

first_user_id, # user_id

first_account_id, # account_id

‘BTC’, # fra_symbol

‘ETH’, # til_symbol

‘0,01’ # mengde fra_symbol

True # aktiver smart_routing

)

Legg merke til hvordan den eneste forskjellen er det ekstra flagget i forespørselen om å aktivere smart ruting og sette den til “True”.

Kartlegge lysestaker

Å bygge et program med et brukergrensesnitt betyr at vi trenger andre komponenter for å illustrere brukerens nåværende tilstand. Et eksempel på data brukeren kan ønske å motta er lysestake-diagrammer.

Lysestakekart hjelper handelsmenn å bestemme når de skal kjøpe eller selge en eiendel.

Shrimpy gir tilgang til gratis endepunkter for tilgang til lysestake-data i sanntid. Hver gang en ny handel utføres på børsen, blir lysestakene oppdatert i sanntid. Disse lysestakene kan deretter kastes med jevne mellomrom for å kunne vises i brukergrensesnittet i applikasjonen din.

I det følgende eksemplet vil vi avstemme de siste lysestakene for ETH / BTC-handelsparet på Binance-børsen. Det samme endepunktet kan brukes til alle andre større sentraler, så det er ingen forskjell mellom å bruke Binance og andre sentraler.

importer reker

importere plotly.graph_objects as go

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Samle inn de historiske lysestakedataene

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

stearinlys = client.get_candles (

‘binance’, # exchange

‘ETH’, # base_trading_symbol

‘BTC’, # quote_trading_symbol

‘1d’ # intervall

)

datoer = []

open_data = []

høye data = []

low_data = []

close_data = []

# Formater dataene slik at de samsvarer med plottbiblioteket

for stearinlys i stearinlys:

dates.append (candle [‘time’])

open_data.append (stearinlys [‘åpen’])

high_data.append (candle [‘high’])

low_data.append (candle [‘low’])

close_data.append (candle [‘close’])

# Plott lysestakene

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

åpen = åpen_data, høy = høy_data,

low = low_data, close = close_data)])

fig.show ()

Sette alt sammen

Det er bare en ting igjen for oss å gjøre. Det er for å sette alt vi har diskutert så langt sammen i et enkelt manus. Dette skriptet overvåker tickeren for BTC / USDT-paret på Binance og utfører en handel for å selge alle BTC-ene dine når verdien av BTC har gått over 10.000 USDT. Dette er et enkelt eksempel på hvordan du kan kombinere dataene fra websockets for å utføre en handelsstrategi.

importer reker

importtid

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Tildel vekslingsnøklene du vil ha tilgang til balansedataene for

exchange_name = "binance"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# Lag websocket-klienten

api_client = reker.ShrimpyApiClient (reker_offisiell_key, reker_secret_key)

raw_token = api_client.get_token ()

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

# Opprett en bruker som vil bli koblet til sentralen vår

# Hopp over dette trinnet (eller bruk "liste brukere" endepunkt) hvis du allerede har opprettet en bruker

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

user_id = create_user_response [‘id’]

# Koble vår første utveksling slik at vi får tilgang til balansedata

# Hopp over dette trinnet (eller bruk "liste opp kontoer" endepunkt) hvis du allerede har koblet en konto

link_account_response = api_client.link_account (

bruker-ID,

exchange_name,

exchange_public_key,

exchange_secret_key

)

account_id = link_account_response [‘id’]

# Vent mens Shrimpy samler inn data for byttekontoen

# Kreves bare første gangs lenking

time.sleep (5)

# Få tilgang til saldodata for brukerkontoen du tidligere opprettet

balanse = api_client.get_balance (

user_id, # user_id

konto_id # konto_id

)

btcAmount = 0

for eiendel i balanse [‘saldi’]:

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

btcAmount = eiendel [‘nativeValue’]

# Dette er en prøvehåndterer, den skriver bare innkommende melding til konsollen

def error_handler (err):

skrive ut (feile)

# Dette er en prøvehåndterer, den skriver bare innkommende melding til konsollen

def handler (msg):

pris = msg [‘innhold’] [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 # mengde fra_symbol

True # aktiver smart_routing

)

subscribe_data = {

"type": "abonnere",

"Utveksling": "binance",

"par": "btc-usdt",

"kanal": "handel"}

# Begynn å behandle Shrimpy websocket-strømmen!

ws_client.connect ()

ws_client.subscribe (subscribe_data, handler)

Konklusjoner

Bevæpnet med disse skriptene, er det mulig å bygge et hvilket som helst antall spennende handelsboter på Binance. Når du utforsker flere ting om handel og Shrimpy Trading API, kan du finne andre nyttige endepunkter, som endepunkter for grenseordre. Disse gir deg bedre kontroll over ordrene du legger på børsen.

Vi oppfordrer alle til å utforske alt vi tilbyr og komme med forslag i vår Utvikler Telegram. Kryptovalutamarkedet er spennende, og dette er bare begynnelsen på en ny måte å handle eiendeler på.

Reker er et program for å konstruere tilpassede kryptovalutaindeksfond, balansere og administrere en mangfoldig portefølje av digitale eiendeler. Automatiser porteføljen din ved å koble til noen av de 16 kryptobørsene vi støtter.

Shrimpys Universal Crypto Exchange APIer er designet for utviklere. Integrering med våre enhetlige API-er gir deg øyeblikkelig tilgang til ensartede sluttpunkter for handel, datainnsamling, brukeradministrasjon og mer på tvers av alle større kryptovalutautvekslinger.

For å få tilgang til de komplette Python- og Node-bibliotekene, følg disse linkene:

Node

Python

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