Integração de APIs de Corretoras com Expert Advisors usando MQL5 e Python

Introdução

Hoje, exploraremos como estabelecer uma conexão perfeita entre nossos Expert Advisors do MetaTrader 5 e corretoras externas usando integração via API. O objetivo principal é resolver o desafio de fundos insuficientes nas contas de negociação, permitindo recargas automatizadas quando os saldos caírem abaixo de um limite definido. Essa abordagem trata de forma eficaz questões críticas de gerenciamento de fundos, aumentando tanto a eficiência quanto a segurança das operações de negociação.

Normalmente, seguimos a rotina de fazer login no portal da conta da corretora para executar várias transações e operações. Embora essa seja a abordagem tradicional, existe um recurso poderoso chamado API (Application Programming Interface) que nos permite fazer muito mais e otimizar nossa abordagem. Para alguns de vocês, este pode ser um termo familiar. No entanto, para outros, irei dividi-lo em seções fáceis de entender para garantir que todos estejam na mesma página:

1. O que é uma API?
2. Uso de APIs
3. Acessando APIs
4. Documentação da API

Vamos explorar esses tópicos em detalhes:

1. O que é uma API?

Uma API (Application Programming Interface) permite interações externas com um sistema de software. Nesse contexto, ela nos fornece a capacidade de realizar operações em nossas contas de corretoras diretamente no servidor — sem a necessidade de login manual.

Curiosamente, as APIs existem desde a década de 1940, mas ganharam força na década de 1970, alcançando ampla adoção após o ano 2000.

2. Uso de APIs

As APIs facilitam a comunicação entre aplicações e sistemas de software. Aqui estão algumas das áreas comuns de aplicação:

• Servidores de sites
• Aplicativos móveis

As APIs permitem acesso contínuo a dados de diversas fontes, tais como:

• Plataformas de redes sociais
• Armazenamento em nuvem
• Gateways de pagamento
• Estações meteorológicas
• Ações e mercados financeiros

API como uma ponte entre computadores externos e servidores em nuvem.

3. Acessando APIs

Para usar uma API, geralmente é necessário:

• Obter uma chave de API junto ao provedor.
• Estudar a documentação da API para integrá-la corretamente.
• Incluir a chave de API como um parâmetro em suas requisições para autenticação e autorização.

A chave de API é essencial para identificar sua aplicação ou usuário, garantindo ao mesmo tempo o acesso seguro.

4. Documentação da API

Cada API vem acompanhada de seu próprio guia do usuário e especificações. Esses materiais detalham como interagir com a API de forma eficaz. Por exemplo, a documentação da API do Telegram difere significativamente da de uma API de corretora, como a API da Corretora Deriv.

Ao compreender e utilizar APIs, podemos simplificar nossas operações, automatizar processos e aumentar a eficiência no gerenciamento de nossas contas de corretoras. Vamos nos aprofundar em cada aspecto e explorar sua implementação prática.

Aqui está uma lista das principais seções da nossa discussão:

• Visão geral desta discussão
• API da Deriv
• Biblioteca Python para comunicação via API WebSocket
• Script Python para intermediar a comunicação entre o MetaTrader 5 e a API da corretora
• Gestor de Fundos EA
• Testes de demonstração e resultados
• Conclusão

Visão geral desta discussão

Neste artigo, exploraremos o uso do MQL5 com a API de uma corretora para facilitar operações contínuas no gerenciamento de fundos. Nosso objetivo é revelar o vasto potencial que os Expert Advisors (EAs) em MQL5 oferecem. Como o MQL5 por si só não pode interagir diretamente com servidores web, utilizaremos bibliotecas externas de linguagem, como Python ou Node.js, dependendo das capacidades da API da corretora. Para esta discussão, focaremos na Deriv.com como nossa corretora escolhida.

Benefícios desta abordagem

• Transferências automatizadas de fundos: O EA automatizará a transferência de ganhos de negociação da conta de trading para uma conta segura.
• Recarga da conta de negociação: Ele irá reabastecer o saldo da conta de negociação caso o patrimônio caia abaixo de um limite predefinido.
• Operações contínuas: Ao hospedar o EA em um servidor virtual, o sistema pode operar 24/7 com capacidades praticamente ilimitadas de gerenciamento de fundos.

Desafios e Considerações

