Como fazer um bot de troca de criptografia usando Python – um guia do desenvolvedor

>

A negociação de criptomoedas pode parecer opressora no início. Há muitos componentes para pensar, dados para coletar, trocas para integrar e gerenciamento de pedidos complexos.

Este guia fornecerá uma análise passo a passo detalhada dos diferentes componentes de que você precisa para construir um bot de criptografia completo. Pense neles como os blocos de construção do seu bot de negociação.

Lembrete: Esta é uma experiência educacional. Os exemplos de código não foram projetados para serem produzidos. Eles são projetados para ajudar a fornecer uma compreensão básica de como construir um bot de negociação. Prepará-los para a produção é sua responsabilidade.

Por que trocar bots?

Queremos um sistema que seja sistemático, sem emoção e funcione 24 horas por dia, 7 dias por semana.

Ao contrário dos humanos, os bots comerciais podem executar estratégias precisas de maneira consistente. Um exemplo de estratégia precisa que é difícil para humanos implementar é a arbitragem. A negociação de arbitragem é uma estratégia quase exclusivamente executada por bots de negociação no mundo de hoje. Os bots de negociação podem executar ordens dentro de milissegundos da ocorrência de um evento. Os humanos não têm os reflexos ou a capacidade de implementar de forma eficaz tal estratégia sem algum tipo de robô comercial.

Mais geralmente do que simplesmente o que é possível, os traders querem algo que seja confiável e determinístico. Dessa forma, não há oportunidade de erro. Quando a estratégia é definida, a estratégia será executada com base nos parâmetros do algoritmo. Isso é realmente tudo que há para fazer.

Configurar

Antes de começarmos, devemos configurar nosso ambiente. Isso envolverá algumas etapas para obter acesso às APIs de negociação e às nossas contas de câmbio, mas uma vez configurado, não precisaremos fazer nenhuma alteração em nosso ambiente de desenvolvimento.

Inscreva-se no Shrimpy

Acesse o site da API Shrimpy Developer aqui. Inscreva-se pra uma conta.

Gerar & Armazenar chaves de API

Antes de começarmos a usar as APIs do Shrimpy, precisaremos gerar nossas chaves de API. Isso pode ser feito entrando em sua conta de desenvolvedor Shrimpy e indo para a guia “Chaves de API”. Selecione o botão para “Criar chave mestre de API”.

Selecione “Criar chave mestre de API”.

Depois de selecionar o botão “Criar chave mestre de API”, você será solicitado a verificar sua conta digitando sua senha e 2FA de 6 dígitos. Se você ainda não habilitou o 2FA para sua conta, primeiro precisará passar pelo processo de configuração do 2FA.

Digite seu código de verificação de 6 dígitos e senha da conta.

Depois de verificar sua conta, Shrimpy enviará um e-mail solicitando que você confirme a criação da chave API.

Confirme seu e-mail clicando no link do e-mail de verificação.

Depois de confirmar a criação da chave de API em seu e-mail, você verá um cartão que representa sua chave de API de desenvolvedor. A chave pública será exibida por padrão.

Selecione “Mostrar” a chave API privada. Isso só pode ser feito uma vez, portanto, armazene com segurança a chave secreta assim que ela for mostrada.

Selecione “Mostrar” a chave privada. A chave privada não será mostrada por padrão e só pode ser vista UMA vez. Isso significa que depois de visualizar sua chave privada, Shrimpy nunca mais mostrará a chave novamente. Se você não armazenar a chave privada com segurança, precisará passar pelo processo de criação de uma nova chave. Depois de selecionar “Mostrar” a chave API privada, você será solicitado novamente a confirmar sua conta inserindo seu código 2FA e senha.

Copie as chaves pública e privada (secreta) para locais seguros.

Assim que a chave de API privada for mostrada, copie as chaves de API pública e privada para um local seguro. Nunca compartilhe esta chave de API com ninguém.

