L’API per i bot di trading crittografico

>

I robot di trading crittografico sono uno degli strumenti più comunemente utilizzati dai trader. Queste applicazioni possono fornire ai trader modi convenienti per eseguire strategie che sarebbero noiose da implementare.

Sfortunatamente, gli sviluppatori hanno difficoltà a creare applicazioni di trading. Ci vuole una notevole quantità di tempo e pazienza per sviluppare l’infrastruttura che si collega a ogni scambio. Molti team credono erroneamente che esistano modi semplici per scalare l’infrastruttura di trading, ma apprendono rapidamente che è molto più complicato di quanto sembri a prima vista.

Molti servizi di trading hanno difficoltà a superare anche una singola integrazione di scambio. Ogni nuova integrazione di scambio oltre gli scambi più grandi produce rendimenti sempre più bassi, rendendo poco pratico costruire un servizio per più dei pochi scambi principali.

Le sezioni seguenti discuteranno di come gli sviluppatori possono integrare ogni scambio principale senza mai preoccuparsi di mantenere e ridimensionare la complessa infrastruttura richiesta per gli scambi.

Bot per il trading di criptovalute: la guida completa

Problemi con l’integrazione degli scambi

Gli sviluppatori stanno avendo difficoltà a creare applicazioni di trading che si collegano agli scambi di criptovaluta.

Quando stai intraprendendo un viaggio per costruire uno strumento di trading di criptovaluta, come un bot, è importante prima comprendere i rischi di costruire l’infrastruttura di scambio da zero.

Nota: questi sono solo alcuni delle questioni che dovrebbero preoccuparti. Ce ne sono molti altri di cui non discuteremo.

Incoerenza

Ogni scambio è diverso. Non esistono due exchange che supportano le stesse API, funzionalità di trading, formati di dati o comportamento. Non ci sono standard su come dovrebbero essere costruiti gli scambi crittografici.

Il risultato è che ogni integrazione di scambio è una nuova avventura. Non una di quelle piacevoli avventure che ti fanno sentire vivo dentro. È come una di quelle avventure in cui ti perdi per 2 mesi nel deserto e non riesci più a distinguere tra allucinazioni e miraggi. Letteralmente tutto sembra un’oasi, ma alla fine è solo più deserto.

Possono essere necessari mesi per comprendere le diverse insidie ​​di ogni scambio. Sviluppare un modo coerente di fare trading su ogni borsa può sembrare quasi impossibile. L’infrastruttura che sviluppi dovrà cambiare di volta in volta mentre scopri nuovi modi in cui gli scambi rovinano il tuo progetto precedente.


L’incoerenza non è limitata solo agli endpoint API. Le risorse nelle borse hanno diversi simboli, nomi e altre informazioni di identificazione. Per supportare tutte le risorse su uno scambio, gli sviluppatori devono mappare manualmente le risorse tra le borse ricercando quale risorsa elencata nella borsa.

Poiché ci sono migliaia di risorse, il processo può richiedere settimane. Per non parlare del fatto che ogni volta che uno scambio elenca una nuova risorsa, gli sviluppatori devono convalidare la nuova risorsa.

La mappatura automatica delle risorse è quasi impossibile. Per garantire l’accuratezza, deve essere un processo manuale.

Le API per sviluppatori di Shrimpy risolvono questo problema identificando e taggando automaticamente le risorse negli scambi. Il comportamento per il trading e i formati che utilizziamo per i dati sono coerenti in ogni scambio. Tutti i processi manuali sono gestiti dal team di Shrimpy, quindi puoi concentrarti sullo sviluppo delle funzionalità.

Manutenzione

Come accennato in precedenza, alcuni scambi elencano frequentemente le risorse. Il processo per la gestione del processo di quotazione, la codifica delle risorse e la mappatura delle risorse tra gli scambi è in gran parte manuale.

Questa non è l’unica manutenzione richiesta per la costruzione di infrastrutture commerciali. Gli scambi spesso si interrompono per manutenzione, aggiornano le API o modificano il comportamento delle richieste in modo imprevisto.