• Risco de esgotamento dos fundos: Os fundos reservados podem se esgotar caso o EA continue recarregando a conta sem gerar lucros consistentes.
• Necessidade de um gerenciamento robusto de fundos: Um sistema sofisticado de gerenciamento deve ser implementado para interromper as operações caso determinados limites de perda ou patrimônio sejam excedidos.

Nas próximas seções, examinaremos os recursos da API da corretora Deriv, desenvolveremos código Python para permitir interação contínua com a API e integraremos essa solução a um EA em MQL5 projetado para um gerenciamento de fundos eficiente e confiável, tudo apresentado em instruções simples, passo a passo, para fácil compreensão e implementação.

Fluxo bidirecional entre MQL5 e Broker

API da Deriv

Deriv.com é uma corretora popular que oferece suporte ao MetaTrader 5 e disponibiliza acesso via API para operações automatizadas. Informações detalhadas podem ser encontradas na documentação da API da Deriv. Para começar, siga os passos descritos no site para se inscrever e obter acesso à API.

Para fins educacionais, você precisará criar uma aplicação no painel da API da Deriv. Durante esse processo, selecione uma conta Demo e gere um token de API com o nível de acesso apropriado. Para esta apresentação, recomendo escolher o nível de acesso Trade API, pois ele permite operações como adicionar fundos à sua conta demo. Evite selecionar o nível Admin Access, a menos que tenha certeza de que pode gerenciá-lo com segurança, já que esse nível concede controle total sobre sua conta. Mantenha sempre seu token de API privado e seguro para evitar acessos não autorizados.

Após a criação do token de API, os próximos passos envolvem configurar um cliente Python WebSocket e integrá-lo ao MQL5 para desenvolver um programa capaz de gerenciar operações da conta.

Operações-chave

As principais funções que buscamos alcançar com nosso programa são:

• Depositar fundos da sua conta Deriv na sua conta Deriv MetaTrader 5.
• Interagir com a API da Deriv para um gerenciamento de fundos contínuo.

A documentação da API da Deriv fornece instruções detalhadas para realizar essas operações na seção MT5 APIs. Como parte desse processo, você obterá dois valores essenciais:

• ID da Aplicação (App ID): Identifica sua aplicação na plataforma Deriv.
• Token de API: Concede acesso para realizar as ações especificadas.

Com esses valores, podemos seguir para o desenvolvimento do cliente Python WebSocket e sua integração ao MQL5 para implementar nosso sistema de gerenciamento de fundos.

Você e a segurança da sua API

Segurança é um tópico fundamental que não pode ser ignorado. Assim como você protege seu celular contra acessos não autorizados, é igualmente essencial proteger suas chaves de API de outras pessoas. Um token de API funciona como uma porta de entrada para sua conta, e se cair nas mãos de criminosos virtuais, você pode ficar vulnerável a atividades maliciosas. Eles podem explorar sua conta e executar ações sem o seu conhecimento.

No contexto da Deriv, a plataforma oferece níveis de acesso a tokens de API, permitindo que você escolha as permissões concedidas ao token. É altamente recomendado usar os recursos de acesso demo e evitar selecionar Admin Access, a menos que seja absolutamente necessário. O nível Admin Access concede controle total sobre sua conta, representando um risco significativo caso caia em mãos erradas.

Esse conselho não se limita à Deriv; aplica-se a tokens de API de qualquer serviço. Trate sempre as chaves de API como senhas — mantenha-as privadas, armazene-as com segurança e nunca as compartilhe com pessoas que você não confia. Ao fazer isso, você minimiza o risco de acessos não autorizados e mantém sua conta protegida.

Biblioteca Python para comunicação via API WebSocket

Primeiro, precisamos ter o Python instalado em nosso computador para prosseguir com este projeto. Em seguida, precisamos instalar a biblioteca Python WebSocket para permitir a comunicação web com a API da corretora. A API da Deriv usa WebSocket para comunicação de alta velocidade, portanto, é essencial configurar nossos computadores adequadamente. Abaixo está o comando para instalar a biblioteca Python no Windows usando o Prompt de Comando.

pip install websocket-client

 Para instalar a biblioteca, abra o Prompt de Comando no Windows e insira o comando acima. Assim que a instalação estiver concluída, você estará pronto para começar a executar e testar. No entanto, antes de prosseguir, daremos os próximos passos para desenvolver o script Python que fará a comunicação entre o MetaTrader 5 e a API da corretora (a API da Deriv como exemplo).

