A API para bots de negociação de criptografia

>

Os bots de negociação de criptografia são uma das ferramentas mais comumente usadas pelos comerciantes. Esses aplicativos podem fornecer maneiras convenientes para os comerciantes executarem estratégias que seriam tediosas de implementar.

Infelizmente, os desenvolvedores estão enfrentando dificuldades para construir aplicativos comerciais. É preciso muito tempo e paciência para desenvolver a infraestrutura que se conecta a cada central. Muitas equipes acreditam incorretamente que existem maneiras simples de escalar a infraestrutura de negociação, mas rapidamente aprendem que é muito mais complicado do que parece à primeira vista.

Muitos serviços de negociação lutam para ultrapassar até mesmo uma única integração de câmbio. Cada nova integração de troca além das maiores bolsas produz retornos cada vez mais baixos, tornando impraticável construir um serviço para mais do que as poucas principais bolsas.

As seções a seguir discutirão como os desenvolvedores podem integrar todas as principais bolsas sem nunca se preocupar em manter e dimensionar a infraestrutura complexa necessária para as trocas.

Crypto Trading Bots – O guia completo

Problemas com a integração de bolsas

Os desenvolvedores estão tendo dificuldade em criar aplicativos de negociação que se conectem a bolsas de criptomoedas.

Quando você está partindo em uma jornada para construir uma ferramenta de negociação de criptomoeda, como um bot, é importante primeiro entender os riscos de construir a infraestrutura de câmbio do zero.

Nota: Estes são apenas alguns das questões que devem preocupar você. Há muitos mais que não discutiremos.

Inconsistência


Cada troca é diferente. Duas bolsas não oferecem suporte às mesmas APIs, recursos de negociação, formatos de dados ou comportamento. Não há padrões para como as trocas de criptografia devem ser construídas.

O resultado é que cada integração de câmbio é uma nova aventura. Não uma daquelas aventuras agradáveis ​​que fazem você se sentir vivo por dentro. É como uma daquelas aventuras em que você se perde por 2 meses no deserto e não consegue mais distinguir entre alucinações e miragens. Literalmente, tudo parece um oásis, mas no final é apenas mais deserto.

Pode levar meses para entender as diferentes armadilhas de cada troca. O desenvolvimento de uma forma consistente de negociação em todas as bolsas pode parecer quase impossível. A infraestrutura que você desenvolve precisará mudar repetidamente à medida que você descobrir novas maneiras de as trocas atrapalharem seu design anterior.

A inconsistência não se limita apenas aos terminais da API. Os ativos nas bolsas têm diferentes símbolos, nomes e outras informações de identificação. Para oferecer suporte a todos os ativos em uma troca, os desenvolvedores precisam mapear manualmente os ativos entre as trocas, pesquisando qual ativo a troca listou.

Como existem milhares de ativos, o processo pode levar semanas. Sem mencionar que toda vez que uma bolsa lista um novo ativo, os desenvolvedores precisam validar o novo ativo.

Mapear ativos automaticamente é quase impossível. Para garantir a precisão, deve ser um processo manual.

As APIs do Shrimpy Developer resolvem esse problema identificando e marcando ativos automaticamente nas trocas. O comportamento de negociação e formatos que usamos para os dados são consistentes em todas as bolsas. Todos os processos manuais são gerenciados pela equipe Shrimpy, para que você possa se concentrar no desenvolvimento de recursos.

Manutenção

Como mencionamos anteriormente, algumas trocas listam ativos com frequência. O processo de gerenciamento do processo de listagem, marcação de ativos e mapeamento de ativos nas trocas é amplamente manual.

Essa não é a única manutenção necessária para a construção da infraestrutura comercial. As trocas frequentemente ficam inativas para manutenção, atualizam suas APIs ou mudam o comportamento das solicitações inesperadamente.

Cada mudança feita por uma troca requer que os desenvolvedores liberem atualizações, reimplante servidores e detectem automaticamente quando essas mudanças são feitas. Sob algumas condições, as trocas nem notificam os desenvolvedores quando uma mudança está chegando. Você vai acordar uma manhã e as APIs serão diferentes.

Sem mencionar os esforços contínuos para integrar novos recursos que são suportados pela troca, descontinuar recursos antigos ou terminais e atualizar o código conforme as condições para a mudança de troca.

As APIs do Shrimpy Developer resolvem esse problema gerenciando atualizações, reimplantando a infraestrutura e integrando novos recursos sem nunca alterar a interface da API. Os desenvolvedores podem ficar tranquilos à noite sabendo que acordarão com um produto que está zumbindo.