Ogni modifica apportata da uno scambio richiede agli sviluppatori di rilasciare aggiornamenti, ridistribuire i server e rilevare automaticamente quando vengono apportate queste modifiche. In alcune condizioni, gli scambi non avvisano nemmeno gli sviluppatori quando è in arrivo un cambiamento. Ti sveglierai una mattina e le API saranno diverse.

Per non parlare dei continui sforzi per integrare nuove funzionalità supportate dallo scambio, deprecare vecchie funzionalità o endpoint e aggiornare il codice come le condizioni per lo scambio cambiano.

Le API per sviluppatori Shrimpy risolvono questo problema gestendo gli aggiornamenti, ridistribuendo l’infrastruttura e integrando nuove funzionalità senza mai cambiare l’interfaccia API. Gli sviluppatori possono stare tranquilli la notte sapendo che si sveglieranno con un prodotto che sta canticchiando.

Limiti di velocità

Ogni scambio ha limiti di velocità e regole differenti su come interagire con le API. Per rispettare queste regole, gli sviluppatori sono spesso costretti a mantenere una farm di server necessari per gestire il volume di scambi che l’applicazione esegue.

Questa farm di server richiede coordinamento e instradamento intelligente per assicurarsi che il servizio rispetti le restrizioni API pur continuando a eseguire gli scambi per ciascun utente in modo tempestivo.

Man mano che il numero di utenti aumenta, questo problema aumenta solo in complessità. Gestire centinaia di server che si interfacciano in modo indipendente con gli scambi diventa un incubo.

Le API Shrimpy Developer risolvono questo problema gestendo la server farm per te. La nostra infrastruttura si adatta a te, quindi che tu abbia 1 utente o 1.000 utenti, non sono necessarie modifiche al modo in cui fai crescere la tua infrastruttura.

Costo

I costi del server necessari per gestire decine di migliaia o centinaia di migliaia di utenti sono costosi. In effetti, la creazione di una solida infrastruttura costerebbe alla maggior parte dei team da $ 3 a $ 6 / utente / mese. Anche se questo sembra alto, è il costo per mantenere una così grande farm di server che si connettono agli scambi.

Sfortunatamente, ciò non include nemmeno i costi di sviluppo. Può essere costoso assumere sviluppatori di livello mondiale sufficientemente esperti per creare l’infrastruttura di cui hai bisogno. I costi aumentano solo perché sono necessarie integrazioni aggiuntive.

La costruzione di infrastrutture per gli scambi è costosa.

Le API per sviluppatori Shrimpy sono poco costose. I costi partono da $ 1,40 / utente / mese e diminuiscono man mano che aumenti gli utenti a bordo.

Gestione account utente

Ora che abbiamo compreso le difficoltà con la gestione dell’infrastruttura di scambio, esamineremo esempi di come possiamo sfruttare le API per sviluppatori di Shrimpy per semplificare il nostro processo di sviluppo.

Per iniziare, dobbiamo sapere come gestire gli utenti, connetterci agli account di scambio utenti e iniziare ad accedere alle informazioni sull’account.

Con le API Shrimpy, ogni utente viene gestito individualmente in modo da mappare il modo in cui sviluppi la tua applicazione. Se hai 1.000 utenti sulla tua applicazione, avrai 1.000 utenti creati con le API di Shrimpy.

Configurazione del nostro ambiente Python

Prima di iniziare, configuriamo il nostro ambiente Python installando la libreria Shrimpy Python.

pip installa shrimpy-python

Nota: la libreria Shrimpy Python è progettata per funzionare con Python3. Se stai usando Python2, aggiorna la tua versione di Python.

Gamberetti & Chiavi API di Exchange

Ogni volta che vedi le seguenti righe negli esempi di script, dobbiamo inserire le nostre chiavi API pubbliche e segrete di Shrimpy. Questi vengono generati registrandosi a Shrimpy e selezionando di creare nuove chiavi API.

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

Oltre alle chiavi API di Shrimpy, vedremo posti nel codice per lo scambio di chiavi API pubbliche e segrete. Queste chiavi sono necessarie per connettersi agli account di scambio.

