Como criar um diário de negociações com MetaTrader e Google Sheets

Índice

• Conceito
• Introdução
• Soluções disponíveis
• O que é uma planilha do Google
• API do Google Spreadsheets
• Criar uma nova Planilha Google
• Criar um Google Apps Script
• Executar a função de configuração
• Publicar o projeto como um aplicativo da web
• Como enviar (escrever) dados para o Google Spreadsheets
• Como ler e acessar o Google Spreadsheets via HTTP
• Implementar e atualizar ferramentas para o nosso Diário de Negociações usando o MetaTrader
• Criar um Expert Advisor para enviar dados
• Obter a lista de ordens e posições em execução
• Enviar os dados da lista de ordens para o Google Sheet
• Análise simples da nossa lista de negociações
• Conclusão

Conceito

Hoje, no mundo do trading, reduzir o erro e aumentar a taxa de acertos é muito importante. Todo trader precisa de um diário de negociações para melhorar o desempenho de sua estratégia. Mas esse trabalho exige muito tempo e precisão. Imagine se isso fosse feito automaticamente.

Introdução

O sistema de diário de negociações no Google Sheets serve como um recurso indispensável para traders de todos os níveis, facilitando o acompanhamento organizado de suas atividades de negociação. Manter um diário de negociações é essencial se você deseja progredir como day trader. Você não pode melhorar o que não mede. Ele permite que os usuários mantenham uma abordagem estruturada para suas operações, oferecendo insights cruciais para a avaliação e melhoria de desempenho. A acessibilidade e a facilidade de uso deste sistema são ampliadas pelos recursos colaborativos do Google Sheets, permitindo que traders compartilhem seus diários ou recebam feedback de colegas. Ao utilizar este sistema, os traders podem cultivar disciplina, acompanhar fatores psicológicos e, por fim, aumentar suas chances de sucesso nos mercados financeiros.

Neste artigo, projetamos uma plataforma personalizada para que os traders registrem e acompanhem suas negociações de forma sistemática. Ela inclui campos personalizáveis para refletir sobre estratégias e resultados, além de funções integradas para automatizar cálculos, reduzir erros e economizar tempo. 

Vamos mostrar como enviar dados personalizados automaticamente via protocolo HTTP POST para uma Planilha Google. Também veremos como lê-los ou recuperá-los por requisição HTTP no MetaTrader.

Soluções disponíveis

Para implementar um diário de negociações, precisamos transferir nossos dados de negociação para um banco de dados para análise futura. Por outro lado, precisamos acessar esse banco de dados, baixar as informações e utilizá-las. O banco de dados pode estar em diversos formatos, como um arquivo Excel, um arquivo CSV, um arquivo MySQL ou Microsoft SQL Server, um arquivo JSON ou até mesmo um simples arquivo de texto onde os dados desejados são armazenados linha por linha Dependendo do tipo do seu banco de dados, o design e o desenvolvimento do seu sistema serão diferentes.

Temos vários tipos de solução.

1. Google Sheets: Manter um diário de negociações pode ser simples usando o Google Sheets. É uma interface fácil de usar para monitorar métricas importantes como negociações, pontos de entrada e saída, lucros e perdas e anotações sobre as operações. Usando um diário de negociações público no Google Sheets, os traders podem organizar suas operações e coletar estatísticas para aprender com suas experiências. Além disso, o Google Sheets permite personalização, para que os traders possam adaptar o diário às suas estratégias específicas.
2. Diários de negociação com Python e API: Para traders que buscam uma solução mais sofisticada, automatizar seu diário de negociações usando Python e a API do Google Sheets pode agilizar significativamente a entrada e a análise de dados. Essa automação permite atualizações em tempo real e reduz o potencial de erro humano. Ao extrair dados das plataformas de negociação e preencher automaticamente a Planilha Google, os traders podem focar mais na análise do que na entrada manual de dados. Essa solução é particularmente eficaz para quem negocia com frequência e precisa de análises de desempenho precisas e oportunas.
3. Diários de negociação online: Diversos diários de negociação online combinam a facilidade de uso e a acessibilidade das aplicações web com recursos que permitem aos traders registrar suas operações sem precisar gerenciar uma planilha manualmente — mas exigem pagamento de assinatura. Essas plataformas geralmente vêm com ferramentas analíticas integradas que podem ajudar os traders a identificar padrões em seu comportamento de negociação, potencialmente levando a decisões mais informadas.