Limites de taxa

Cada troca tem diferentes limites de taxas e regras de como você pode interagir com as APIs. Para obedecer a essas regras, os desenvolvedores são frequentemente forçados a manter um conjunto de servidores necessários para lidar com o volume de negociações que o aplicativo executa.

Este conjunto de servidores requer coordenação e roteamento inteligente para garantir que o serviço esteja de acordo com as restrições de API enquanto ainda executa negociações para cada usuário em tempo hábil.

À medida que aumenta o número de usuários, esse problema só aumenta em complexidade. Gerenciar centenas de servidores, cada um com interface independente com as trocas, torna-se um pesadelo.

As APIs do Shrimpy Developer resolvem esse problema gerenciando o farm de servidores para você. Nossa infraestrutura se adapta a você, então, se você tem 1 ou 1.000 usuários, não há mudanças necessárias na forma como você aumenta sua infraestrutura.

Custo

Os custos do servidor necessários para gerenciar dezenas de milhares ou centenas de milhares de usuários são caros. Na verdade, construir uma infraestrutura robusta custaria à maioria das equipes entre US $ 3 e US $ 6 / usuário / mês. Embora pareça alto, é o custo de manter um conjunto tão grande de servidores que se conectam a trocas.

Infelizmente, isso nem inclui os custos de desenvolvimento. Pode ser caro contratar desenvolvedores de classe mundial com experiência suficiente para construir a infraestrutura de que você precisa. Os custos só aumentam à medida que você precisa de integrações adicionais.

Construir infraestrutura para trocas é caro.

As APIs de desenvolvedor Shrimpy são baratas. Os custos começam em $ 1,40 / usuário / mês e diminuem à medida que você embarca mais usuários.

Gerenciamento de conta de usuário

Agora que entendemos as dificuldades com o gerenciamento da infraestrutura de troca, veremos exemplos de como podemos aproveitar as APIs do Shrimpy Developer para simplificar nosso processo de desenvolvimento.

Para começar, precisamos saber como gerenciar usuários, conectar-se a contas de troca de usuários e começar a acessar as informações de suas contas.

Com as APIs do Shrimpy, cada usuário é gerenciado individualmente para que mapeie a maneira como você desenvolve seu aplicativo. Se você tiver 1.000 usuários em seu aplicativo, terá 1.000 usuários criados com as APIs Shrimpy.

Configurando nosso ambiente Python

Antes de começarmos, vamos configurar nosso ambiente Python instalando a biblioteca Shrimpy Python.

pip install shrimpy-python

Observação: a biblioteca Shrimpy Python foi projetada para funcionar com Python3. Se você estiver usando Python2, atualize sua versão do Python.

Shrimpy & Chaves de API do Exchange

Sempre que você vir as seguintes linhas nos exemplos de script, devemos inserir nossas chaves de API públicas e secretas Shrimpy. Eles são gerados ao se inscrever no Shrimpy e selecionar a criação de novas chaves de API.

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

Além das chaves de API do Shrimpy, veremos lugares no código para a troca de chaves de API públicas e secretas. Essas chaves são necessárias para se conectar a contas de câmbio.

exchange_public_key = ‘…’

exchange_secret_key = ‘…’

Criar usuário

Cada vez que um usuário se inscreve em seus serviços, tudo o que você precisa fazer é criar um novo usuário com Shrimpy. Este processo pode ser semelhante ao seguinte.

# importar bibliotecas necessárias

importar camarão

# atribua suas chaves de API Shrimpy Master para uso posterior

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# crie o cliente Shrimpy

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# criar um usuário que será vinculado ao nosso intercâmbio

create_user_response = client.create_user (‘O Mestre do Camarão’)

user_id = create_user_response [‘id’]

Salve o ‘user_id’ para que possa ser usado em scripts posteriores. Este é o ID que você usará para mapear seu usuário para o usuário criado com Shrimpy. Este mapeamento pode ser salvo em algum lugar como um banco de dados.

Conectar bolsas

Depois de criar um usuário, é provável que ele deseje se conectar às suas várias trocas. Shrimpy permite que você conecte até 20 contas de troca por usuário por padrão (este limite pode ser aumentado mediante solicitação). O processo de vinculação de uma nova conta do Exchange a um usuário é direto.

# importar bibliotecas necessárias

importar camarão

# atribua suas chaves de API Shrimpy Master para uso posterior

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# atribua suas chaves de câmbio para as quais deseja acessar os dados do saldo