Antes de concluirmos a configuração da chave API, selecione para habilitar todas as permissões na chave API. Usaremos todas as configurações para este guia de tutorial, no entanto, você pode reconfigurar sua configuração quando estiver pronto para implantar sua versão de produção de seu bot comercial. Durante o teste, não exigimos nenhuma configuração complexa.

Observação: você pode criar várias chaves de API. Se você deseja ter um conjunto de chaves de API com apenas permissões de “Dados”, um conjunto apenas com permissões de “Conta” e um com permissões de “Usuário”, você pode configurar suas chaves da maneira que desejar.

Habilite todas as permissões nas chaves de API e selecione “Atualizar”.

Não precisamos comprar nenhum crédito para testar o Shrimpy, mas você pode comprar créditos a qualquer momento no "Pagamento" aba. Isso se parecerá com a imagem abaixo.

Compre créditos quando estiver pronto. Shrimpy vai começar com 500 créditos grátis, então este tutorial não exigirá nenhum pagamento.

Antes que os créditos possam ser comprados, primeiro solicitamos que você vincule um método de pagamento. Depois de vincular uma forma de pagamento, você pode inserir o valor dos créditos que deseja comprar.

Depois de passar por todas essas etapas, você pode sair da sua conta Shrimpy Developer API. Não precisamos de mais nada de nossa conta neste momento.

Configurando nosso ambiente Python

Precisamos configurar algumas coisas para nosso ambiente Python antes de começar a codificar. Primeiro, comece instalando a biblioteca Shrimpy Python.

pip install shrimpy-python

Além de instalar a Biblioteca Shrimpy, também instalaremos algumas outras bibliotecas que serão usadas para plotagem de dados posteriormente no tutorial. Essas bibliotecas são Pandas e Plotly.

pip instalar pandas

pip install plotly == 4.1.0

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

Chaves de API do Exchange

Antes de começarmos a codificar, precisamos de mais uma informação. Essas são as chaves de API de troca. Essas chaves de API são recuperadas da bolsa que você deseja usar para negociação.

Com o plano pessoal Shrimpy, você pode se conectar a 20 contas de câmbio diferentes ao mesmo tempo, mas para esses exemplos, vamos conectar apenas a uma. Faça login em sua conta do Exchange e siga o tutorial apropriado em nossa lista de artigos específicos do Exchange aqui.

Estes artigos o ajudarão a obter acesso à sua chave de API e copiá-los em um local seguro. Depois que as chaves de API forem copiadas, você pode fechar o artigo. Você não precisa colá-los no aplicativo de gerenciamento de portfólio Shrimpy, já que só os usaremos para nossos scripts ao longo desses tutoriais de exemplo.

Código

Agora estamos prontos para começar a codificar! Os exemplos a seguir incluirão espaços em que você precisará inserir suas chaves de API públicas e secretas para o Shrimpy e o Exchange.

Quando você vê:

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

Insira as chaves mestras da API Shrimpy que você gerou nas etapas anteriores.

Quando você vê:

exchange_public_key = ‘…’

exchange_secret_key = ‘…’

Insira as chaves de API específicas de troca que você gerou nas etapas anteriores.

Coletando dados de preços

Uma das informações mais importantes para um bot decidir quando executar uma negociação são os dados de preços. Os dados de preços específicos de câmbio devem ser usados ​​para calcular os tempos de negociação ideais, bem como a colocação exata dos pedidos.

Geralmente, os dados do livro de pedidos são usados ​​para tomar decisões específicas sobre onde colocar um pedido e os dados da negociação podem ser usados ​​para determinar quando um pedido deve ser executado.

Ticker de preço simples

O ticker de preço simples é uma forma de acessar os preços mais recentes para cada ativo em uma bolsa. Este valor é atualizado em um intervalo de 1 minuto. O objetivo deste terminal é apenas para fins de exibição. Este terminal não foi projetado para execução de ordens ou arbitragem. Oferecemos outros terminais para esses fins.