Escolhemos o Google Sheets como nosso banco de dados baseado em Excel por dois motivos principais: primeiro, é simples e fácil de entender. Segundo, o Google Sheets é, por natureza, um banco de dados online que pode ser acessado de qualquer lugar e em qualquer computador apenas com um link. Não há necessidade de configurar infraestrutura adicional para tornar os dados acessíveis online.

O que é uma planilha do Google

A planilha do Google é uma versão gratuita e baseada na web do Excel, fornecida pelo Google, que permite aos usuários criar, editar e gerenciar planilhas. Semelhante ao Microsoft Excel, ela possibilita organizar dados em células e tabelas e realizar operações matemáticas, estatísticas e analíticas, com centenas de tipos de barras e análises gráficas.

Principais recursos e benefícios de usar o Google Sheets:

• Os arquivos são salvos automaticamente no Google Drive, tornando-os acessíveis a partir de qualquer dispositivo com conexão à internet
• Vários usuários podem trabalhar no mesmo arquivo simultaneamente e visualizar instantaneamente as alterações uns dos outros.
• Não é necessário instalar software; basta um navegador e uma conta do Google.
• Os usuários podem importar e exportar dados em formatos como Excel, CSV e PDF.
• Suporta uma ampla variedade de funções para análise de dados, semelhantes às do Excel.
• O Google Sheets também suporta scripts, funções de automação e acesso por soluções via API.

O Google Sheets é excelente para colaboração online e para acessar ou compartilhar dados de qualquer lugar. Por isso, pode ser uma ótima solução para Diários de Negociação.

API do Google Spreadsheets

A API do Planilhas Google é uma interface RESTful que permite ler e modificar os dados de uma planilha. Os usos mais comuns desta API incluem as seguintes tarefas:

• Criar planilhas
• Ler e escrever valores de células de planilhas
• Atualizar a formatação da planilha
• Gerenciar Connected Sheets

O uso da API do Google Sheets requer etapas complexas e uma Conta de Desenvolvedor Google com taxa de US$ 300.

Mas não paramos por aí — fornecemos a você uma solução simples e gratuita. Vamos avançar passo a passo:

Criar uma nova Planilha Google

1. Para começar, abra o Google Sheets e crie uma nova planilha em branco. Se você ainda não tiver uma conta Google, será necessário criar uma para acessar este serviço. Essa planilha servirá como o local principal de armazenamento para todos os dados com os quais trabalharemos, permitindo enviar e recuperar informações para o nosso diário de negociações de forma integrada.
2. Depois que a planilha estiver aberta, você precisará configurar a primeira linha adicionando cabeçalhos que correspondam aos principais pontos de dados que usaremos. Na primeira linha, insira os seguintes cabeçalhos, um por coluna:

• ticket: Ticket — armazenará o identificador único de cada negociação.
• order: Ordem — esta coluna indicará se a negociação é de compra ou venda.
• symbol: Símbolo — registrará o instrumento de negociação, como pares de moedas EURUSD ou GBPJPY.
• openprice: Isso armazenará o preço pelo qual a negociação foi aberta..
• sl: Valor de stop loss definido para a negociação.
• tp: Valor de take profit definido para a negociação.
• close: Indica se a negociação foi encerrada ou não.
• lot: Tamanho do lote — volume da negociação.
• opentime: Horário exato de abertura da negociação.