Script Python para intermediar a comunicação entre o MetaTrader 5 e a API da corretora

Apresentei os passos para o desenvolvimento do script Python. Vamos avançar para a construção desse programa antes de criarmos nosso EA Gerenciador de Fundos. Abra seu editor de código (Notepad++ é o preferido) e crie um novo arquivo. Acompanhe enquanto desenvolvemos o script, que chamaremos de deriv_api_handler.py. Certifique-se de anotar o local onde seu script está salvo, pois ele será necessário posteriormente no código do EA.

1. Configuração e instalação iniciais

 Primeiramente, queremos estabelecer as importações necessárias, configurar as definições de conexão e definir os caminhos dos arquivos onde ocorrerá a comunicação com o MQL5. Começamos importando as bibliotecas essenciais. Sabemos que a biblioteca json é crucial para analisar e gerar dados JSON, que é o formato utilizado para enviar mensagens através de WebSocket e processar comandos. A biblioteca websocket é escolhida para lidar com a conexão WebSocket com a API da Deriv, e time ajuda o programa a introduzir pausas no script quando necessário. Por fim, os permite que ele interaja com o sistema de arquivos, como verificar arquivos de comando.

import json
import websocket
import time
import os

# Configuration
API_URL = "wss://ws.binaryws.com/websockets/v3?app_id= Your app ID"   #Replace with your App ID created in Deriv API dashboard
API_TOKEN = "Your API token"   #Replace with your actual token

# File paths (Replace YourComputerName with the actual name of your computer)
MQL5_TO_PYTHON = "C:/Users/YourComputerName/AppData/Roaming/MetaQuotes/Terminal/Common/Files/mql5_to_python.txt"
PYTHON_TO_MQL5 = "C:/Users/YourComputerName/AppData/Roaming/MetaQuotes/Terminal/Common/Files/python_to_mql5.txt"

• Em seguida, definimos nossa URL da API e o token, pois estes são as chaves necessárias para autorizar nossa conexão WebSocket com o servidor da Deriv. Essa URL aponta para o endpoint WebSocket, e o token de API é o que comprova nossa identidade perante o servidor.

• Por fim, especificamos os caminhos de arquivos para interação com o MQL5. Esses arquivos atuarão como a ponte entre nosso script Python e o MQL5, permitindo a troca de comandos e respostas. Devemos ter cuidado ao escolher caminhos que sabemos que são acessíveis para ambos os sistemas (MQL5 e Python).

2. Conexão WebSocket

Nesta seção do código do script, estabelecemos uma conexão segura com a API WebSocket da Deriv e autorizamos o script a fazer requisições.

def connect_to_deriv():
    """Connects to Deriv's WebSocket API."""
    try:
        ws.connect(API_URL)
        ws.send(json.dumps({"authorize": API_TOKEN}))
        response = json.loads(ws.recv())
        print(f"Authorization Response: {response}")
        if response.get("error"):
            print("Authorization failed:", response["error"]["message"])
            return False
        return True
    except Exception as e:
        print(f"Error during authorization: {e}")
        return False

• Definimos uma função para gerenciar a conexão WebSocket. Primeiro, tentamos conectar à API usando a URL configurada anteriormente. Iniciamos a conexão com ws.connect(API_URL) e então enviamos a mensagem de autorização contendo nosso token de API. Isso é necessário para autenticar nosso script junto ao servidor da Deriv.

• Imediatamente, o script aguarda uma resposta do servidor. O servidor retornará um objeto JSON que confirma se a conexão foi bem-sucedida. Se houver um erro, saberemos que o token era inválido ou que ocorreu algum outro problema. Esse tratamento de erros é essencial para garantir que o script falhe de forma adequada.

• Nossa decisão de usar blocos try-except garante que o script não pare caso algo dê errado na conexão ou na troca de mensagens. É uma medida de segurança que dá ao programa flexibilidade para depurar e lidar com problemas sem interromper todo o processo.

3. Processamento de Comandos

Nesta etapa, o programa interpreta os comandos recebidos e toma as ações apropriadas com base no tipo de comando. Após conectado e autenticado com sucesso, o script processará comandos enviados pelo MQL5 no formato de string JSON, ficando assim pronto para analisá-los e tratá-los.