exchange_public_key = ‘…’

exchange_secret_key = ‘…’

Creare un utente

Ogni volta che un utente si iscrive ai tuoi servizi, tutto ciò che devi fare è creare un nuovo utente con Shrimpy. Questo processo può essere simile al seguente.

# importa le librerie richieste

importare gamberetti

# assegna le tue chiavi API Shrimpy Master per un uso successivo

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# crea il client Shrimpy

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# crea un utente che sarà collegato al nostro scambio

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

user_id = create_user_response [“id”]

Salvare “user_id” in modo che possa essere utilizzato negli script successivi. Questo è l’ID che utilizzerai per mappare il tuo utente all’utente creato con Shrimpy. Questa mappatura può essere salvata da qualche parte come un database.

Connetti scambi

Dopo aver creato un utente, è probabile che voglia connettersi ai vari scambi. Shrimpy ti consente di connettere fino a 20 account di scambio per utente per impostazione predefinita (questo limite può essere aumentato su richiesta). Il processo per collegare un nuovo account di scambio a un utente è semplice.

# importa le librerie richieste

importare gamberetti

# assegna le tue chiavi API Shrimpy Master per un uso successivo

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# assegna le tue chiavi di scambio per le quali desideri accedere ai dati del saldo

exchange_name = "bittrex"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# assegna lo user_id che è stato generato nell’ultimo esempio di script

user_id = ‘…’

# se non ricordi il tuo ‘user_id’, recuperalo da Shrimpy

# dovrebbe essere il primo utente se ne hai creato solo uno

utenti = client.list_users ()

user_id = utenti [0] [“id”]

# crea il client Shrimpy

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# collega il nostro primo scambio in modo da poter accedere ai dati del saldo

link_account_response = client.link_account (

ID utente,

exchange_name,

exchange_public_key,

exchange_secret_key

)

account_id = link_account_response [“id”]

Salva “account_id” in modo da poterlo utilizzare negli script successivi. Ogni account di scambio per l’utente avrà un ID univoco.

Ottieni i saldi del conto

Una volta che l’account di scambio è collegato a un utente, possiamo accedere ai saldi per questo account di scambio eseguendo il seguente script.

importare gamberetti

# usa le chiavi pubbliche e private dell’API Shrimpy per creare il client

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# nota: poiché abbiamo creato un utente nel nostro precedente script di esempio,

# possiamo semplicemente recuperare il nostro elenco di utenti.

utenti = client.list_users ()

user_id = utenti [0] [“id”]

# recupera gli account associati a questo utente

account = client.list_accounts (

ID utente

)

account_id = account [0] [“id”]

# accedi ai dati del saldo per l’account utente che hai creato in precedenza

balance = client.get_balance (

user_id, # user_id

account_id # account_id

)

Il risultato di questo script è un elenco di ciascuna risorsa di proprietà dell’utente e la quantità esatta di ciascuna risorsa.

Trading & Gestione degli ordini

Senza il trading, la creazione di un bot di trading sarebbe impossibile. Le API per sviluppatori di gamberetti forniscono le opzioni più robuste per il trading. Queste opzioni semplificano il processo di sviluppo, semplificano le strategie e ottimizzano il modo in cui vengono eseguiti gli scambi.

Esistono diversi tipi di ordine supportati dalle API per sviluppatori di Shrimpy. I tipi di ordine più importanti saranno inclusi nella discussione qui.

Ordini limite

Shrimpy supporta due diversi tipi di ordini limite. Questi sono ordini IOC e GTC. Sebbene entrambi abbiano la stessa premessa, hanno comportamenti leggermente diversi che li rendono ideali per situazioni diverse.

Ordini immediati o annullati (IOC)

Gli ordini IOC sono progettati per essere eseguiti immediatamente. L’ordine deve essere inserito a un prezzo attualmente occupato da un ordine aperto in modo che l’ordine venga eseguito immediatamente al prezzo specificato o migliore. Se il mercato si muove e il prezzo specificato non è più disponibile, l’ordine verrà immediatamente annullato e i fondi bloccati nell’ordine verranno restituiti all’utente.