exchange_name = "bittrex"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# atribua o user_id que foi gerado no último exemplo de script

user_id = ‘…’

# se você não consegue se lembrar do seu ‘user_id’, recupere-o do Shrimpy

# deve ser o primeiro usuário se você criou apenas um

users = client.list_users ()

user_id = users [0] [‘id’]

# crie o cliente Shrimpy

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# vincule nossa primeira troca para que possamos acessar os dados do saldo

link_account_response = client.link_account (

ID do usuário,

exchange_name,

exchange_public_key,

exchange_secret_key

)

account_id = link_account_response [‘id’]

Salve o ‘account_id’ para que possamos usá-lo em scripts posteriores. Cada conta de troca para o usuário terá um ID único.

Obter saldos da conta

Uma vez que a conta de câmbio esteja vinculada a um usuário, podemos acessar os saldos dessa conta de câmbio executando o seguinte script.

importar camarão

# use suas chaves públicas e privadas da API Shrimpy para criar o cliente

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# observação: já que criamos um usuário em nosso script de exemplo anterior,

# podemos simplesmente recuperar nossa lista de usuários.

users = client.list_users ()

user_id = users [0] [‘id’]

# recuperar as contas associadas a este usuário

accounts = client.list_accounts (

ID do usuário

)

account_id = accounts [0] [‘id’]

# acessar dados de saldo para a conta de usuário que você criou anteriormente

balance = client.get_balance (

user_id, # user_id

account_id # account_id

)

O resultado deste script é uma lista de cada ativo que pertence ao usuário e a quantidade exata de cada ativo.

Trading & Gestão de Pedidos

Sem negociação, construir um bot de negociação seria impossível. As APIs do Shrimpy Developer fornecem as opções mais robustas para negociação. Essas opções agilizam o processo de desenvolvimento, simplificam estratégias e otimizam a forma como as negociações são executadas.

Existem alguns tipos de pedidos diferentes que são suportados pelas APIs de desenvolvedor do Shrimpy. Os tipos de pedido mais importantes serão incluídos na discussão aqui.

Limite de pedidos

Shrimpy oferece suporte a dois tipos diferentes de pedidos de limite. Essas são ordens IOC e GTC. Embora ambos tenham a mesma premissa, eles têm comportamentos ligeiramente diferentes que os tornam ideais para diferentes situações.

Pedidos imediatos ou cancelados (IOC)

Os pedidos IOC são projetados para serem executados imediatamente. O pedido deve ser colocado a um preço que está atualmente ocupado por um pedido aberto para que o pedido seja executado imediatamente ao preço especificado ou melhor. Se o mercado se mover e o preço especificado não estiver mais disponível, o pedido será imediatamente cancelado e os fundos bloqueados no pedido serão devolvidos ao usuário.

Executar um pedido IOC seria mais ou menos assim com Shrimpy.

importar camarão

# use suas chaves públicas e privadas da API Shrimpy para criar o cliente

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# observação: já que criamos um usuário em nosso script de exemplo anterior,

# podemos simplesmente recuperar nossa lista de usuários.

users = client.list_users ()

first_user_id = users [0] [‘id’]

# recuperar as contas associadas a este usuário

accounts = client.list_accounts (

first_user_id

)

first_account_id = accounts [0] [‘id’]

# acessar dados de saldo para a conta de usuário que você criou anteriormente

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

# executar uma ordem de 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’, # quantidade de base_symbol

‘0,026’, # preço

‘Vender lado

‘IOC’, # time_in_force

)

limit_order_id = place_limit_order_response [‘id’]

Observe como esse script exato pode ser executado para cada troca. Você não precisaria alterar nada além da conta de câmbio que está se referindo para executar uma negociação em outra bolsa.

Esse comportamento é exclusivo do Shrimpy. A implementação da infraestrutura por conta própria exigiria que você escrevesse um código personalizado para cada troca.

Nota: O preço para o comércio incluído aqui é apenas um preço de exemplo. O preço deve ser medido com base no estado atual do mercado. Não execute este script “como está”.

Good Til ’Cancel (GTC)

Os pedidos GTC são colocados em um preço e quantidade específicos. A ordem permanecerá aberta na bolsa até que outro trader compre a ordem ou até que você cancele a ordem. Uma ordem aberta que é tomada por outro negociante incorre em taxas de negociação do fabricante.