note: Os nomes das colunas diferenciam maiúsculas e minúsculas no código do nosso projeto. Portanto, se quiser alterá-los para seu estilo, certifique-se de entender essa sensibilidade.

Criar um Google Apps Script

Para adicionar funcionalidade à sua planilha do Google, o próximo passo é criar um Google Apps Script. O Google Apps Script permite escrever código personalizado para automatizar tarefas e conectar serviços do Google, tornando-o perfeito para integrar sua planilha com plataformas externas.

Para isso:

• No Google Sheets, clique no menu “Extensões” na parte superior.
• No menu suspenso, selecione “Apps Script”. Essa ação abrirá uma nova guia, levando você à interface do Google Apps Script, onde poderá escrever e editar códigos para automatizar interações com sua planilha.
• Quando o editor do Apps Script abrir, você verá um editor de código em branco. É recomendável dar um nome significativo ao seu projeto para facilitar a identificação no futuro.
• Você pode nomeá-lo como “meu primeiro diário” ou “minha função de lista de negociações”, ou qualquer nome de sua preferência.
• Depois de abrir o editor do Google Apps Script e nomear o projeto, o próximo passo é modificar o script, removendo o código padrão que aparece. Por padrão, o Google Apps Script inclui um modelo de função simples chamado “myFunction”, que não será necessário para o nosso projeto.

Portanto, remova essa função padrão e, em seguida, copie e cole a função abaixo, substituindo-a pelo seu próprio script personalizado

// Original code from https://github.com/jamiewilson/form-to-google-sheets
const sheetName = 'Sheet1'
const scriptProp = PropertiesService.getScriptProperties();

function initialSetup() {  
const activeSpreadsheet = SpreadsheetApp.getActiveSpreadsheet();
scriptProp.setProperty('key', activeSpreadsheet.getId());
}

function doPost (e) {  
  const lock = LockService.getScriptLock();
  lock.tryLock(10000);
  
  try {    
    const doc = SpreadsheetApp.openById(scriptProp.getProperty('key'));    
    const sheet = doc.getSheetByName(sheetName);
    const headers = sheet.getRange(1, 1, 1, sheet.getLastColumn()).getValues()[0];
    const nextRow = sheet.getLastRow() + 1;
    const newRow = headers.map(function(header) {      
      return header === 'Date' ? newDate() : e.parameter[header];
    })
 
    sheet.getRange(nextRow, 1, 1, newRow.length).setValues([newRow]);

    return ContentService      
      .createTextOutput(JSON.stringify({ 'result': 'success', 'row': nextRow }))
      .setMimeType(ContentService.MimeType.JSON);
  }
  catch (e) {
    return ContentService
      .createTextOutput(JSON.stringify({ 'result': 'error', 'error': e }))
      .setMimeType(ContentService.MimeType.JSON);
  }
  finally {
    lock.releaseLock();
  }}

Agradecimentos a Jamie Wilson, pois usamos seu código (form-to-google-sheets) para o nosso projeto.

Agora, salve o projeto antes de passar para a próxima etapa. Arquivo > ícone Salvar

Essa função faz parte de um Google Apps Script que conecta um Formulário Google ou uma requisição externa HTTP POST a uma planilha do Google, permitindo armazenar dados dinamicamente na planilha.

Aqui está a descrição dos componentes da função:

sheetName: variável global que se refere à nova planilha criada anteriormente. O nome padrão da planilha é “sheet1”.

scriptProp: usado para armazenar propriedades específicas do script via PropertiesService no Google Apps Script, permitindo o armazenamento persistente de valores como o ID da planilha.

initialSetup: com essa função, recuperamos a planilha ativa no momento usando SpreadsheetApp.getActiveSpreadsheet() e armazenamos seu ID exclusivo nas propriedades do script usando scriptProp.setProperty('key', activeSpreadsheet.getId()). Isso permite que outras partes do script acessem a planilha pelo ID posteriormente.