• Na função process_command, o script tenta primeiro converter o comando em um dicionário Python. Isso permite acessar facilmente os diferentes campos do comando (como o valor do depósito). Em seguida, ele verifica por chaves específicas no JSON analisado (como "mt5_deposit"), que indicam qual ação o MQL5 está solicitando.

• Se o comando solicitar um depósito ("mt5_deposit"), uma função separada mt5_deposit será chamada para lidar com isso. Essa abordagem modular torna o script flexível e fácil de manter, pois podemos adicionar novos tipos de comandos no futuro sem dificuldade.

• Se o comando for desconhecido ou estiver formatado incorretamente, ele retorna uma mensagem de erro, o que ajuda o sistema MQL5 a entender o que deu errado.

def process_command(command):
    """Processes a command from MQL5."""
    try:
        command_data = json.loads(command)  # Parse the JSON command
        if "mt5_deposit" in command_data:
            return mt5_deposit(
                command_data["amount"],
                command_data["from_binary"],
                command_data["to_mt5"]
            )
        else:
            return {"error": "Unknown command"}
    except json.JSONDecodeError:
        return {"error": "Invalid command format"}
    except Exception as e:
        return {"error": f"Unexpected error: {e}"}

4. Operação de Depósito

Esta seção realiza a operação de depósito solicitada pelo MQL5, enviando os dados necessários para a API da Deriv. Criamos uma função dedicada (mt5_deposit) para executar o depósito. Isso mantém nosso código organizado e isola a lógica de tratamento da operação, facilitando a manutenção ou expansão futura.

• Dentro dessa função, uma mensagem JSON que instrui a Deriv a executar o depósito é estruturada. Essa mensagem inclui todos os detalhes necessários, como o valor, a conta de origem e a conta MT5 de destino. Enviar os dados corretos no formato adequado é essencial para garantir que a transação seja processada com sucesso.

• Após enviar a solicitação de depósito, o script aguarda uma resposta do servidor. Assim que a resposta é recebida, ela é convertida em JSON e retornada. Isso permite que o sistema MQL5 saiba se a operação foi concluída com sucesso ou se falhou.

• Exceções são tratadas caso algo dê errado na comunicação ou na execução da operação de depósito, garantindo que erros sejam capturados e informados ao MQL5.

def mt5_deposit(amount, from_binary, to_mt5):
    """Performs a deposit operation to the MT5 account."""
    try:
        ws.send(json.dumps({
            "mt5_deposit": 1,
            "amount": amount,
            "from_binary": from_binary,
            "to_mt5": to_mt5
        }))
        response = ws.recv()
        return json.loads(response)
    except Exception as e:
        return {"error": f"Error during deposit operation: {e}"}

5. Lendo comandos do MQL5

Esta é a seção do código onde um comando vindo do MQL5 é verificado e processado, caso esteja disponível, garantindo que o mesmo comando não seja processado repetidamente. Para ler comandos do MQL5, o script verifica se o arquivo mql5_to_python.txt existe. É nesse arquivo que o MQL5 grava os comandos que precisam ser processados. Se o arquivo existir, seu conteúdo será lido. Ao remover espaços desnecessários e verificar a presença de um BOM (Byte Order Mark), garantimos que os dados sejam tratados corretamente, independentemente de inconsistências de formatação.

• Quando o comando é lido, ele é exibido para fins de depuração, permitindo confirmar que o conteúdo foi recuperado como esperado. Após a leitura, o arquivo é apagado, garantindo que o mesmo comando não seja processado novamente no futuro.
• Se o arquivo não existir, a função retorna None, indicando que não há comando a ser processado. Se o arquivo não existir, a função retorna None, indicando que não há comando a ser processado.

def read_command():
    """Reads a command from the MQL5 file and deletes the file after reading."""
    print(f"Checking for command file at: {MQL5_TO_PYTHON}")
    if os.path.exists(MQL5_TO_PYTHON):
        print(f"Command file found: {MQL5_TO_PYTHON}")
        with open(MQL5_TO_PYTHON, "r", encoding="utf-8") as file:
            command = file.read().strip()
        print(f"Raw Command read: {repr(command)}")
        
        # Strip potential BOM and whitespace
        if command.startswith("\ufeff"):
            command = command[1:]
        
        print(f"Processed Command: {repr(command)}")
        os.remove(MQL5_TO_PYTHON)  # Remove file after reading
        return command
    print(f"Command file not found at: {MQL5_TO_PYTHON}")
    return None