importar camarão

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

ticker = client.get_ticker (‘binance’)

Websocket Price Ticker

Se você precisa de um ticker de preços em tempo real com as últimas negociações sendo executadas, este ticker de preços de websocket é para você. Ao contrário do “Ticker de Preço Simples”, o ticker de preço do websocket é em tempo real. Isso significa que não há atraso entre o momento em que a negociação é executada na bolsa e as atualizações do indicador de preço.

Este endpoint é mais complexo, entretanto, pois exigirá uma conexão de websocket.

importar camarão

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

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

def error_handler (err):

imprimir (errar)

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

manipulador de def (msg):

imprimir (msg [‘conteúdo’] [0] [‘preço’])

api_client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

raw_token = api_client.get_token ()

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

subscribe_data = {

"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 ()

Instantâneo simples do livro de pedidos ao vivo

Este endpoint de API restante fornecerá o instantâneo mais recente do livro de pedidos ativo. Conforme a carteira de pedidos é atualizada ao vivo, você pode acessar um instantâneo desses dados ao vivo para executar negociações, fornecer informações para a tomada de decisões ou mesmo apenas analisar o mercado.

importar camarão

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

orderbooks = client.get_orderbooks (

‘bittrex’, # troca

‘XLM’, # base_symbol

‘BTC’, # quote_symbol

10 # limite

)

Websocket Live Order Book

Se você não quiser pesquisar atualizações para obter os dados mais recentes do livro de pedidos, você sempre pode usar o websocket do livro de pedidos ao vivo, semelhante ao websocket ao vivo para negociações.

O portal do livro de pedidos enviará imediatamente as atualizações mais recentes do livro de pedidos assim que quaisquer alterações forem feitas no livro de pedidos da troca. Dessa forma, a sua cópia local do livro de pedidos nunca fica desatualizada.

importar camarão

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

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

def error_handler (err):

imprimir (errar)

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

manipulador de def (msg):

imprimir (msg)

api_client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

raw_token = api_client.get_token ()

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

subscribe_data = {

"modelo": "se inscrever",

"intercâmbio": "binance",

"par": "eth-btc",

"canal": "livro de encomendas"}

# Comece a processar o stream de websocket Shrimpy!

ws_client.connect ()

ws_client.subscribe (subscribe_data, handler)

# Depois de concluído, pare o cliente

ws_client.disconnect ()

Vinculando uma conta Exchange

Antes de começarmos a acessar as informações de nossa conta na troca ou executar negociações, precisaremos vincular uma conta de troca. Só precisamos conectar uma conta de troca uma vez. Depois que a conta for vinculada, Shrimpy manterá a conexão para que você não precise vincular as chaves novamente.

# 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 = ‘…’

# 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’]

# 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’]

Recuperando Saldos de Contas de Câmbio

Para negociar, é provável que queiramos saber quanto de cada ativo que temos disponível em nossa conta para negociar. Sem essas informações, estaríamos estimando a quantidade de fundos que temos disponíveis para cada ativo.

Use este script para acessar os saldos de qualquer conta de câmbio que tenha sido vinculada às suas APIs de desenvolvedor 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)

# nota: já que criamos um usuário em nosso último exemplo de script,

# 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

)

Executando uma negociação

Agora que temos os dados de preço, dados do livro de pedidos e informações da conta de que precisamos, é hora de começar a negociar!

É importante lembrar que a negociação é complexa. Os exemplos fornecidos aqui serão um ótimo ponto de partida, mas não são a linha de chegada. O desenvolvimento de uma colocação comercial completa e algoritmo de execução levará tempo.

Comércio Simples

Crie uma negociação acessando primeiro os saldos disponíveis na bolsa que você conectou ao Shrimpy. Neste exemplo, vamos executar negociações a fim de consolidar todos os nossos fundos em BTC.

A execução deste script executará negociações ao vivo em sua conta de câmbio real. Isso significa que você só deve executar este script se pretende mover todos os seus ativos para o BTC.

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)