As taxas do fabricante são normalmente mais baixas do que as taxas do tomador em muitas bolsas, uma vez que deixar ordens em aberto na bolsa adiciona liquidez ao mercado. Por esse motivo, muitas bolsas querem recompensar a liquidez adicional.

importar camarão

# use suas chaves públicas e privadas da API Shrimpy para criar o cliente

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# observação: já que criamos um usuário em nosso script de exemplo anterior,

# podemos simplesmente recuperar nossa lista de usuários.

users = client.list_users ()

first_user_id = users [0] [‘id’]

# recuperar as contas associadas a este usuário

accounts = client.list_accounts (

first_user_id

)

first_account_id = accounts [0] [‘id’]

# acessar dados de saldo para a conta de usuário que você criou anteriormente

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

# executar uma ordem de 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’, # quantidade de base_symbol

‘0,026’, # preço

‘Vender lado

‘GTC’, # time_in_force

)

limit_order_id = place_limit_order_response [‘id’]

Nota: O preço para o comércio incluído aqui é apenas um preço de exemplo. O preço deve ser calculado com base no estado atual do mercado. Não execute este script “como está”.

Leia mais sobre pedidos com limite

Roteamento inteligente de pedidos

Coletar dados em centenas de pares de negócios e analisar os dados para roteamento de comércio otimizado é complicado. Por esse motivo, Shrimpy oferece Smart Order Routing (SOR) pronto para uso.

O SOR automatiza a execução do pedido, para que você possa gastar mais tempo gerenciando para onde os fundos devem ir, em vez de como eles chegam lá. Shrimpy irá encaminhar de forma inteligente a ordem entre pares comerciais para garantir a melhor execução da ordem.

Exemplo: digamos que você queira trocar ETH por LTC.

Em qualquer troca, pode haver 10 caminhos diferentes que podem ser seguidos para vender ETH e comprar LTC. Você poderia ir ETH->BTC->LTC, ETH->LTC, ETH->USDT->LTC, ETH->USDC->LTC e assim por diante. Cada um deles terá taxas diferentes que mudam constantemente.

O SOR avaliará automaticamente todas essas opções, dividirá as ordens e executará as negociações ideais.

importar camarão

# use suas chaves públicas e privadas da API Shrimpy para criar o cliente

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# observação: já que criamos um usuário em nosso script de exemplo anterior,

# podemos simplesmente recuperar nossa lista de usuários.

users = client.list_users ()

first_user_id = users [0] [‘id’]

# recuperar as contas associadas a este usuário

accounts = client.list_accounts (

first_user_id

)

first_account_id = accounts [0] [‘id’]

# acessar dados de saldo para a conta de usuário que você criou anteriormente

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

# executar uma ordem de mercado

smart_order_response = client.create_trade (

first_user_id, # user_id

first_account_id, # account_id

‘BTC’, # from_symbol

‘ETH’, # to_symbol

‘0,01’ # quantidade de from_symbol

True # enable smart_routing

)

API para roteamento inteligente de pedidos

Live Market Data

Para executar negociações, precisamos de dados de mercado ao vivo para tomar decisões rápidas sobre como e quando executar ordens.

Shrimpy fornece uma API REST e uma API Websocket para garantir que você possa construir um aplicativo com dados ao vivo que funcione melhor para você.

Endpoints API REST

Esses endpoints da API REST fornecem a maneira mais fácil para os desenvolvedores acessarem dados de mercado sob demanda, sem se conectar a websockets.

Encomendar livros

Você pode acessar o instantâneo do livro de pedidos mais recente usando o terminal a seguir. Isso irá retornar instantaneamente o instantâneo do livro ao vivo que você pode usar para tomar decisões sobre como executar negociações.

importar camarão

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

orderbooks = client.get_orderbooks (

‘binance’, # troca

‘XLM’, # base_symbol

‘BTC’, # quote_symbol

10 # limite

)

Castiçais

Se você precisa de gráficos que acompanham as atualizações ao vivo do mercado, pode solicitar os castiçais mais recentes para se manter atualizado com todos os movimentos do mercado.

Este endpoint retorna os últimos 1.000 candlesticks. Se precisar de mais castiçais, você deve usar o ponto de extremidade “histórico de velas”.

importar camarão

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

velas = client.get_candles (

‘binance’, # troca

‘XLM’, # base_trading_symbol

‘BTC’, # quote_trading_symbol

’15m’ # intervalo

)

Websocket Endpoints