L’esecuzione di un ordine IOC sarebbe simile a questo con Shrimpy.

importare gamberetti

# usa le chiavi pubbliche e private dell’API Shrimpy per creare il client

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# nota: poiché abbiamo creato un utente nel nostro precedente script di esempio,

# possiamo semplicemente recuperare il nostro elenco di utenti.

utenti = client.list_users ()

first_user_id = utenti [0] [“id”]

# recupera gli account associati a questo utente

account = client.list_accounts (

first_user_id

)

first_account_id = account [0] [“id”]

# accedi ai dati del saldo per l’account utente che hai creato in precedenza

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

# esegue un ordine limite IOC

place_limit_order_response = client.place_limit_order (

first_user_id, # user_id

first_account_id, # account_id

“ETH”, # base_symbol

“BTC”, # quote_symbol

‘0.01’, # quantità di base_symbol

‘0,026’, # prezzo

“VENDI”, lato #

“IOC”, # time_in_force

)

limit_order_id = place_limit_order_response [“id”]

Notare come questo script esatto può essere eseguito per ogni scambio. Non è necessario modificare nient’altro che l’account di scambio a cui si fa riferimento per eseguire uno scambio su un altro scambio.

Questo comportamento è unico per Shrimpy. L’implementazione dell’infrastruttura da soli richiederebbe di scrivere codice personalizzato per ogni singolo scambio.

Nota: il prezzo per lo scambio incluso qui è solo un prezzo di esempio. Il prezzo dovrebbe essere preso in base allo stato attuale del mercato. Non eseguire questo script “così com’è”.

Good Til ’Cancel (GTC)

Gli ordini GTC vengono effettuati a un prezzo e una quantità specifici. L’ordine rimarrà aperto in borsa fino a quando un altro trader non acquista l’ordine o fino a quando non si annulla l’ordine. Un ordine aperto preso da un altro trader incorre in commissioni di trading maker.

Le commissioni del produttore sono in genere inferiori alle commissioni dell’acquirente su molte borse poiché lasciare ordini aperti sulla borsa aggiunge liquidità al mercato. Per questo motivo, molte borse vogliono premiare la liquidità aggiuntiva.

importare gamberetti

# usa le chiavi pubbliche e private dell’API Shrimpy per creare il client

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# nota: poiché abbiamo creato un utente nel nostro precedente script di esempio,

# possiamo semplicemente recuperare il nostro elenco di utenti.

utenti = client.list_users ()

first_user_id = utenti [0] [“id”]

# recupera gli account associati a questo utente

account = client.list_accounts (

first_user_id

)

first_account_id = account [0] [“id”]

# accedi ai dati del saldo per l’account utente che hai creato in precedenza

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

# esegui un ordine limite GTC

place_limit_order_response = client.place_limit_order (

first_user_id, # user_id

first_account_id, # account_id

“ETH”, # base_symbol

“BTC”, # quote_symbol

‘0.01’, # quantità di base_symbol

‘0,026’, # prezzo

“VENDI”, lato #

“GTC”, # time_in_force

)

limit_order_id = place_limit_order_response [“id”]

Nota: il prezzo per lo scambio incluso qui è solo un prezzo di esempio. Il prezzo dovrebbe essere preso in base allo stato attuale del mercato. Non eseguire questo script “così com’è”.

Ulteriori informazioni sugli ordini limite

Routing intelligente degli ordini

La raccolta di dati su centinaia di coppie di trading e l’analisi dei dati per un instradamento commerciale ottimizzato è complicata. Per questo motivo, Shrimpy offre Smart Order Routing (SOR) fin da subito.

SOR automatizza l’esecuzione degli ordini, quindi puoi dedicare più tempo a gestire dove dovrebbero andare i fondi, piuttosto che come ottenerli. Shrimpy instraderà in modo intelligente l’ordine tra le coppie di trading per garantire la migliore esecuzione dell’ordine.

Esempio: supponi di voler scambiare ETH con LTC.

