Copy trade, resumidamente, é o ato de um trader A autorizar ter os seus trades copiados por um trader B (ou vários outros traders). Ou seja, se A efetuar uma compra, B efetua a mesma compra. Se A vender algum ativo, B vende também. Consequentemente, se A tiver lucro, B vai lucrar também, mas o oposto também é verdadeiro.
Existem algumas exchanges que fornecem esse tipo de funcionalidade e também existem plataformas criadas especificamente para essa finalidade. Não vou citar nenhuma aqui pois não uso esse tipo de abordagem, mas conversando com alun0s de meus cursos acabou surgindo a ideia de ensinar o básico de como você pode estruturar um bot para copy trade, para uso pessoal ou de terceiros. Falo “básico” porque copy trade vai muito além de “observar e repetir” trades de alguém. Cada trader tem a sua conta, sua realidade, etc e nem sempre copiar literalmente todos trades com mesmos parâmetros é uma boa ideia e as plataformas mais profissionais dão várias ferramentas para isso.
E por fim, para alinhar expectativas e não lhe fazer perder tempo, este é um tutorial de programação recomendado para quem já possui experiência com programação. Caso não seja o seu caso, lá no meu canal você encontra uma playlist Programação para Iniciantes, recomendado para quem tem zero conhecimento. Além disso, o que vou ensinar aqui exige que você tenha as chaves de API do investidor que vai ter os trades copiados. Então não, este NÃO é um tutorial para criar bot que copia trades de desconhecidos. Acredito que ele vá ser mais útil para quem desenvolve plataformas de bots do que para traders individuais. Também faremos apenas para Binance Futures, caso queira fazer par Binance Spot, use este outro tutorial.
Se preferir, você pode assistir ao vídeo abaixo ao invés de ler, o conteúdo é o mesmo.
Vamos lá!
#1 – Preparação do Ambiente
Utilizaremos a tecnologia Node.js para programar e recomendo que use o editor Visual Studio Code. Ensino a instalar ambos no vídeo abaixo, caso ainda não tenha na sua máquina.
Usaremos a exchange Binance para nosso bot e portanto você precisará das chaves de API de uma ou mais contas dela. Eu vou usar apenas uma conta no tutorial e, além disso, conta de teste apenas e é o que recomendo que você faça. No entanto o bot vai suportar o copy de uma conta para múltiplas outras. No vídeo abaixo eu ensino a criar contas de teste e de produção, caso ainda não tenha.
Com isso você tem o ambiente preparado para programar seu bot, então vamos começar o projeto.
#2 – Estruturando o Projeto
Comece criando uma pasta para o seu projeto. O meu eu vou chamar de binance-copytrade-futures e dentro rode os seguintes comandos para inicializar o projeto e instalar as dependências que vamos precisar.
|
1 2 3 4 |
npm init -y npm i dotenv axios ws |
São 3 as dependências que instalamos, a saber:
- dotenv: para gestão das variáveis de ambiente (configurações);
- axios: para chamadas à API da Binance;
- ws: para conexão na stream da Binance;
Agora crie um arquivo .env na raiz do seu projeto para que possamos configurar as variáveis de ambiente que vamos precisar, explico elas na sequência.
|
1 2 3 4 5 6 7 8 9 10 |
BINANCE_API_URL=https://testnet.binancefuture.com/fapi BINANCE_WS_URL=wss://stream.binancefuture.com/ws TRADER0_API_KEY=<api key do trader> TRADER0_API_SECRET=<api secret do trader> TRADER1_API_KEY=<api key do copy trader 1> TRADER1_API_SECRET=<api secret do copy trader 2> |
As variáveis aqui são bem autoexplicativas caso já tenha feito outros bots para Binance antes, mas segue um resumo:
- BINANCE_API_URL: a URL da API da Binance Futures que vai usar. Neste caso estou apontando para Testnet aqui;
- BINANCE_WS_URL: a URL da stream da Binance Futures que vai usar. Neste caso estou apontando para Testnet aqui. Se a API URL estiver testnet, aqui também de estar testnet ou vai ter problemas;
- TRADER0_API_KEY: a API key do trader que vamos copiar os trades. Se sua URL de API for Testnet, aqui deve ser api key da testnet;
- TRADER0_API_SECRET: a API secret do trader que vamos copiar os trades. Deve ser o par da Api key da configuração anterior;
Agora as últimas duas variáveis merecem uma explicação separada. Isso porque para cada trader que for copiar os trades do primeiro, você deve adicionar um par de variáveis a mais no .env. No exemplo acima eu coloquei apenas um par, o que indica que terá apenas um trader copiando e ficou assim:
- TRADER1_API_KEY: repare no número após a palavra trader, ele deve ser sequencial e representa neste caso a api key do copy trader 1;
- TRADER1_API_SECRET: o secret do trader anterior;
Assim, se quiser adicionar mais um copy trader, seria TRADER2_API_KEY e TRADER2_API_SECRET, por exemplo. Lembrando que TODOS os traders estarão no mesmo ambiente: testnet ou produção.
Este arquivo de variáveis deve ser carregado na inicialização do bot, sendo que ela irá acontecer no index.js, que vamos criar agora. Crie o referido arquivo, carregue o pacote dotenv e vamos escrever uma função que vai iterar pelas variáveis de ambiente procurando pelas contas dos copy traders. Ao final do arquivo, vamos inicializar o bot que por enquanto fará apenas isso.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
require("dotenv").config(); const accounts = []; function loadAccounts() { let i = 1; while (process.env[`TRADER${i}_API_KEY`]) { accounts.push({ apiKey: process.env[`TRADER${i}_API_KEY`], apiSecret: process.env[`TRADER${i}_API_SECRET`] }) i++; } console.log(`${i - 1} copy accounts loaded`); return "empty"; } async function start() { const listenKey = loadAccounts(); } start(); |
Repare que carrego somente as contas dos copy traders e que estou retornando uma string fixa ao final da função, ignore ela por enquanto. Repare também que criei outra função, específica para o start, que chama essa de carregar as contas. O esperado para esta etapa é que o bot esteja conseguindo ler as chaves dos copy traders, só isso.
#3 – Conectando no Trader Mestre
Agora o próximo passo é carregarmos as configurações do trader mestre e nos conectarmos na conta dele. A Binance permite que você “escute” todas as atualizações de uma determinada conta se tiver acesso às chaves dela. Com as chaves em mão, você deve se conectar em uma API que vai lhe fornecer uma listen key. Com a listen key você pode se conectar em uma stream de dados que é acionada toda vez que o saldo da conta muda, toda vez que o status de um trade daquela conta muda e assim por diante. É esse recurso que usaremos para saber o que está rolando na conta mestre e, mais tarde, replicar para as cópias.
Primeiro, precisamos solicitar a listen key para a API correspondente, antes de fazer a conexão de fato. Por uma questão de organização vamos criar um módulo api.js e dentro vamos criar a função de conectar na conta.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
const axios = require('axios'); const apiUrl = process.env.BINANCE_API_URL; async function connectAccount() { const apiKey = process.env.TRADER0_API_KEY; const apiSecret = process.env.TRADER0_API_SECRET; if (!apiKey || !apiSecret) throw new Error('Preencha corretamente sua API KEY e SECRET KEY'); try { const result = await axios({ method: "POST", url: `${apiUrl}/v1/listenKey`, headers: { 'X-MBX-APIKEY': apiKey } }); return result.data; } catch (err) { console.error(err.response ? err.response : err); } } module.exports = { connectAccount } |
Aqui eu comecei carregando o módulo Axios que eu uso para enviar as requisições para a Binance Futures. Depois carrego a API URL que vamos usar a partir do .env e declaro a função connectAccount. Essa função por sua vez carrega as chaves da conta mestre (com número 0), monta a request pra API que gera a listen key e retorna a mesma ao final. A construção da request em si segue o padrão estabelecido na documentação da Binance.
Agora vamos voltar ao nosso index.js e fazer uma segunda versão da função loadAccounts, para que ela carregue também a conta mestre ao invés de apenas as cópias.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
const api = require("./api"); async function loadAccounts() { const { listenKey } = await api.connectAccount(); console.log(`ListenKey obtained/updated: ${listenKey}`); let i = 1; while (process.env[`TRADER${i}_API_KEY`]) { accounts.push({ apiKey: process.env[`TRADER${i}_API_KEY`], apiSecret: process.env[`TRADER${i}_API_SECRET`] }) i++; } console.log(`${i - 1} copy accounts loaded`); return listenKey; } async function start() { const listenKey = await loadAccounts(); console.log("Waiting news..."); setInterval(() => { api.connectAccount(); }, 59 * 60 * 1000) } |
Repare que comecei carregando o módulo da api e que mudei a função para async pois teremos chamada de API dentro dela e isso forçará também a função start a usar await ao chamá-la.
Mais falando dos detalhes mais internos da loadAccounts, agora ela obtém primeiro a listen key usando a connectAccount da API e retorna a mesma ao final da função, pois precisaremos dela na próxima etapa, de conexão na stream de dados da conta mestre. Repare também, na função start, que coloquei um timer que roda a cada 59 minutos. Isso porque a Binance derruba conexões inativas a mais de 60 minutos, assim a gente precisa cuidar do reconnect da stream, que é o que estou fazendo aqui.
Agora falando da conexão à stream de user data da conta mestre, vamos trabalhar dentro da função start do index.js
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
const WebSocket = require("ws"); const oldOrders = {}; async function start() { const listenKey = await loadAccounts(); const ws = new WebSocket(`${process.env.BINANCE_WS_URL}/${listenKey}`); ws.onmessage = async (event) => { try { const trade = JSON.parse(event.data); if (trade.e === "executionReport" && !oldOrders[trade.i]) { oldOrders[trade.i] = true; console.clear(); console.log(trade); } } catch (err) { console.error(err); } } console.log("Waiting news..."); setInterval(() => { api.connectAccount(); }, 59 * 60 * 1000) } |
Aqui eu começo carregando o pacote ws para conexão via websockets. Também declaro um array de old orders, que usaremos para registrar ordens já processadas. Isso porque um mesmo trade pode gerar vários updates, mas somente o primeiro nos interessa e não queremos repetições acidentais.
Agora entrando na função de start, após obtermos uma listen key vamos usar ela para conexão na stream de user data, como mostrado. Essa conexão vai disparar um evento de onmessage a cada update recebido e é nesse evento que vamos converter a string recebida para um objeto JSON e com esse objeto vamos verificar o tipo de atualização recebida e se já não processamos esse trade (usando seu id como chave). Um evento do tipo ORDER_TRADE_UPDATE indica atualização de trade na conta e é o que queremos monitorar, entrando no if.
Então se o evento recebido é de atualização de trade, vamos registrar que já processamos o mesmo (precisa ser antes de tudo pois esses updates vem quase juntos) e, por enquanto, imprimimos no console (mais tarde vamos replicar o trade). Por fora de tudo isso um try/catch para o caso de termos erros.
Agora você já pode testar esse bot rodando-o a partir do index.js. O que ele vai fazer no momento é ficar monitorando e imprimindo no console as atualizações de trade na conta em questão. Recomendo agora que acesse a interface gráfica da Testnet Binance Futures e submeta alguns trades, para ver funcionando o copy trade bot.
Na segunda parte deste tutorial, você aprenderá como replicar os trades nas contas dos copy traders configurados.
Olá, tudo bem?
O que você achou deste conteúdo? Conte nos comentários.
Bom dia Luis
Gostei muito do vídeo e dos materiais onde vc ensina a fazer o Bot de Copy trader para a Binance.
Gostaria muito de utiliza-lo para replicar os meus trades para as contas da minha família, mas não tenho condições de construir ele, por isso pergunto: Vc não teria esse Bot pronto e testado para vender?
Obrigado
Infelizmente não desenvolvo para terceiros e nem vendo bots prontos, só ensino a programar mesmo.