doPost: é a função principal que processa as requisições HTTP POST recebidas, mapeando os dados recebidos para a planilha do Google. Primeiro, adquire um bloqueio para evitar problemas de gravação simultânea, depois recupera a planilha de destino pelo ID armazenado e identifica a aba correta. A função lê os cabeçalhos da primeira linha para mapear os dados recebidos para as colunas correspondentes, adiciona os dados na próxima linha disponível e trata o cabeçalho “Date” inserindo automaticamente a data atual. Ela retorna uma mensagem de sucesso em formato JSON se a operação for concluída ou uma mensagem de erro caso haja problemas, e, por fim, libera o bloqueio.

Executar a função de configuração

Como esse script não foi revisado pelo Google, ele exibirá um aviso antes que você possa continuar. Este é um procedimento padrão para scripts não verificados.

Para executar a função e configurar corretamente seu Google Apps Script:

1. Clique no ícone Executar, ao lado do ícone Salvar.
2. Uma janela modal aparecerá informando que “É necessária autorização”. Clique em “Revisar permissões” para prosseguir até a próxima tela, onde será necessário autorizar o script a acessar sua conta Google.
3. Selecione a conta Google que deseja usar com este script. Essa conta concederá as permissões necessárias.
4. Na tela seguinte, você poderá ver uma mensagem informando “O Google não verificou este aplicativo”. Esse é um aviso comum para scripts que não passaram pelo processo de verificação do Google. Para prosseguir, clique em “Avançado”.
5. Após clicar em Avançado, você verá a opção “Ir para Projeto sem título (não seguro)”. Essa mensagem indica que, embora o script não seja verificado, você ainda está permitindo que ele acesse sua conta Google. Clique neste link para continuar.
6. Por fim, será solicitado que você conceda permissões ao script. Revise as permissões solicitadas e clique em “Permitir” para autorizar o script a interagir com sua planilha do Google e outros serviços do Google.

Após conceder as permissões necessárias ao script, você verá um log de execução no console do editor de scripts indicando que o script foi autorizado a ser executado. Neste ponto, o script está pronto, mas para automatizar sua execução por meio de requisições HTTP POST, é necessário configurar um gatilho (trigger).

---

Para isso:

1. Na página do editor do Google Apps Script, na barra lateral esquerda, clique em “Gatilhos” para abrir a interface de gerenciamento de gatilhos. Essa seção permite configurar quando e como seu script deve ser executado.
2. Dentro da página de Gatilhos, clique no botão “Adicionar gatilho”. Esse botão normalmente é representado por um ícone de mais (+) ou identificado explicitamente como “Adicionar gatilho”.
3. Uma nova janela de diálogo aparecerá, onde você poderá configurar os detalhes do gatilho. Você precisa configurar o gatilho para ativar sua função (<b0>doPost</b0>) em resposta a uma requisição HTTP POST.
4. Para a origem do evento, selecione “Do aplicativo da Web” ou “Aplicativo da Web” (a opção pode variar conforme atualizações da interface do Google Apps Script).
5. Escolha a função que deseja disparar no menu suspenso. Neste caso, selecione doPost.
6. Escolha qual versão (deployment) deve ser executada: Head
7. Selecione a origem do evento: Da planilha
8. Defina o tipo de evento como “Ao enviar formulário”. Essa configuração permite que seu script seja executado em resposta a uma requisição HTTP POST enviada para a URL do aplicativo da Web.

Em seguida, clique em SALVAR. Se for solicitada permissão, aceite-a com sua conta Google.

Publicar o projeto como um aplicativo da web

Agora precisamos publicar o projeto: clique no botão azul “Implantar” na página do App e selecione “Nova implantação” no menu suspenso.

Depois, clique no ícone “Selecionar tipo” e escolha “Aplicativo da Web”.

No formulário que aparecer, selecione as seguintes opções:

• Descrição: Isso pode ser qualquer coisa que você quiser. Apenas torne-o descritivo.
• Aplicativo da Web → Executar como: Eu
• Aplicativo da Web → Quem tem acesso: Qualquer pessoa

Em seguida, clique em Implantar.

Importante: Na página seguinte, copie a URL do aplicativo da Web — usaremos esse link no nosso projeto. Seu link será algo assim:

Link do projeto: https://script.google.com/macros/s/AfycbxWxYnDPsdvsvsdvdv236545OfgVnadvkvsASDCV6541scsSDHNfnqPeVkyH5A-r5eDhg/exec

Como enviar (escrever) dados para o Google Spreadsheets

HTTP POST é um método usado pelo protocolo HTTP para enviar dados do cliente para o servidor. Ele é geralmente utilizado no envio de dados de formulários em sites. Você o verá com frequência na web, exatamente como no formulário de login do site MQL.

Os dados são transmitidos no corpo da requisição, diferentemente do método GET, em que os dados são passados na URL. Ao usar o método POST, os dados não ficam visíveis na URL, o que proporciona um pouco mais de segurança, e o tamanho dos dados enviados não é limitado, permitindo o envio de arquivos ou grandes quantidades de informações.

Apenas para testar a função do nosso script, criaremos um simples formulário HTML para coletar dados de teste e enviá-los ao servidor para processamento. O método de envio do formulário deve ser POST.

O formulário HTML básico abaixo contém:

Action: deve ser definido com o Link do projeto (obtido nas etapas anteriores de publicação).

Method: é o método de envio do formulário, podendo ser GET ou POST.

Como escrevemos nosso App Script no Google Sheet com o método POST, usaremos POST para enviar dados ao Google.

input: inclui todos os tipos de dados que queremos enviar.

Este é o nosso formulário HTML final:

<!DOCTYPE html>
<htmllang="en">
<head>
<metacharset="UTF-8">
</head>
<body>
<form method="post" action="https://script.google.com/macros/s/AfycbxWxYnDPsdvsvsdvdv236545OfgVnadvkvsASDCV6541scsSDHNfnqPeVkyH5A-r5eDhg/exec">
<input type="number" size="20" name="ticket" placeholder="ticket">
<input type="text" size="20" name="order" placeholder="order">
<input type="text" size="20" name="symbol" placeholder="symbol"><br>
<input type="number" step="0.00001" size="20" name="openprice" placeholder="openprice">
<input type="number" step="0.00001" size="20" name="sl" placeholder="stoploss">
<input type="number" step="0.00001" size="20" name="tp" placeholder="takeprofit"><br>
<input type="number" step="0.00001" size="20" name="close" placeholder="close price">
        <input type="number" step="0.01" size="20" name="lot" placeholder="volume">
        <input type="datetime-local" size="20" name="opentime" placeholder="opentime">
<input type="submit" value="post">
</form>
</body>
</html>

Copie e cole este texto em um arquivo de texto local e renomeie o formato do arquivo para um arquivo HTML. Como este “newfile.html”

Substitua o endereço da ação do formulário pelo link do projeto da sua planilha.

Agora, conseguimos facilmente enviar os dados desejados para uma planilha do Google.

Preencha os campos do formulário, clique em enviar (POST) e aguarde a atualização da sua planilha do Google.

Se você conseguiu concluir esta etapa, podemos seguir para a próxima; caso contrário, releia as etapas acima com atenção. Se você conseguiu concluir esta etapa, podemos seguir para a próxima; caso contrário, releia as etapas acima com atenção.

O formulário usado acima é apenas para testar o envio de dados via HTML POST. No restante deste artigo, enviaremos automaticamente os dados das transações usando a função WebRequest do MetaTrader.

Como ler e acessar o Google Spreadsheets via HTTP

Para ler dados de uma planilha usando o método HTTP, você precisa configurar permissão de leitura na sua planilha.