In un determinato scambio, potrebbero esserci 10 percorsi diversi che possono essere intrapresi per vendere ETH e acquistare LTC. Potresti andare all’ETH->BTC->LTC, ETH->LTC, ETH->USDT->LTC, ETH->USDC->LTC e così via. Ognuno di questi avrà tassi diversi che cambiano costantemente.

SOR valuterà automaticamente tutte queste opzioni, suddividerà gli ordini ed eseguirà le operazioni ottimali.

importare gamberetti

# usa le chiavi pubbliche e private dell’API Shrimpy per creare il client

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# nota: poiché abbiamo creato un utente nel nostro precedente script di esempio,

# possiamo semplicemente recuperare il nostro elenco di utenti.

utenti = client.list_users ()

first_user_id = utenti [0] [“id”]

# recupera gli account associati a questo utente

account = client.list_accounts (

first_user_id

)

first_account_id = account [0] [“id”]

# accedi ai dati del saldo per l’account utente che hai creato in precedenza

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

# esegue un ordine di mercato

smart_order_response = client.create_trade (

first_user_id, # user_id

first_account_id, # account_id

“BTC”, # from_symbol

“ETH”, # to_symbol

‘0.01’ # quantità di from_symbol

True # abilita smart_routing

)

API per il routing intelligente degli ordini

Dati di mercato in tempo reale

Per eseguire operazioni, abbiamo bisogno di dati di mercato in tempo reale per prendere decisioni rapide su come e quando eseguire gli ordini.

Shrimpy fornisce sia un’API REST che un’API Websocket per assicurarti di poter creare un’applicazione con dati in tempo reale che funzioni meglio per te.

Endpoint API REST

Questi endpoint API REST forniscono agli sviluppatori il modo più semplice per accedere ai dati di mercato su richiesta senza connettersi a websocket.

Ordina libri

È possibile accedere all’istantanea del registro ordini più recente utilizzando il seguente endpoint. Ciò restituirà istantaneamente l’istantanea del libro live che puoi utilizzare per prendere decisioni su come eseguire le negoziazioni.

importare gamberetti

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

orderbooks = client.get_orderbooks (

‘binance’, # exchange

“XLM”, # base_symbol

“BTC”, # quote_symbol

Limite di 10 #

)

Candelieri

Se hai bisogno di grafici che tracciano gli aggiornamenti in tempo reale del mercato, puoi richiedere le ultime candele per tenerti aggiornato con ogni movimento del mercato.

Questo endpoint restituisce le ultime 1.000 candele. Se hai bisogno di più candele, devi utilizzare l’endpoint “Candela storica”.

importare gamberetti

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

candele = client.get_candles (

‘binance’, # exchange

“XLM”, # base_trading_symbol

“BTC”, # quote_trading_symbol

Intervallo ’15m’ #

)

Endpoint Websocket

Le applicazioni di trading in tempo reale richiedono dati di mercato in tempo reale su base continua. Il modo più semplice per implementare queste strategie è sfruttare il book degli ordini e fare trading di websocket di dati. Questi websocket mantengono gli abbonati aggiornati con ogni operazione eseguita e ogni ordine che viene inserito nello scambio.

Order Book Websocket

Il websocket del registro ordini invierà continuamente le ultime modifiche al registro ordini. Shrimpy invia sempre immediatamente gli aggiornamenti non appena diventano disponibili.

importare gamberetti

public_key = ‘…’

private_key = ‘…’

# Questo è un gestore di esempio, stampa semplicemente il messaggio di errore in arrivo sulla console

def error_handler (err):

stampa (err)

# Questo è un gestore di esempio, stampa semplicemente il messaggio in arrivo sulla console

gestore def (msg):

stampa (msg)

api_client = shrimpy.ShrimpyApiClient (public_key, private_key)

raw_token = api_client.get_token ()

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

subscribe_data = {

"genere": "sottoscrivi",

"scambio": "binance",

"paio": "ltc-btc",

"canale": "portafoglio ordini"}

# Inizia l’elaborazione del flusso websocket di Shrimpy!

client.connect ()

client.subscribe (subscribe_data, handler)

# Una volta completato, ferma il client

client.disconnect ()

Websocket commerciale