6. Escrevendo respostas para MQL5

Esta parte envia a resposta de volta ao MQL5, permitindo que ele tome ações adicionais com base no resultado.Esta parte envia a resposta de volta ao MQL5, permitindo que ele tome ações adicionais com base no resultado. Isso é feito escrevendo a resposta no arquivo python_to_mql5.txt, onde o MQL5 pode lê-la.

• Para garantir que a resposta esteja devidamente formatada, o dicionário Python é convertido em uma string JSON usando json.dumps(). Escrever essa string JSON no arquivo garante que o sistema MQL5 consiga interpretar a resposta corretamente.

• Essa etapa é crítica porque completa o ciclo de comunicação entre Python e MQL5, permitindo que o MQL5 saiba se a operação foi bem-sucedida ou falhou e tome a ação apropriada.

def write_response(response):
    """Writes a response to the MQL5 file."""
    with open(PYTHON_TO_MQL5, "w", encoding="utf-8") as file:
        file.write(json.dumps(response))

7. Loop Principal

Criamos um loop contínuo para ler e processar comandos do MQL5, garantindo que o sistema opere em tempo real. O loop principal é o coração do script, onde tudo se conecta. Após a conexão e autorização bem-sucedidas com a API da Deriv, o script entra em um loop onde verifica continuamente se há novos comandos. A função read_command é chamada para verificar se existe um novo comando a ser processado.

• Se um comando for encontrado, ele é processado e o resultado é enviado de volta ao MQL5. Se o arquivo de comando não existir ou ocorrer um erro, isso é tratado de forma adequada exibindo uma mensagem de erro e encerrando o loop.
• O loop é essencial para manter o sistema responsivo. Garantimos que o script não seja executado indefinidamente sem controle e que não falhe sem fornecer informações úteis. Ao implementar blocos try-except, protegemos o loop contra erros inesperados e garantimos que ele não quebre o script, mas sim finalize corretamente.

if __name__ == "__main__":
    if not connect_to_deriv():
        print("Failed to authorize. Exiting.")
        exit(1)

    print("Connected and authorized. Waiting for commands...")
    while True:
        try:
            command = read_command()
            if command:
                print(f"Processing command: {command}")
                response = process_command(command)
                print(f"Response: {response}")
                write_response(response)
                print("Response written. Exiting loop.")
                break  # Exit the loop after processing one command
            else:
                print("No command file found. Exiting.")
                break  # Exit the loop if the command file is not found
        except Exception as e:
            print(f"Error in main loop: {e}")
            break  # Exit the loop on unexpected error

Gestor de Fundos EA

Nesta etapa, continuaremos explorando o processo de desenvolvimento do EA Gerenciador de Fundos. Projetaremos este EA para monitorar o saldo da conta e propor uma recarga caso o saldo caia abaixo de um limite especificado. A operação de recarga será acionada por meio do script Python que desenvolvemos anteriormente. Embora este EA não englobe todas as funcionalidades de um Expert Advisor completo, focaremos no segmento específico do código que integra interações com a API da corretora. A discussão tem como objetivo demonstrar o potencial para integrar APIs de corretoras com qualquer EA.

Visão geral do Plano de Desenvolvimento:

Um dos componentes principais deste EA é a implementação da função ShellExecuteW, que será usada para executar o script deriv_api_handler.py a partir do código do EA. O EA monitorará o saldo atual da conta e, caso detecte que o valor está abaixo do limite definido, emitirá um comando para iniciar um depósito.

Tipicamente, tais operações são tratadas na função OnTimer() para permitir verificações periódicas e automação por um período prolongado. No entanto, para fins de teste e feedback imediato, optei por colocar essas operações dentro da função OnInit(). Essa abordagem garante que a API seja testada imediatamente após o EA ser iniciado. A longo prazo, a função OnTimer() será mais adequada para monitorar continuamente o saldo da conta e solicitar uma recarga conforme necessário. 

1. Importação de metadados e bibliotecas