Abra a planilha do Google criada anteriormente.

Na página da planilha, no canto superior direito, clique em “Compartilhar” e defina o acesso geral como “Qualquer pessoa com o link” e a função como “Leitor”.

Em seguida, clique em “Copiar link” para utilizá-lo como link de acesso à planilha. O link de acesso será assim:

https://docs.google.com/spreadsheets/d/1rYNuscaYWtRu_65W-fPnascNTYHwcU-3fWiNQ4asTBHQo/edit

O texto em negrito é o seu ID da planilha.

Precisamos desse ID para ler a planilha no formato JSON.

Link de acesso: https://docs.google.com/spreadsheets/d/{YOUR_SHEET_ID}/gviz/tq?tqx=out:json&tq&gid='+gid

{YOUR_SHEET_ID} é o identificador da sua planilha, que pode ser encontrado na URL da planilha.

Copie o ID da URL e substitua {YOUR_SHEET_ID} no link de acesso. O link ficará assim:

https://docs.google.com/spreadsheets/d/1rYNuscaYWtRu_65W-fPnascNTYHwcU-3fWiNQ4asTBHQo/gviz/tq?tqx=out:json&tq&gid='+gid

Ao usar este link no navegador, será baixado um arquivo JSON com todos os detalhes da sua planilha.

O resultado será assim:

google.visualization.Query.setResponse(
{
    "version": "0.6",
    "reqId": "0",
    "status": "ok",
    "sig": "529900317",
    "table":
    {
        "cols": [
        {
            "id": "A",
            "label": "ticket",
            "type": "number",
            "pattern": "General"
        },
        {
            "id": "B",
            "label": "order",
            "type": "string"
        },
        {
            "id": "C",
            "label": "symbol",
            "type": "string"
        },
        {
            "id": "D",
            "label": "openprice",
            "type": "number",
            "pattern": "General"
        }],
        "rows": [
        {
            "c": [
            {
                "v": 5.64123564E8,
                "f": "564123564"
            },
            {
                "v": "buy"
            },
            {
                "v": "EURUSD"
            },
            {
                "v": 1.2215,
                "f": "1.2215"
            },
            {
                "v": 1.21,
                "f": "1.21"
            },
            {
                "v": 1.23,
                "f": "1.23"
            },
            {
                "v": 0.0,
                "f": "0"
            },
            {
                "v": 0.01,
                "f": "0.01"
            },
            {
                "v": "Date(2024,8,11,18,27,0)",
                "f": "2024-09-11 18:27"
            }, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            {
                "v": null
            }]
        },
        {
            "c": [
            {
                "v": 123123.0,
                "f": "123123"
            },
            {
                "v": "sell"
            },
            {
                "v": "USDJPY"
            },
            {
                "v": 147.22,
                "f": "147.22"
            },
            {
                "v": 147.44,
                "f": "147.44"
            },
            {
                "v": 146.0,
                "f": "146"
            },
            {
                "v": 0.0,
                "f": "0"
            },
            {
                "v": 0.02,
                "f": "0.02"
            },
            {
                "v": "Date(2024,8,4,20,43,0)",
                "f": "2024-09-04 20:43"
            }, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            {
                "v": null
            }]
        }],
        "parsedNumHeaders": 1
    }
});

Ele contém todos os nomes de colunas, números e valores. Todos os dados acima são apenas para 2 linhas de detalhes de posição.

Usamos esse arquivo JSON para ler a planilha no nosso Expert Advisor.

Vamos para a parte mais interessante da história: a implementação automática de tudo o que vimos na plataforma MetaTrader.

Implementar e atualizar ferramentas para o nosso Diário de Negociações usando o MetaTrader

Para implementar um Diário de Negociações no Google Sheets usando o MetaTrader, o processo envolve etapas principais.

Primeiro, precisamos criar uma planilha no Google Sheets para salvar e gerenciar os detalhes de negociação, incluindo detalhes de posição ou comentários da posição. Já fizemos isso.

