Como calcular indicadores técnicos em robô trader com JavaScript (RSI)

Em outras oportunidades aqui no blog e também no meu canal do Youtube eu trouxe tutoriais de como criar robôs de criptomoedas, ou seja, automações via software para comprar e vender criptoativos em corretoras como Binance, Mercado Bitcoin e BityPreço. Em todas essas ocasiões eu trouxe como gatilho de compra e venda o preço do ativo no mercado à vista, afinal nada é mais importante (e óbvio para leigos) do que o preço do ativo, já que a estratégia mais bruta que existe é comprar barato e vender caro, certo?

No entanto estratégias mais elaboradas (e geralmente mais assertivas) não usam unicamente o preço como indicador de melhor momento de compra ou de venda. O mais comum é o uso dos chamados indicadores técnicos: métricas obtidas através de matemática sobre o comportamento passado daquele ativo. Existem centenas de indicadores mas a imensa maioria deles é obtido da seguinte forma:

pega-se uma amostra de velas (candles) do ativo;
aplica-se uma fórmula matemática sobre as velas (geralmente o preço de fechamento);
obtém-se o indicador atualizado para comparação;

E é justamente isso que quero mostrar como você pode fazer hoje. Se preferir, o vídeo abaixo contém o mesmo conteúdo do tutorial, caso prefira assistir ao invés de ler.

Vamos lá!

#1 – Setup do Projeto

Dentre os players mundiais de criptomoedas, uma das mais agressivas em termos de taxas e portfólio de moedas é a Binance, considerada a maior exchange de criptomoedas do mundo em volume de negociações. Usaremos ela como fonte de dados aqui pois é um bom termômetro do mercado de criptomoedas, mas o que vou mostrar pode ser usado com qualquer exchange (de cripto ou não) que disponibilize publicamente as suas velas. Nem mesmo você precisa ter conta na Binance para fazer este tutorial, pois ele não efetuará as compras e vendas de fato, ok?

Além disso, existem centenas de indicadores técnicos diferentes, como citei na introdução, então pegarei um como exemplo e depois eu posso trazer outros em oportunidades futuras ou você pega o que aprender aqui e adapta para outros indicadores, ok?

Dito isso, antes de sairmos programando precisamos configurar nosso projeto. Usarei aqui a linguagem JavaScript, então precisamos do Node.js instalado na máquina. Se ainda não tem o ambiente de desenvolvimento para Node.js configurado, você pode ver como fazer no vídeo abaixo.

Agora crie uma pasta no seu computador com o nome de binance-rsi e dentro dela rode o comando abaixo pelo seu terminal de linha de comando para inicializar um projeto Node.js na pasta.


npm init -y

npm init -y

Agora coloque um arquivo index.js vazio dentro da pasta e vamos instalar alguns pacotes via NPM pra deixar nosso projeto preparado. Seguem os comandos de instalação:


npm i dotenv axios

npm i dotenv axios

O módulo dotenv serve para carregar automaticamente variáveis de ambiente na sua aplicação Node.js. Usaremos estas variáveis de ambiente para colocar as configurações do nosso bot. Agora crie um arquivo “.env” na raiz do seu projeto colocando nele os valores abaixo, conforme instruções:

API_URL: o endereço base da URL de API da Binance que você vai utilizar, produção ou desenvolvimento;
SYMBOL: o par de moedas que seu robô vai monitorar e calcular indicadores. Ex: BTCUSDT (sempre em maiúsculas);
INTERVAL: o tempo gráfico das suas velas. Ex: 1h (para velas de 1h);
PERIOD: o período (quantidade de velas) que serão usadas no seu cálculo. Ex: 14;

Seu arquivo deve ficar mais ou menos assim:


API_URL=https://api.binance.com/api
SYMBOL=BTCUSDT
INTERVAL=1h
PERIOD=14

API_URL=https://api.binance.com/api

SYMBOL=BTCUSDT

INTERVAL=1h

PERIOD=14

Para carregar estas configurações na sua aplicação, modifique o seu package.json para que no script de start ele carregue o .env:


  "scripts": {
    "start": "node -r dotenv/config index"
  },