Esta seção configura metadados para o Expert Advisor (EA) e importa uma biblioteca do sistema para executar comandos externos. A função ShellExecuteW da biblioteca shell32.dll é usada para executar aplicações externas como um script Python, permitindo comunicação com sistemas ou APIs externas.

//+------------------------------------------------------------------+
//|                                             Fund Manager EA.mq5  |
//|                                Copyright 2024, Clemence Benjamin |
//|             https://www.mql5.com/en/users/billionaire2024/seller |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Clemence Benjamin"
#property link      "https://www.mql5.com/en/users/billionaire2024/seller"
#property version   "1.01"
#property description "Deposit and Withdraw funds between broker and trading account within the EA"

#import "shell32.dll"
int ShellExecuteW(int hwnd, string lpOperation, string lpFile, string lpParameters, string lpDirectory, int nShowCmd);
#import

2. Parâmetros de entrada para personalização

Aqui, parâmetros de entrada personalizáveis permitem que os usuários adaptem o EA às suas necessidades específicas sem modificar o código principal. Os parâmetros incluem o limite de saldo, o valor de recarga, IDs de conta para transferências de fundos e caminhos para o script Python e o executável.

input double balance_threshold = 100000.0;  // Threshold balance for top-up
input double top_up_amount = 100000.0;      // Amount to top-up if balance is below threshold
input string from_binary = "CR0000000";     // Binary account ID to withdraw funds from. Replace zero with real one
input string to_mt5 = "MTRReplace";     // MT5 account ID to deposit funds into. Replace with your MT5 acc from Deriv Broker
input string python_script_path = "C:\\Users\\YourComputerName\\PathTo\\deriv_api_handler.py"; // Python script path
input string python_exe = "python";         // Python executable command (ensure Python is in PATH)

3. Inicialização: Consulta de saldo e depósito

A função OnInit é o ponto de entrada do EA. Ela primeiro recupera o saldo atual da conta usando AccountInfoDouble(ACCOUNT_BALANCE). Se o saldo estiver abaixo do limite especificado, o EA procede para iniciar um depósito.