Em seguida, usamos o Google Apps Script para permitir que a planilha interaja com sistemas externos via requisições HTTP. Isso também já fizemos.

Agora, no MetaTrader, escreveremos um Expert Advisor personalizado que envie dados de negociações (como símbolo, volume e tipo de ordem) para o Google Sheets usando a função WebRequest e o protocolo HTTP POST. A planilha atua como um banco de dados em nuvem, permitindo monitorar, armazenar e compartilhar negociações em tempo real em diferentes contas e locais.

Criar um Expert Advisor para enviar dados

Precisamos de um Expert Advisor para enviar detalhes de posições e ordens para o Google Sheets.

Portanto, precisamos de duas partes principais no nosso código:

1. Uma função com a tarefa de verificar as posições abertas e ordens pendentes em uma conta no MetaTrader. Chamaremos essa função de “OrderList”.
2. Uma função com a tarefa de enviar os dados da “OrderList” para o Google Sheets via função WebRequest. Chamaremos essa função de “UpdateDatabase.”

Obter a lista de ordens e posições em execução

Nossa função “OrderList” pode ter a seguinte estrutura:

void OrderList {
   for(int conter = PositionsTotal() - 1; conter >= 0; conter -= 1)
   {
      const ulong ticket = PositionGetTicket(conter);
      if(ticket == 0 || !PositionSelectByTicket(ticket)) continue;
      string   symbol      =  PositionGetString(POSITION_SYMBOL);
      int      order_type  =  PositionGetInteger(POSITION_TYPE);
      double   volume      =  PositionGetDouble(POSITION_VOLUME);
      double   open_price  =  PositionGetDouble(POSITION_PRICE_OPEN);
      datetime open_time   =  PositionGetInteger(POSITION_TIME);
      double   stop_loss   =  PositionGetDouble(POSITION_SL);
      double   take_profit =  PositionGetDouble(POSITION_TP);      
      // Send trade details via WebRequest
      UpdateDatabase(symbol, order_type, volume, open_price, stop_loss, take_profit, ticket, open_time);
   }
} 

E para MQL4, o código poderia ser assim:

void OrderList {
   // Loop through all open trades
   for(int conter = OrdersTotal() - 1; conter >= 0; conter -= 1) {
      if(OrderSelect(conter, SELECT_BY_POS, MODE_TRADES)) {
         // Collect trade data
         int      ticket      =  OrderTicket();
         string   symbol      =  OrderSymbol();
         int      order_type  =  OrderType();
         double   volume      =  OrderLots();
         double   open_price  =  OrderOpenPrice();
         datetime open_time   =  OrderOpenTime();
         double   stop_loss   =  OrderStopLoss();
         double   take_profit =  OrderTakeProfit();
         // Send trade details via WebRequest
         UpdateDatabase(symbol, order_type, volume, open_price, stop_loss, take_profit, ticket, opentime);
      }
   }
}

O código dessa função contém um loop que começa do 0 até o número total de ordens abertas com OrdersTotal() ou PositionsTotal().

A cada iteração, seleciona uma posição ou ordem da lista de ordens do MetaTrader usando a função OrderSelect.

Depois, lemos as informações desejadas usando PositionGetString, PositionGetDouble e PositionGetInteger.

Todos os detalhes necessários para outros dados podem ser encontrados aqui para Funções de Negociação MQL4 e Funções de Negociação MQL5.

Enviar os dados da lista de ordens para o Google Sheet

Depois de obter todos os detalhes das ordens com a função “OrderList”, agora precisamos de outra função chamada “UpdateDatabase” para postar os dados no Google Sheets.

Detalhes da posição como símbolo, tipo de ordem, volume, preço de abertura, stop loss, take profit e número do ticket são recebidos como parâmetros e formatados em uma string. Esses dados são enviados por uma requisição HTTP POST via função WebRequest(). Se a requisição for bem-sucedida, confirma-se que os dados foram enviados; caso contrário, uma mensagem de erro é impressa.