Os aplicativos de negociação em tempo real requerem dados de mercado em tempo real em uma base contínua. A maneira mais fácil de implementar essas estratégias é alavancar a carteira de pedidos e os websockets de dados comerciais. Esses websockets mantêm os assinantes atualizados com cada negociação que é executada e cada pedido que é colocado na bolsa.

Order Book Websocket

O websocket do livro de pedidos enviará continuamente as alterações mais recentes ao livro de pedidos. Shrimpy sempre envia imediatamente as atualizações assim que se tornam disponíveis.

importar camarão

public_key = ‘…’

private_key = ‘…’

# Este é um manipulador de amostra, ele simplesmente imprime a mensagem de erro recebida no console

def error_handler (err):

imprimir (errar)

# Este é um manipulador de amostra, ele simplesmente imprime a mensagem recebida no console

manipulador de def (msg):

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

"modelo": "se inscrever",

"intercâmbio": "binance",

"par": "ltc-btc",

"canal": "livro de encomendas"}

# Comece a processar o stream de websocket Shrimpy!

client.connect ()

client.subscribe (subscribe_data, handler)

# Depois de concluído, pare o cliente

client.disconnect ()

Trade Websocket

O websocket de negociação envia cada uma das negociações que são executadas na bolsa. Estes dados de negociação tick-by-tick fornecem a maneira mais rápida de visualizar cada negociação feita por todos os participantes do mercado.

importar camarão

public_key = ‘…’

private_key = ‘…’

# Este é um manipulador de amostra, ele simplesmente imprime a mensagem de erro recebida no console

def error_handler (err):

imprimir (errar)

# Este é um manipulador de amostra, ele simplesmente imprime a mensagem recebida no console

manipulador de def (msg):

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

"modelo": "se inscrever",

"intercâmbio": "binance",

"par": "ltc-btc",

"canal": "troca"}

# Comece a processar o stream de websocket Shrimpy!

client.connect ()

client.subscribe (subscribe_data, handler)

# Depois de concluído, pare o cliente

client.disconnect ()

Dados históricos do mercado

Cada um desses terminais de dados históricos fornece vários dados que podem ser usados ​​para avaliar o mercado em momentos diferentes, estratégias de backtest e análise de desempenho.

Castiçais históricos (OHLCV)

Os castiçais históricos podem ser usados ​​para gráficos, análises e desenvolvimento de novas estratégias de negociação. No Shrimpy, castiçais históricos estão disponíveis para 1m, 5m, 15m, 1h, 6h, ou 1d intervalos. Esses intervalos foram padronizados entre as trocas para evitar inconsistências.

importar camarão

# use suas chaves públicas e privadas da API Shrimpy para criar o cliente

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

velas = client.get_historical_candles (

‘Binance’,

‘LTC’,

‘BTC’,

‘2019-05-19T00: 00: 00.000Z’,

‘2019-05-20T00: 00: 00.000Z’,

100,

’15m’

)

Livros de pedidos históricos

Instantâneos históricos do livro de pedidos estão disponíveis em todos os mercados de câmbio. Esses instantâneos são obtidos em um intervalo de 1 minuto para fornecer um dos períodos de instantâneo de livro de pedidos de maior resolução disponíveis no mercado. A profundidade do livro de pedidos é limitada aos 20 primeiros em cada lado do livro de pedidos.

Os instantâneos do livro de pedidos podem ser usados ​​para desenvolver soluções de backtesting, analisar o mercado a longo prazo ou pesquisar padrões de negociação práticos.

importar camarão

# use suas chaves públicas e privadas da API Shrimpy para criar o cliente

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

)

Comércios históricos tick-by-tick

Os dados históricos de negociação tick-by-tick são frequentemente usados ​​pelos traders como um fator na construção de novas estratégias de negociação. Estes dados históricos são um histórico completo de todas as negociações que foram executadas em um par de negociação de bolsa.

importar camarão

# use suas chaves públicas e privadas da API Shrimpy para criar o cliente

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

)

Sobre Shrimpy

Shrimpy é um aplicativo para construir fundos de índice de criptomoeda personalizados, rebalancear e gerenciar um portfólio diversificado de ativos digitais. Automatize seu portfólio vinculando-se a qualquer uma das 17 trocas de criptografia que apoiamos.

APIs Universal Crypto Exchange do Shrimpy são projetados para desenvolvedores. A integração com nossas APIs unificadas oferece acesso instantâneo a endpoints uniformes para negociação, coleta de dados, gerenciamento de usuários e muito mais em todas as principais bolsas de criptomoedas.

Para acessar as bibliotecas Python e Node completas, siga estes links:

Pitão

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