Il websocket di scambio invia ciascuna delle operazioni eseguite sullo scambio. Questi dati sugli scambi tick-by-tick forniscono il modo più veloce per visualizzare ogni scambio effettuato da tutti i partecipanti al mercato.

importare gamberetti

public_key = ‘…’

private_key = ‘…’

# Questo è un gestore di esempio, stampa semplicemente il messaggio di errore in arrivo sulla console

def error_handler (err):

stampa (err)

# Questo è un gestore di esempio, stampa semplicemente il messaggio in arrivo sulla console

gestore def (msg):

stampa (msg)

api_client = shrimpy.ShrimpyApiClient (public_key, private_key)

raw_token = api_client.get_token ()

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

subscribe_data = {

"genere": "sottoscrivi",

"scambio": "binance",

"paio": "ltc-btc",

"canale": "commercio"}

# Inizia l’elaborazione del flusso websocket di Shrimpy!

client.connect ()

client.subscribe (subscribe_data, handler)

# Una volta completato, ferma il client

client.disconnect ()

Dati storici di mercato

Ciascuno di questi endpoint di dati storici fornisce vari dati che possono essere utilizzati per valutare il mercato in momenti diversi, strategie di backtest e analizzare le prestazioni.

Candelieri storici (OHLCV)

Le candele storiche possono essere utilizzate per creare grafici, analisi e sviluppare nuove strategie di trading. In Shrimpy sono disponibili candelabri storici per 1 m, 5m, 15m, 1h, 6h, o 1d intervalli. Questi intervalli sono stati standardizzati tra gli scambi per evitare incongruenze.

importare gamberetti

# usa le chiavi pubbliche e private dell’API Shrimpy per creare il client

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

candele = client.get_historical_candles (

“Binance”,

“LTC”,

“BTC”,

“2019-05-19T00: 00: 00.000Z”,

“2019-05-20T00: 00: 00.000Z”,

100,

“15 m”

)

Libri di ordine storico

Le istantanee storiche del registro ordini sono disponibili su tutti i mercati di scambio. Queste istantanee vengono acquisite con un intervallo di 1 minuto per fornire uno dei periodi di istantanea del book degli ordini con la massima risoluzione disponibile sul mercato. La profondità del portafoglio ordini è limitata ai primi 20 su ciascun lato del portafoglio ordini.

Le istantanee del registro degli ordini possono essere utilizzate per sviluppare soluzioni di backtest, analizzare il mercato a lungo termine o ricercare modelli di trading pratici.

importare gamberetti

# usa le chiavi pubbliche e private dell’API Shrimpy per creare il client

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

historical_orderbooks = client.get_historical_orderbooks (

“Binance”,

“LTC”,

“BTC”,

“2019-05-19T00: 00: 00.000Z”,

“2019-05-20T00: 00: 00.000Z”,

100

)

Trades storici tick-by-tick

I dati storici di trading tick-by-tick sono spesso utilizzati dai trader come fattore nella costruzione di nuove strategie di trading. Questi dati storici sono una cronologia completa di ogni operazione eseguita su una coppia di scambio.

importare gamberetti

# usa le chiavi pubbliche e private dell’API Shrimpy per creare il client

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

trades = client.get_historical_trades (

“Binance”,

“LTC”,

“BTC”,

“2019-05-19T00: 00: 00.000Z”,

“2019-05-20T00: 00: 00.000Z”,

100

)

A proposito di gamberetti

Gamberetti è un’applicazione per la costruzione di fondi indicizzati di criptovaluta personalizzati, il ribilanciamento e la gestione di un portafoglio diversificato di risorse digitali. Automatizza il tuo portafoglio collegandoti a uno dei 17 scambi di criptovaluta che supportiamo.

API di Shrimpy Universal Crypto Exchange sono progettati per gli sviluppatori. L’integrazione con le nostre API unificate ti dà accesso immediato a endpoint uniformi per il trading, la raccolta dei dati, la gestione degli utenti e altro ancora in tutti i principali scambi di criptovaluta.

Per accedere alle librerie complete Python e Node, segui questi collegamenti:

Nodo

Pitone

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