void SendTradeData(string orderSymbol, int orderType, double orderVolume, double openPrice, double stopLoss, double takeProfit, ulong orderTicket, datetime openTime)
{ 
   // Database url. Replace with your own url
   string url  = "https://script.google.com/macros/s/AfycbxWxYnDPsdvsvsdvdv236545OfgVnadvkvsASDCV6541scsSDHNfnqPeVkyH5A-r5eDhg/exec";
   int   digit = (int)SymbolInfoInteger(orderSymbol,SYMBOL_DIGITS);
   string datastring = "?
                  +"&ticket="+string(orderTicket)
                  +"&order="+string(orderType)
                  +"&symbol="+string(orderSymbol)
  +"&openprice="+DoubleToString(openPrice,digit)
                  +"&sl="+DoubleToString(stopLoss,digit)
                  +"&tp="+DoubleToString(takeProfit,digit)
                  +"&close=0"
  +"&lot="+DoubleToString(orderVolume,2)
  +"&opentime="+(string)openTime;   

   int   res;     // To receive the operation execution result
   char  data[];  // Data array to send POST requests  
   char  result[];
   //--- Create the body of the POST request for authorization
   ArrayResize(data,StringToCharArray(datastring,data,0,WHOLE_ARRAY,CP_UTF8)-1);
   ResetLastError();
   res=WebRequest("POST", url, NULL, 0, data, result, str);
   string responsestring   = CharArrayToString(result, 0, 0, CP_UTF8);
   Print(responsestring);
   if(res == -1)
      Print("Error in WebRequest: ", GetLastError());
   else
      Print("Trade data sent: ", data);
}

Nessa função, obtemos os dados da função “OrderList” e os preparamos para o método POST.

A URL é a URL pública da nossa planilha.

Então, criamos uma variável string “datastring” no formato GET method.

Com a função StringToCharArray, armazenamos a string em um array chamado data.

A função WebRequest é então iniciada na linha seguinte com o método POST, “url”, o array “data” e a resposta armazenada na variável “result”.

Depois, convertemos o array de resposta em uma string “responsestring” para imprimir nos logs da aba Expert do MetaTrader.

Análise simples da nossa lista de negociações

Sempre que abrir uma ordem, sua planilha será atualizada, e você poderá analisar todos os dados com gráficos analíticos do Google Sheets.

Calcule o total de posições de compra, total de vendas, total de lotes, total de posições vencedoras ou perdedoras, média de ganhos, média de perdas ou qualquer outro indicador que imaginar.

Criamos um modelo para o seu diário, e você pode acessá-lo por este link. Verifique as fórmulas das colunas para entender como calculamos e analisamos os dados brutos da lista de posições.

https://docs.google.com/spreadsheets/d/1rYcRJKzVWtRu_65W-fPnQgODSzTU-3fWiNQHZz3P2Qo/edit?usp=sharing

Conclusão

Neste artigo, percorremos o processo de criação de um diário de negociações usando o Google Sheets, integrado ao MetaTrader para rastreamento automático de dados. Cobrimos a configuração da planilha, a adição de cabeçalhos e o uso do Google Apps Script para enviar dados via HTTP POST. Esse sistema economiza tempo e reduz erros, facilitando o acompanhamento das negociações em tempo real.

Também aprendemos a criar um Expert Advisor no MetaTrader para enviar detalhes das negociações diretamente para o Google Sheets, permitindo análise em tempo real. Com essa configuração simples, agora você tem uma forma eficiente de organizar e melhorar seu desempenho de negociação sem precisar de ferramentas complexas.

Preparamos para você os códigos necessários para as versões MetaTrader 4 e 5.

Se tiver dúvidas ou ideias, não hesite em deixar um comentário.