# nota: já que criamos um usuário em nosso último exemplo de script,

# 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

)

participações = saldo [‘saldos’]

# selecione o ativo para o qual deseja consolidar

consolidação_symbol = ‘BTC’

# vender todos os ativos além do ativo de consolidação

para ativos em participações:

asset_symbol = asset [‘symbol’]

asset_amount = asset [‘nativeValue’]

if asset_symbol! = Consolidation_symbol:

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

create_trade_response = client.create_trade (

first_user_id,

first_account_id,

asset_symbol,

consolidação_symbol,

valor_do_material

)

Roteamento inteligente de pedidos

O roteamento inteligente de ordens encaminhará de forma inteligente as negociações por meio de quaisquer pares de negociação disponíveis para receber o melhor preço. Ao executar uma estratégia de roteamento de pedido inteligente, você não pode especificar as moedas de cotação, apenas as moedas “de” e “para”. As moedas de cotação serão determinadas com base nos caminhos que resultarão na melhor execução do pedido.

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)

# nota: já que criamos um usuário em nosso último exemplo de script,

# 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

)

Charting Candlesticks

Se você estiver negociando, deverá ter uma forma visual de ver o preço atual dos ativos. Isso geralmente é feito por meio de velas. Neste exemplo, mostraremos como gerar velas para visualização ou integração de estratégia.

importar camarão

import plotly.graph_objects as go

# inscreva-se nas APIs de desenvolvedor Shrimpy para obter suas chaves de API gratuitas

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# colete os dados históricos do candlestick

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

velas = client.get_candles (

‘bittrex’, # troca

‘XRP’, # base_trading_symbol

‘BTC’, # quote_trading_symbol

‘1d’ # intervalo

)

datas = []

open_data = []

high_data = []

low_data = []

close_data = []

# formate os dados para corresponder à biblioteca de plotagem

para velas em velas:

datas.append (vela [‘hora’])

open_data.append (candle [‘abrir’])

high_data.append (candle [‘high’])

low_data.append (candle [‘low’])

close_data.append (candle [‘fechar’])

# plotar os castiçais

fig = go.Figure (data = [go.Candlestick (x = datas,

open = open_data, high = high_data,

low = low_data, close = close_data)])

fig.show ()

Juntando tudo

Agora que você tem cada componente para construir seu bot de negociação. É hora de colocar cada um desses componentes juntos para executar uma estratégia de bot de negociação.

Por exemplo, se você quiser construir um script simples que irá olhar para o par BTC / USDT e negociar todo o seu BTC para USDT assim que o BTC tocar em 10000 USDT, você pode fazer algo assim.

importar camarão

tempo de importação

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 = ‘…’

api_client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

raw_token = api_client.get_token ()

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

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

# pule esta etapa se você já criou um usuário

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

user_id = create_user_response [‘id’]

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

# ignore esta etapa se você já vinculou uma conta

link_account_response = api_client.link_account (

ID do usuário,

exchange_name,

exchange_public_key,

exchange_secret_key

)

account_id = link_account_response [‘id’]

# aguarde enquanto Shrimpy coleta dados para a conta de troca

# exigiu apenas a primeira vinculação

tempo.sono (5)

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

balance = api_client.get_balance (

user_id, # user_id

account_id # account_id

)

btcAmount = 0

para ativo em balanço [‘saldos’]:

se ativo [‘símbolo’] == ‘BTC’:

btcAmount = asset [‘nativeValue’]

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

def error_handler (err):

imprimir (errar)

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

manipulador de def (msg):

preço = msg [‘conteúdo’] [0] [‘preço’]

if int (preço) > 10000:

smart_order_response = api_client.create_trade (

user_id, # user_id

account_id, # account_id

‘BTC’, # from_symbol

‘USDT’, # to_symbol

btcAmount, # quantidade de from_symbol

True # enable smart_routing

)