int OnInit()
  {
   double current_balance = AccountInfoDouble(ACCOUNT_BALANCE);
   Print("Current Account Balance: ", current_balance);

   if(current_balance < balance_threshold)
     {
      Print("Balance is below the threshold. Attempting a deposit...");

4. Escrevendo o comando Deposit em um arquivo

O EA cria um arquivo para comunicar-se com o script Python. O arquivo contém uma string no formato JSON especificando o comando de depósito, incluindo o valor, detalhes da conta de origem e destino. Esse arquivo atua como interface entre o MQL5 e o sistema Python.

string command_file = "mql5_to_python.txt";
string command_path = TerminalInfoString(TERMINAL_COMMONDATA_PATH) + "\\Files\\" + command_file;
int handle = FileOpen(command_file, FILE_WRITE | FILE_COMMON | FILE_TXT | FILE_ANSI);

string deposit_command = StringFormat("{\"mt5_deposit\": 1, \"amount\": %.2f, \"from_binary\": \"%s\", \"req_id\": 1, \"to_mt5\": \"%s\"}", top_up_amount, from_binary, to_mt5);
FileWrite(handle, deposit_command);
FileClose(handle);
Print("Deposit command written to file: ", command_path);

5. Executando o script Python

Usando a função ShellExecuteW, o EA executa o script Python especificado nos parâmetros de entrada. O script processa a solicitação de depósito e interage com sistemas externos.

int result = ShellExecuteW(0, "open", python_exe, python_script_path, NULL, 1);
if(result <= 32)
  {
   Print("Failed to launch Python script. Error code: ", result);
   return(INIT_FAILED);
  }
else
  {
   Print("Python script launched successfully.");
  }

6. Verificando a resposta do Python

Após executar o script Python, o EA verifica a existência de um arquivo de resposta. Se o arquivo existir, o EA o lê para confirmar se o depósito foi bem-sucedido. O arquivo de resposta deve conter uma mensagem de sucesso para que o EA proceda adequadamente.

string response_file = "python_to_mql5.txt";
if(FileIsExist(response_file, FILE_COMMON))
  {
   handle = FileOpen(response_file, FILE_READ | FILE_COMMON | FILE_TXT | FILE_ANSI);
   string response = FileReadString(handle);
   FileClose(handle);
   Print("Response from Python: ", response);

   if(StringFind(response, "\"status\":\"success\"") >= 0)
     {
      Print("Deposit was successful.");
     }
   else
     {
      Print("Deposit failed. Response: ", response);
     }
  }
else
  {
   Print("Response file not found. Ensure the Python script is running and processing the command.");
  }

7. Finalizando a inicialização

Se o saldo estiver acima do limite, o EA ignora o processo de depósito. A inicialização termina com sucesso e o EA entra em sua fase operacional.

else
  {
   Print("Balance is above the threshold. No deposit attempt needed.");
  }

return(INIT_SUCCEEDED);

8. Desinicialização 

Desinicialização 

void OnDeinit(const int reason)
  {
   Print("Expert deinitialized.");
  }

Testes de demonstração e resultados

Discutiremos dois testes aqui;

1. Testando o script Python (deriv_api_handler.py) no Prompt de Comando
2. Testando o EA de Gestão de Fundos

Vamos aos detalhes:

1. Testando o script Python (deriv_api_handler.py)

Trabalhei no meu script Python usando uma ferramenta gratuita chamada Notepad++. Abaixo há um clipe animado mostrando como iniciar o prompt de comando diretamente a partir do editor. Essa abordagem é essencial, pois garante que o prompt de comando esteja direcionado para a pasta contendo o script, tornando conveniente executar o script diretamente de sua localização.

Iniciando o cmd a partir do Notepad++

Uma vez que a janela do prompt de comando esteja aberta, você pode digitar o comando para executar o script. O objetivo é verificar a autorização bem-sucedida e o acesso à API da Deriv.

Digite o seguinte comando no prompt de comando e pressione Enter:

python deriv_api_handler.py

Resposta com credenciais de API padrão:

Com o script padrão que não possui credenciais válidas, você receberá a resposta mostrada abaixo. É essencial garantir que você forneça suas credenciais funcionais (Token de API e App ID) para estabelecer autorização e funcionalidade adequadas.

Error during authorization: Handshake status 401 Unauthorized -+-+- {'date': 'Thu, 15 Jan 2025 08:43:53 GMT', 'content-type': 
'application/json;charset=UTF-8', 'content-length': '24', 'connection': 'keep-alive', 'content-language': 'en', 'upgrade': 
'websocket', 'sec-websocket-accept': 'yfwlFELh2d3KczdgV3OT8Nolp0Q=', 'cf-cache-status': 'DYNAMIC', 'server': 'cloudflare', 'cf-ray': 
'902cd20129b638df-HRE', 'alt-svc': 'h3=":443"; ma=86400'} -+-+- b'{"error":"InvalidAppID"}'
Failed to authorize. Saindo.

Resposta com as credenciais corretas:

No trecho de resultado abaixo, usando as credenciais corretas, estabelecemos com sucesso uma conexão e autorização. O programa então verifica o arquivo mql5_to_python.txt na pasta comum, como mostrado abaixo. Esse arquivo de texto contém as informações do comando que o script processa e encaminha através da conexão WebSocket. A API envia uma resposta, e neste exemplo foram usados detalhes de conta aleatórios para proteger minhas credenciais. Você precisará usar seus detalhes corretos para obter resultados positivos.

Nosso objetivo foi atingido com sucesso, pois recebemos uma resposta e um arquivo python_to_mql5.txt foi gerado com a resposta da API, o qual é então comunicado de volta ao MetaTrader 5.

Conectado e autorizado. Aguardando comandos...
Checking for command file at: C:/Users/YourComputerName/AppData/Roaming/MetaQuotes/Terminal/Common/Files/mql5_to_python.txt
Command file found: C:/Users/YourComputerName/AppData/Roaming/MetaQuotes/Terminal/Common/Files/mql5_to_python.txt
Raw Command read: '{"mt5_deposit": 1, "amount": 100000.00, "from_binary": "CR4000128", "req_id": 1, "to_mt5": "MTR130002534"}'
Processed Command: '{"mt5_deposit": 1, "amount": 100000.00, "from_binary": "CR4000128", "req_id": 1, "to_mt5": "MTR130002534"}'
Processing command: {"mt5_deposit": 1, "amount": 100000.00, "from_binary": "CR4000128", "req_id": 1, "to_mt5": "MTR130002534"}
Response: {'echo_req': {'amount': 100000, 'from_binary': 'CR4000128', 'mt5_deposit': 1, 'to_mt5': 'MTR130002534'}, 'error': {'code': 'PermissionDenied', 
'message': 'Permission denied, requires payments scope(s).'}, 'msg_type': 'mt5_deposit'}
Response written. Saindo do loop.

2. Testando o EA de Gestão de Fundos

Para testar nosso Expert Advisor (EA), o iniciamos no MetaTrader 5. Conforme mencionado anteriormente, projetamos para que ele tentasse um depósito durante a inicialização. Como estamos trabalhando com uma conta demo que possui patrimônio de 10.000, defini o limite de saldo para 100.000 para acionar uma tentativa de depósito caso o saldo atual esteja abaixo desse valor. Abaixo há uma captura animada exibindo o lançamento, juntamente com as configurações de entrada que permitem a personalização desses valores.

Lançamento do EA de Gestor de Fundos

Na aba Experts da janela Toolbox no MetaTrader 5, você pode visualizar o log de todas as operações realizadas pelo EA. Abaixo, você encontrará os resultados do log exibidos.

2025.01.14 11:49:56.012 Fund Manager EA1 (EURUSD,M1)    Current Account Balance: 10000.22
2025.01.14 11:49:56.012 Fund Manager EA1 (EURUSD,M1)    Balance is below the threshold. Attempting a deposit...
2025.01.14 11:49:56.013 Fund Manager EA1 (EURUSD,M1)    Deposit command written to file: C:\Users\BTA24\AppData\Roaming\MetaQuotes\Terminal\Common\Files\mql5_to_python.txt
2025.01.14 11:49:56.097 Fund Manager EA1 (EURUSD,M1)    Python script launched successfully.
2025.01.14 11:50:01.132 Fund Manager EA1 (EURUSD,M1)    Response file path: C:\Users\BTA24\AppData\Roaming\MetaQuotes\Terminal\Common\Files\python_to_mql5.txt
2025.01.14 11:50:01.133 Fund Manager EA1 (EURUSD,M1)    Response from Python: {"echo_req": {"amount": 100000, "from_binary": "CR4000128", "mt5_deposit": 1,
 "to_mt5": "MTR130002534"}, "error": {"code": "PermissionDenied", "message": "Permission denied, requires payments scope(s)."}, "msg_type": "mt5_deposit"}
2025.01.14 11:50:01.133 Fund Manager EA1 (EURUSD,M1)    Deposit failed. Response: {"echo_req": {"amount": 100000, "from_binary": "CR4000128", "mt5_deposit": 1, 
"to_mt5": "MTR130002534"}, "error": {"code": "PermissionDenied", "message": "Permission denied, requires payments scope(s)."}, "msg_type": "mt5_deposit"}

O resultado acima demonstra uma interação bem-sucedida entre o EA Gerenciador de Fundos, o script Python e a API da Deriv. Privadamente, realizei com sucesso operações de recarga usando esse conjunto. Neste exemplo, contudo, encontramos um erro "Permission Denied" porque credenciais aleatórias foram usadas para proteger minhas credenciais pessoais de API.

Conclusão

Conseguimos integrar com sucesso o MQL5 e o Python para interagir com um servidor de corretora externo por meio de sua API. Essa solução resolve o desafio de ficar sem fundos durante negociações automatizadas, especialmente para contas hospedadas em um VPS. O EA recarrega automaticamente a conta quando seu saldo cai abaixo de um limite definido. Embora nosso foco tenha sido a API da Deriv, integrações semelhantes podem ser alcançadas com outras APIs de corretoras, muitas das quais oferecem recursos avançados e níveis variados de acesso. Para fins de demonstração, testamos o EA usando uma conta vazia e verificamos sua funcionalidade por meio de respostas da API. Você pode estender esse sistema para incluir capacidades de saque e outros recursos avançados.

A aplicação da API da Deriv é simples e facilita principalmente o gerenciamento dos tokens de API necessários para a comunicação do EA. Você pode explorar a API mais a fundo para desbloquear possibilidades adicionais. Anexados estão os arquivos do script Python e do EA Gerenciador de Fundos para testes e expansão. Sinta-se à vontade para compartilhar suas opiniões ou fazer perguntas na seção de comentários abaixo para manter a discussão ativa.