"scripts": {

"start": "node -r dotenv/config index"

Note que este robô de monitoramento de indicador irá funcionar com um par de moedas e um indicador, mas pode ser adaptado para vários pares ou pode replicar o projeto várias vezes na sua máquina.

#2 – Obtendo os dados das velas

Para a finalidade de monitoramento das velas/candles a Binance fornece uma API histórica, que é útil para pegar velas em quantidade, e um fluxo de streams que é útil para pegar somente a vela atual. É possível fazer uma abordagem que une o melhor dos dois mundos mas isso complicaria demais esse tutorial, então vou usar uma abordagem mais simplificada, apenas com a API.

Para consumir a API de velas históricas da Binance eu usarei o pacote Axios, que instalamos anteriormente. Se você nunca programou com Axios antes, ele é um cliente HTTP bem popular para JavaScript e o vídeo abaixo dá uma excelente introdução (não é obrigatório, mas ajuda).

Com o Axios importado em seu arquivo index.js (abaixo) e as variáveis do .env devidamente carregadas, você pode combiná-los para chamar a API de velas históricas e imprimir no console o resultado.


const axios = require("axios");

const API_URL = process.env.API_URL;
const SYMBOL = process.env.SYMBOL;
const INTERVAL = process.env.INTERVAL;
const PERIOD = parseInt(process.env.PERIOD);

async function getCandles(){
    const response = await axios.get(`${API_URL}/v3/klines?symbol=${SYMBOL}&interval=${INTERVAL}&limit=${PERIOD+1}`);
    const closes = response.data.map(k => parseFloat(k[4]));
    console.log(closes);
}

getCandles();

const axios = require("axios");

const API_URL = process.env.API_URL;

const SYMBOL = process.env.SYMBOL;

const INTERVAL = process.env.INTERVAL;

const PERIOD = parseInt(process.env.PERIOD);

async function getCandles(){

const response = await axios.get(`${API_URL}/v3/klines?symbol=${SYMBOL}&interval=${INTERVAL}&limit=${PERIOD+1}`);

const closes = response.data.map(k => parseFloat(k[4]));

console.log(closes);

}

getCandles();

Nesta amostra de código, após eu ter todas as variáveis necessárias, eu chamo uma função getCandles que faz a request com Axios para a rota klines da REST API da Binance. Essa API espera que a gente passe o symbol (par de moedas), o interval (tempo gráfico) e a quantidade de velas que queremos, sendo que precisamos de uma a mais que o período para conseguir calcular o indicador corretamente (explicarei porquê mais adiante). Isso retornará um array de velas que mapeamos para pegar somente o close de cada vela (valor de fechamento), pois é a única informação que precisamos.

Neste primeiro momento, apenas imprimimos os closes no terminal para que você consiga ver se esta primeira etapa funcionou. Experimente rodar o seu projeto com o comando npm start e terá os valores impressos no terminal.

#3 – Entendendo o Cálculo do Indicador

Agora que temos os dados que precisamos para a grande maioria dos indicadores técnicos, é hora de escolher um, estudarmos sua fórmula e implementarmos o seu cálculo em JavaScript. Para este tutorial eu escolhi trabalhar com RSI ou Relative Strength Index (Indicador de Força Relativa), um indicador muito popular entre traders. No entanto, o racional que vamos usar aqui é o mesmo para qualquer outro indicador.

Antes de escrever algoritmos para indicadores técnicos é sempre importante que você entenda a fórmula do mesmo. No caso do RSI, ela é facilmente encontrada na Internet e é expressa como:

Ou seja, primeiro calculamos os ganhos médios no período (average gains) e as perdas médias (average losses). Um ganho é quando uma vela fechou com um valor superior no preço em relação ao fechamento da vela anterior. Somam-se as diferenças de ganhos e guarda-se em uma variável, algo como abaixo. Repare que estou considerando o empate como ganho, mas na prática não influencia em nada. Repare também que preciso de um close a mais para ter com quem comparar para o primeiro cálculo de ganho (começa em 1 o for):


let gains = 0;

for (let i = 1; i < closes.length; i++) {
    const diff = closes[i] - closes[i - 1];
    if (diff >= 0)
        gains += diff;
}

let gains = 0;

for (let i = 1; i < closes.length; i++) {

const diff = closes[i] - closes[i - 1];

if (diff >= 0)

gains += diff;

}

Depois, fazemos o mesmo para as perdas. Uma perda é quando uma vela fechou com um valor inferior no preço em relação ao fechamento da vela anterior. Subtraem-se as diferenças e armazenamos esse número negativo em outra variável.


let gains = 0;
let losses = 0;

for (let i = 1; i < closes.length; i++) {
    const diff = closes[i] - closes[i - 1];
    if (diff >= 0)
        gains += diff;
    else
        losses -= diff;
}

let gains = 0;

let losses = 0;

for (let i = 1; i < closes.length; i++) {

const diff = closes[i] - closes[i - 1];

if (diff >= 0)

gains += diff;

else

losses -= diff;

}

Agora que temos os ganhos e as perdas médios, é hora de calcular a força relativa do período (relative strength ou RS), que a fórmula diz que é ganhos sobre perdas, ou…


const strength = gains / losses;

const strength = gains / losses;

Com a força calculada, é bem simples de aplicar o restante da fórmula onde subtraímos 100 da divisão de 100 por 1 + RS, como abaixo.


const rsi = 100 - (100 / (1 + strength));

const rsi = 100 - (100 / (1 + strength));

Isso vai nos dar o RSI para o período. Bora transformar em código?

#4 – Calculando o RSI em JS

Agora que entendemos como calcular a fórmula em JS, transpor o entendimento acima para uma função é muito simples, como abaixo.


function RSI(closes, period = 14) {
    if (closes.length < (period + 1)) throw new Error(`Invalid period for closes length`);

    let gains = 0;
    let losses = 0;

    for (let i = 1; i < closes.length; i++) {
        const diff = closes[i] - closes[i - 1];
        if (diff >= 0)
            gains += diff;
        else
            losses -= diff;
    }

    const strength = gains / losses;
    return 100 - (100 / (1 + strength));
}

function RSI(closes, period = 14) {

if (closes.length < (period + 1)) throw new Error(`Invalid period for closes length`);

let gains = 0;

let losses = 0;

for (let i = 1; i < closes.length; i++) {

const diff = closes[i] - closes[i - 1];

if (diff >= 0)

gains += diff;

else

losses -= diff;

}

const strength = gains / losses;

return 100 - (100 / (1 + strength));

}

Isso vai permitir que apenas informando os closes e o período para a função, que teremos o RSI calculado. Agora você pode voltar na função getCandles e adicionar a chamada ao cálculo do RSI, imprimindo o resultado.


async function getCandles() {
    const response = await axios.get(`${API_URL}/v3/klines?symbol=${SYMBOL}&interval=${INTERVAL}&limit=${PERIOD + 1}`);
    const closes = response.data.map(k => parseFloat(k[4]));
    const rsi = RSI(closes, PERIOD);
    console.log(rsi);
}

async function getCandles() {

const response = await axios.get(`${API_URL}/v3/klines?symbol=${SYMBOL}&interval=${INTERVAL}&limit=${PERIOD + 1}`);

const closes = response.data.map(k => parseFloat(k[4]));

const rsi = RSI(closes, PERIOD);

console.log(rsi);

}

Por fim, se quiser que esse comportamento se repita de tempos em tempos, basta criar um timer, como abaixo, onde exemplifiquei um intervalo de 3 segundos entre cada cálculo.


setInterval(getCandles, 3000);

setInterval(getCandles, 3000);

O resultado, você vê no seu terminal.

Para me certificar que estava comparando certo, eu abri um gráfico no Trading View com o mesmo ativo e tempo gráfico e os valores ficaram muito próximos, alguns décimos de diferença apenas, o que não influencia na análise do indicador, que geralmente é focada no valor inteiro.

Quer aprender a calcular outros dois indicadoes? Confira neste post.

Um abraço e até a próxima!