subscribe_data = {

"modelo": "se inscrever",

"intercâmbio": "binance",

"par": "btc-usdt",

"canal": "troca"}

# Comece a processar o stream de websocket Shrimpy!

ws_client.connect ()

ws_client.subscribe (subscribe_data, handler)

Este script monitorará o mercado até que o Bitcoin chegue a 10000 USDT. Nesse ponto, ele irá negociar todo o seu BTC para USDT.

Este exemplo não verifica casos extremos, modos de falha e muitas outras situações que irão surgir. Nenhum dos exemplos fornecidos é adequado para produção. Eles são apenas para fins educacionais, para fornecer uma maneira de se familiarizar com os conceitos para construir um robô comercial.

Serviços de bot de negociação

Se construir um bot de negociação personalizado do zero não é sua velocidade, isso não é um problema! Existem alguns bots de negociação atualmente disponíveis no mercado que você pode usar. Eles estão prontos para integrar novos usuários e começar a automatizar seu portfólio sem qualquer desenvolvimento.

Shrimpy

Os bots de negociação de criptomoedas não precisam ser complicados. No Shrimpy, levamos essa ideia a sério. Como resultado, criamos os serviços de negociação mais sofisticados que são extremamente fáceis de usar.

Shrimpy foi projetado por criptocríticos, para criptomoedas. Pessoas que planejam permanecer no mercado pelos próximos 10 ou 20 anos. Em vez de se preocupar com o segundo ao segundo tick do mercado, Shrimpy se concentra no horizonte de 10 anos. O objetivo é fornecer uma maneira de automatizar seu portfólio a longo prazo.

Não há outros serviços como o Shrimpy. Simplesmente conecte todas as contas de câmbio que você possui atualmente, selecione um portfólio ou estratégia de indexação e observe Shrimpy manter automaticamente seu portfólio ao longo do tempo. Parece HODLing 2.0.

Em vez de deixar seu portfólio acumular poeira em uma carteira de hardware, Shrimpy reequilibra sistematicamente seu portfólio. Quando você deposita novos fundos em sua conta de câmbio, esses fundos podem ser injetados automaticamente em seu portfólio usando nossos recursos avançados de cálculo de custo em dólar.

Tudo que você precisa para gerenciar seu portfólio é fornecido em um único aplicativo. Acompanhe seu desempenho ao longo do tempo, ajuste rapidamente seu portfólio com base em novas pesquisas ou movimentos de mercado ou apenas deixe o Shrimpy automatizar tudo com nossas estratégias de indexação dinâmica de classe mundial. É a solução definitiva de gerenciamento de ativos pessoais para proprietários de criptomoedas.

Shrimpy oferece suporte para conexão com qualquer uma das 17 principais bolsas de criptomoedas, para que você sempre encontre uma bolsa que funcione perfeitamente para você. Se você não consegue decidir sobre uma única troca, isso não é um problema. Vincule várias bolsas ao Shrimpy para visualizar seu portfólio entre bolsas e gerenciar todas as suas contas de câmbio por meio de um único painel unificado.

Inscreva-se no Shrimpy hoje!

Conclusão

Passe algum tempo explorando o mercado. Desfrute da liberdade de construir seu próprio robô de negociação ou experimente um serviço de negociação existente. O que quer que você decida, aproveite a experiência de participar de um novo sistema financeiro global.

As criptomoedas são um mercado complexo. Conforme expandimos em um futuro previsível, precisaremos continuar desenvolvendo recursos de negociação que nos ajudem a automatizar melhor nosso portfólio e estratégia de negociação.

Não hesite em entrar em contato com nossa equipe se tiver alguma dúvida sobre como construir um bot de negociação, precisar de ajuda para construir uma nova estratégia de negociação ou quiser que integremos novos recursos em nosso APIs de criptografia universal.

Sobre Shrimpy

Shrimpy é um aplicativo para a construção de fundos de índice de criptomoeda personalizados, rebalanceamento e gerenciamento de 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