Integration von Broker-APIs mit Expert Advisors unter Verwendung von MQL5 und Python

Einführung

Heute werden wir untersuchen, wie man eine nahtlose Verbindung zwischen unseren MetaTrader 5 Expert Advisors und externen Brokern mit Hilfe der API-Integration herstellen kann. Das Hauptziel besteht darin, das Problem unzureichender Geldmittel auf Handelskonten zu lösen, indem automatische Aufladungen ermöglicht werden, wenn das Guthaben unter einen bestimmten Schwellenwert fällt.  Mit diesem Ansatz werden kritische Fragen der Fondsverwaltung wirksam angegangen und sowohl die Effizienz als auch die Sicherheit der Handelsoperationen erhöht.

Normalerweise loggen wir uns routinemäßig in unser Maklerkonto-Portal ein, um verschiedene Transaktionen und Vorgänge durchzuführen. Dies ist zwar der traditionelle Ansatz, aber es gibt eine leistungsstarke Funktion, die API (Application Programming Interface), mit der wir viel mehr tun und unseren Ansatz optimieren können. Einigen von Ihnen ist dieser Begriff vielleicht bekannt. Für die anderen werde ich sie in leicht verständliche Abschnitte unterteilen, um sicherzustellen, dass alle auf der gleichen Seite sind:

1. Was ist eine API?
2. Verwendung von APIs
3. Zugriff auf APIs
4. API-Dokumentation

Lassen Sie uns diese im Detail untersuchen:

1. Was ist eine API?

Eine API (Application Programming Interface, Programmierschnittstelle) ermöglicht externe Interaktionen mit einem Softwaresystem. In diesem Zusammenhang bietet es uns die Möglichkeit, Operationen auf unseren Brokerkonten direkt auf dem Server durchzuführen, ohne dass wir uns manuell anmelden müssen.

Interessanterweise gibt es Programmierschnittstelle schon seit den 1940er Jahren, aber erst seit den 1970er Jahren und seit dem Jahr 2000 ist es weit verbreitet.

2. Verwendung von APIs

APIs erleichtern die Kommunikation zwischen Softwareanwendungen und Systemen. Hier sind einige der häufigsten Anwendungsbereiche:

• Website-Server
• Mobile Anwendungen

APIs ermöglichen einen nahtlosen Datenzugriff aus verschiedenen Quellen, wie z. B.:

• Plattformen für soziale Medien
• Cloud-Speicher
• Zahlungs-Gateways
• Wetterstationen
• Aktien und Finanzmärkte

API als Brücke zwischen externen Computern und Cloud-Servern.

3. Zugriff auf APIs

Um eine API zu verwenden, müssen Sie in der Regel:

• einen Schlüssel für die API des Anbieters beziehen,
• die API-Dokumentation studieren, um sie korrekt zu integrieren,
• den API-Schlüssel als Parameter in Ihre Anfragen zur Authentifizierung und Autorisierung einfügen.
• Der API-Schlüssel ist entscheidend für die Identifizierung Ihrer Anwendung oder Ihres Nutzers und gewährleistet gleichzeitig einen sicheren Zugang.

4. API-Dokumentation

Für jede API gibt es ein eigenes Nutzerhandbuch und eigene Spezifikationen. Darin wird beschrieben, wie man mit der API effektiv interagieren kann. Beispielsweise unterscheidet sich die Dokumentation der API von Telegram erheblich von der eines Maklers, wie z. B. der API des Brokers.

Durch das Verständnis und die Nutzung von APIs können wir unsere Abläufe rationalisieren, Prozesse automatisieren und die Effizienz bei der Verwaltung unserer Maklerkonten steigern. Lassen Sie uns die einzelnen Aspekte näher beleuchten und ihre praktische Umsetzung untersuchen.

Im Folgenden finden Sie eine Liste der wichtigsten Abschnitte in unserer Diskussion:

• Überblick über diese Diskussion
• Deriv-API
• Python-Bibliothek für Web-Socket-API-Kommunikation
• Python-Skript zur Überbrückung der Kommunikation zwischen MetaTrader 5 und Broker API
• Fondsmanager EA
• Demo-Tests und Ergebnisse
• Schlussfolgerung

Überblick über diese Diskussion

In diesem Artikel werden wir die Verwendung von MQL5 mit der API eines Brokers untersuchen, um nahtlose Abläufe in der Fondsverwaltung zu erleichtern. Unser Ziel ist es, das enorme Potenzial von MQL5 Expert Advisors (EAs) aufzudecken. Da MQL5 allein nicht direkt mit Webservern interagieren kann, werden wir je nach den API-Fähigkeiten des Brokers externe Sprachbibliotheken, wie Python oder Node.js, verwenden. Für diese Diskussion werden wir uns auf Deriv.com als den von uns gewählten Broker konzentrieren.

Vorteile dieses Ansatzes

• Automatisierte Fondsüberweisungen: Der EA wird den Transfer von Handelsgewinnen vom Handelskonto auf ein sicheres Konto automatisieren.
• Aufstocken des Handelskontos: Er überweist Geld auf das Handelskonto, wenn das Kapital unter einen vordefinierten Schwellenwert fällt.
• Kontinuierlicher Betrieb: Da der EA auf einem virtuellen Server gehostet wird, kann das System rund um die Uhr mit praktisch unbegrenzten Möglichkeiten der Fondsverwaltung arbeiten.

Herausforderungen und Überlegungen

• Risiko der Erschöpfung des Fonds: Die reservierten Mittel können erschöpft sein, wenn der EA weiter auflädt, ohne beständige Gewinne zu erzielen.
• Notwendigkeit einer soliden Fondsverwaltung: Es muss ein ausgeklügeltes Fondsmanagement-System implementiert werden, um den Betrieb zu stoppen, wenn bestimmte Verlust- oder Kapitalschwellen überschritten werden.

In den nächsten Abschnitten werden wir uns mit den Funktionen der Deriv-Broker-API befassen, Python-Code entwickeln, um eine reibungslose Interaktion mit der API zu ermöglichen, und diese Lösung in einen MQL5-EA integrieren, der für ein effizientes und zuverlässiges Fondsmanagement entwickelt wurde. All dies wird in einfachen, schrittweisen Anleitungen dargestellt, die leicht zu verstehen und umzusetzen sind.

Bidirektionaler Informationsfluss zwischen MQL5 und Broker

Deriv-API

Deriv.com ist ein beliebter Broker, der MetaTrader 5 unterstützt und API-Zugang für automatisierte Operationen bietet. Detaillierte Informationen finden Sie in der Dokumentation von Deriv API. Folgen Sie zunächst den Schritten auf der Website, um sich für den API-Zugang zu registrieren.

Zu Schulungszwecken müssen Sie eine Anwendung im DerivAPI Dashboard erstellen. Wählen Sie während dieses Vorgangs ein Demo-Konto aus und generieren Sie ein API-Token mit der entsprechenden Zugriffsstufe. Für diese Präsentation empfehle ich, die Zugriffsstufe Trade API zu wählen, da sie Vorgänge wie das Aufladen Ihres Demokontos ermöglicht. Wählen Sie nicht die Zugangsstufe „Admin“, wenn Sie nicht sicher sind, dass Sie das Konto sicher verwalten können, da diese Stufe volle Kontrolle über Ihr Konto gewährt. Bewahren Sie Ihr API-Token immer privat und sicher auf, um unbefugten Zugriff zu verhindern.

Sobald das API-Token erstellt ist, besteht der nächste Schritt darin, einen Python-WebSocket-Client einzurichten und ihn in MQL5 zu integrieren, um ein Programm zu entwickeln, das in der Lage ist, Kontooperationen zu verwalten.

Wichtige Operationen

Die wichtigsten Funktionen, die wir mit unserem Programm erreichen wollen, sind:

• Einzahlung von Geldern von Ihrem Deriv-Konto auf Ihr Deriv MetaTrader 5-Konto.
• Schnittstelle mit der Deriv-API für nahtlose Fondsverwaltung.

Die Deriv-API-Dokumentation enthält detaillierte Anweisungen zur Durchführung dieser Operationen im Abschnitt MT5 APIs. Im Rahmen dieses Prozesses werden Sie zwei kritische Werte erhalten:

• App ID: Identifiziert Ihre Anwendung auf der Deriv-Plattform.
• API-Token: Gewährt Zugang zur Durchführung der angegebenen Aktionen.

Mit diesen Werten können wir mit der Entwicklung des Python-WebSocket-Clients fortfahren und ihn mit MQL5 integrieren, um unser Fondsverwaltungssystem zu implementieren.

Sie und Ihre API-Sicherheit

Sicherheit ist ein kritisches Thema, das nicht außer Acht gelassen werden darf. Genauso wie Sie Ihr Telefon vor unbefugtem Zugriff schützen, ist es ebenso wichtig, Ihre API-Schlüssel vor anderen zu schützen. Ein API-Token fungiert als Tor zu Ihrem Konto, und wenn es in die Hände von Cyberkriminellen fällt, könnten Sie dadurch anfällig für bösartige Aktivitäten werden. Sie könnten Ihr Konto ausnutzen und unbefugte Aktionen ohne Ihr Wissen durchführen.

Im Zusammenhang mit Deriv bietet die Plattform API-Token-Zugriffsstufen, mit denen Sie die für das Token gewährten Berechtigungen auswählen können. Es wird dringend empfohlen, die Demo-Zugriffsfunktionen zu nutzen und den Admin-Zugriff nur dann zu wählen, wenn dies unbedingt erforderlich ist. Der Admin-Zugang gewährt die volle Kontrolle über Ihr Konto, was ein erhebliches Risiko darstellt, wenn es in die falschen Hände gerät.

Dieser Ratschlag ist nicht auf Deriv beschränkt, sondern gilt für API-Tokens von jedem Dienst. Behandeln Sie API-Schlüssel immer wie Passwörter - halten Sie sie geheim, bewahren Sie sie sicher auf, und geben Sie sie niemals an Personen weiter, denen Sie nicht vertrauen. Auf diese Weise minimieren Sie das Risiko eines unbefugten Zugriffs und stellen sicher, dass Ihr Konto geschützt bleibt.

Python-Bibliothek für Web-Socket-API-Kommunikation

Zuallererst müssen wir ein installiertes Python auf unserem Computer haben, um mit diesem Projekt fortzufahren. Als Nächstes müssen wir die Python WebSocket-Bibliothek installieren, um die Webkommunikation mit der API des Brokers zu ermöglichen. Die Deriv API verwendet WebSocket für die Hochgeschwindigkeitskommunikation, daher ist es wichtig, unsere Computer entsprechend einzurichten. Nachfolgend finden Sie den Befehl zur Installation der Python-Bibliothek unter Windows über die Eingabeaufforderung.

pip install websocket-client

 Um die Bibliothek zu installieren, öffnen Sie die Eingabeaufforderung oder Prompt unter Windows und geben Sie den obigen Befehl ein. Sobald die Installation abgeschlossen ist, können Sie mit dem Betrieb und den Tests beginnen. Bevor wir jedoch fortfahren, werden wir die nächsten Schritte unternehmen, um das Python-Skript zu entwickeln, das die Kommunikation zwischen MetaTrader 5 und der Broker-API (beispielsweise Derivs API) handhaben wird.

Python-Skript zur Überbrückung der Kommunikation zwischen MetaTrader 5 und Broker API

Ich habe die Schritte für die Entwicklung des Python-Skripts skizziert. Bevor wir mit der Erstellung unseres Fund Manager EA fortfahren, wollen wir uns mit dem Aufbau dieses Programms befassen. Öffnen Sie Ihren Code-Editor (Notepad++ ist vorzuziehen) und erstellen Sie eine neue Datei. Folgen Sie uns bei der Entwicklung des Skripts, das wir deriv_api_handler.py nennen werden. Notieren Sie sich den Speicherort Ihres Skripts, da es später im EA-Code benötigt wird.

1. Ersteinrichtung und Konfiguration

 Zunächst wollen wir die erforderlichen Importe einrichten, die Verbindungseinstellungen konfigurieren und die Dateipfade einrichten, über die die Kommunikation mit MQL5 erfolgen soll. Wir beginnen mit dem Import der wichtigsten Bibliotheken. Wir wissen, dass die Bibliothek json für das Parsen und Generieren von JSON-Daten entscheidend ist. Dies ist das Format, das für das Senden von Nachrichten über websocket und die Verarbeitung von Befehlen verwendet wird. Die Bibliothek websocket wird ausgewählt, um mit websocket die Verbindung zur Deriv-API zu handhaben, und time hilft dem Programm, bei Bedarf Pausen in das Skript einzufügen. Schließlich kann durch os mit dem Dateisystem interagiert werden, z. B. nach Befehlsdateien zu suchen.

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"

• Als Nächstes definieren wir unsere API-URL und unser Token, da dies die Schlüssel sind, die für die Autorisierung unserer WebSocket-Verbindung mit dem Deriv-Server benötigt werden. Diese URL verweist auf den WebSocket-Endpunkt, und das API-Token ist der Identitätsnachweis für den Server.

• Schließlich geben wir Dateipfade für die Interaktion mit MQL5 an. Diese Dateien dienen als Brücke zwischen unserem Python-Skript und MQL5 und ermöglichen den Austausch von Befehlen und Antworten. Wir sollten darauf achten, dass wir Pfade wählen, von denen wir wissen, dass sie für beide Systeme (MQL5 und Python) zugänglich sind.

2. WebSocket-Verbindung

In diesem Codeabschnitt unseres Skripts stellen wir eine sichere Verbindung zur Deriv WebSocket API her und autorisieren das Skript, Anfragen zu stellen.

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

• Wir definieren eine Funktion zur Verwaltung der WebSocket-Verbindung. Zunächst versuchen wir, eine Verbindung mit der API über die URL herzustellen, die wir zuvor eingerichtet haben. Wir initiieren die Verbindung mit ws.connect(API_URL) und senden dann die Autorisierungsnachricht mit unserem API-Token. Dies ist notwendig, um unser Skript gegenüber dem Deriv-Server zu authentifizieren.

• Sofort wartet das Skript auf eine Antwort des Servers. Der Server gibt ein JSON-Objekt zurück, das bestätigt, ob die Verbindung erfolgreich war. Wenn es einen Fehler enthält, weiß es, dass das Token ungültig war oder dass es ein anderes Problem gab. Diese Fehlerbehandlung ist wichtig, um sicherzustellen, dass das Skript ordnungsgemäß abbricht.

• Unsere Entscheidung, die Blöcke von try-except zu verwenden, stellt sicher, dass das Skript nicht abstürzt, wenn etwas mit der Verbindung oder dem Nachrichtenaustausch schief geht. Dies ist eine Sicherheitsmaßnahme, die dem Programm Flexibilität bei der Fehlersuche und -behebung gibt, ohne den gesamten Prozess zu unterbrechen.

3. Befehlsverarbeitung

In dieser Phase interpretiert das Programm die empfangenen Befehle und führt je nach Befehlstyp die entsprechenden Aktionen aus. Nach erfolgreicher Verbindung und Authentifizierung verarbeitet das Skript Befehle von MQL5, die in Form einer JSON-Zeichenfolge gesendet werden, sodass es bereit ist, diese zu parsen und zu verarbeiten.

• In der Funktion process_command versucht das Skript zunächst, den Befehl für Python zu zerlegen. Dies ermöglicht den einfachen Zugriff auf verschiedene Felder des Befehls (wie den Einzahlungsbetrag). Dann wird nach bestimmten Schlüsseln in der geparsten JSON-Datei gesucht (z. B. „mt5_deposit“), die Aufschluss darüber geben, welche Art von Aktion von MQL5 durchgeführt werden soll.

• Wenn der Befehl eine Einzahlung verlangt (mt5_deposit), wird die separate Funktion mt5_deposit aufgerufen, um diese zu bearbeiten. Dieser modulare Ansatz macht das Skript flexibel und wartbar, da wir in Zukunft problemlos weitere Befehlstypen hinzufügen können.

• Wenn der Befehl unbekannt oder falsch formatiert ist, wird eine Fehlermeldung zurückgegeben, die dem MQL5-System hilft zu verstehen, was falsch gelaufen ist.

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. Einlagengeschäft

Dieser Abschnitt führt den von MQL5 angeforderten Einzahlungsvorgang durch und sendet die erforderlichen Daten an die Deriv-API. Wir haben eine eigene Funktion (mt5_deposit) für die Durchführung der Einzahlung erstellt. Dadurch bleibt unser Code übersichtlich und die Logik für die Bearbeitung von Einlagen wird isoliert, was die Wartung und Erweiterung erleichtert.

• Innerhalb dieser Funktion wird eine JSON-Nachricht erstellt, die Deriv anweist, eine Einzahlung durchzuführen. Diese Nachricht enthält alle notwendigen Angaben wie den Betrag, das Quellkonto und das MT5-Zielkonto. Die Übermittlung der richtigen Daten im richtigen Format ist entscheidend für die erfolgreiche Abwicklung der Transaktion.

• Nach dem Senden der Einzahlungsanforderung wartet er auf eine Antwort des Servers. Sobald die Antwort eingegangen ist, wird sie in JSON geparst und zurückgegeben. Dadurch erfährt das MQL5-System, ob der Vorgang erfolgreich war oder nicht.

• Ausnahmen werden für den Fall behandelt, dass etwas mit der Kommunikation oder dem Einzahlungsvorgang schief läuft, wodurch sichergestellt wird, dass Fehler erfasst und an MQL5 zurückgemeldet werden.

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. Lesen von Befehlen aus MQL5

Dies ist ein Abschnitt im Code, in dem ein Befehl von MQL5 geprüft und verarbeitet wird, wenn er verfügbar ist, um sicherzustellen, dass derselbe Befehl nicht wiederholt verarbeitet wird. Um Befehle aus MQL5 zu lesen, wird geprüft, ob die Datei mql5_to_python.txt existiert. Hier schreibt MQL5 Befehle, die verarbeitet werden müssen. Wenn die Datei existiert, wird ihr Inhalt gelesen. Durch das Entfernen unnötiger Leerzeichen und die Überprüfung auf eine BOM (Byte Order Mark) wird sichergestellt, dass die Daten unabhängig von Formatierungsinkonsistenzen korrekt verarbeitet werden.

• Sobald der Befehl gelesen wurde, wird er zu Debugging-Zwecken ausgedruckt, damit überprüft werden kann, ob der Inhalt wie erwartet abgerufen wurde. Nach dem Lesen des Befehls wird die Datei gelöscht, um sicherzustellen, dass derselbe Befehl in Zukunft nicht mehr verarbeitet wird.
• Wenn die Datei nicht existiert, wird „None“ zurückgegeben, was bedeutet, dass es keinen Befehl zu verarbeiten gibt. Dies hilft, unnötige Überprüfungen zu vermeiden, wenn kein Befehl verfügbar ist.

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. Antworten auf MQL5 schreiben

Dieser Teil sendet die Antwort zurück an MQL5, damit es auf der Grundlage unseres Ergebnisses weitere Maßnahmen ergreifen kann.  Nach der Verarbeitung eines Befehls und dem Erhalt einer Antwort wird dieser an MQL5 zurückgeschickt. Dazu wird die Antwort in die Datei python_to_mql5.txt geschrieben, wo MQL5 sie lesen kann.

• Um sicherzustellen, dass die Antwort richtig formatiert ist, wird das Python-Wörterbuch mit json.dumps() in eine JSON-Zeichenkette umgewandelt. Das Schreiben dieser JSON-Zeichenfolge in die Datei stellt sicher, dass das MQL5-System die Antwort korrekt interpretieren kann.

• Dieser Schritt ist von entscheidender Bedeutung, da er die Kommunikationsschleife zwischen Python und MQL5 abschließt, sodass MQL5 weiß, ob die Operation erfolgreich war oder fehlgeschlagen ist und entsprechende Maßnahmen ergreifen kann.

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. Hauptschleife

Wir erstellen eine kontinuierliche Schleife, um Befehle von MQL5 zu lesen und zu verarbeiten, damit das System in Echtzeit arbeitet. Die Hauptschleife ist das Herzstück des Skripts, in dem alles zusammenläuft. Nach erfolgreicher Verbindung und Autorisierung mit der Deriv-API tritt es in eine Schleife ein, in der es ständig nach neuen Befehlen sucht. Die Funktion read_command wird aufgerufen, um zu prüfen, ob es einen neuen Befehl zu verarbeiten gibt.

• Wenn ein Befehl gefunden wird, wird er verarbeitet und das Ergebnis wird in MQL5 zurückgeschrieben. Wenn die Befehlsdatei nicht existiert oder ein Fehler auftritt, wird eine Fehlermeldung ausgegeben und die Schleife beendet.
• Die Schleife ist entscheidend für die Aufrechterhaltung eines reaktionsfähigen Systems. Wir haben sichergestellt, dass das Skript nicht endlos läuft oder versagt, ohne nützliches Feedback zu liefern. Durch die Implementierung der Blöcke von try-except schützen wir die Schleife vor unerwarteten Fehlern und stellen sicher, dass sie das Skript nicht zum Absturz bringt, sondern sauber beendet wird

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

Fondsmanager EA

In dieser Phase werden wir den Entwicklungsprozess des Fund Manager EA weiter untersuchen. Wir werden diesen EA so gestalten, dass er den Kontostand überwacht und eine Aufstockung vorschlägt, wenn der Kontostand unter einen bestimmten Schwellenwert fällt. Der Aufladevorgang wird durch das Python-Skript ausgelöst, das wir zuvor entwickelt haben. Dieser EA umfasst zwar nicht alle Funktionen eines vollwertigen Expert Advisors für den Handel, aber wir werden uns auf das spezifische Codesegment konzentrieren, das die Interaktionen mit der Broker-API integriert. Die Diskussion zielt darauf ab, das Potenzial für die Integration von Broker-APIs mit jedem EA aufzuzeigen.

Überblick über den Entwicklungsplan:

Eine der wichtigsten Komponenten dieses EA ist die Implementierung der Funktion ShellExecuteW, mit der das Skript deriv_api_handler.py aus dem EA-Code heraus gestartet wird. Der EA überwacht den aktuellen Kontostand, und wenn er feststellt, dass der Saldo unter dem festgelegten Schwellenwert liegt, gibt er den Befehl, eine Einzahlung zu veranlassen.

Typischerweise werden solche Operationen in der Funktion OnTimer() abgewickelt, um periodische Überprüfungen und Automatisierung über einen längeren Zeitraum zu ermöglichen. Für die Zwecke des Testens und der unmittelbaren Rückmeldung habe ich mich jedoch dafür entschieden, diese Operationen innerhalb der Funktion OnInit() zu platzieren. Dieser Ansatz stellt sicher, dass die API unmittelbar nach dem Start des EA getestet wird. Langfristig wird die Funktion OnTimer() besser geeignet sein, um den Kontostand kontinuierlich zu überwachen und bei Bedarf eine Aufladung anzufordern. 

1. Metainformationen und Bibliotheksimport

In diesem Abschnitt werden Metadaten für den Expert Advisor (EA) eingerichtet und eine Systembibliothek zur Ausführung externer Befehle importiert. Die Funktion ShellExecuteW aus der Bibliothek shell32.dll wird verwendet, um externe Anwendungen wie ein Python-Skript auszuführen und die Kommunikation mit externen Systemen oder APIs zu ermöglichen.

//+------------------------------------------------------------------+
//|                                             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. Eingabeparameter für Anpassungen

Hier ermöglichen anpassbare Eingabeparameter den Nutzern, den EA an ihre spezifischen Bedürfnisse anzupassen, ohne den Kerncode zu verändern. Zu den Parametern gehören der Schwellenwert für den Kontostand, der Aufladebetrag, die Konto-IDs für Überweisungen und die Pfade für das Python-Skript und die ausführbare Datei.

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. Initialisierung: Saldoüberprüfung und Einzahlung

Die Funktion OnInit ist der Einstiegspunkt in den EA. Zunächst wird der aktuelle Kontostand mit AccountInfoDouble(ACCOUNT_BALANCE) abgefragt. Liegt der Saldo unter dem angegebenen Schwellenwert, veranlasst der EA eine Einzahlung.

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. Ablagebefehl in eine Datei schreiben

Der EA erstellt eine Datei zur Kommunikation mit dem Python-Skript. Die Datei enthält eine JSON-formatierte Zeichenfolge, die den Einzahlungsbefehl angibt, einschließlich des Betrags, der Quell- und Zielkontodetails. Diese Datei dient als Schnittstelle zwischen MQL5 und dem Python-System.

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. Starten des Python-Skripts

Mit der Funktion ShellExecuteW führt der EA das in den Eingabeparametern angegebene Python-Skript aus. Das Skript verarbeitet den Einzahlungsantrag und interagiert mit externen Systemen.

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. Überprüfung der Python-Antwort

Nachdem das Python-Skript ausgeführt wurde, sucht der EA nach einer Antwortdatei. Wenn die Datei vorhanden ist, liest der EA sie, um festzustellen, ob die Einzahlung erfolgreich war. Die Antwortdatei muss eine Erfolgsmeldung enthalten, damit der EA entsprechend fortfahren kann.

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. Initialisierung abschließen

Wenn der Saldo über dem Schwellenwert liegt, überspringt der EA den Einzahlungsvorgang. Die Initialisierung wird erfolgreich abgeschlossen, und der EA tritt in seine Betriebsphase ein.

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

return(INIT_SUCCEEDED);

8. Deinitialisierung 

Die Funktion OnDeinit protokolliert, wenn der EA entfernt oder deinitialisiert wird. 

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

Demo-Tests und Ergebnisse

Wir werden hier zwei Tests besprechen;

1. Testen des Python-Skripts (deriv_api_handler.py) in der Eingabeaufforderung
2. Testen des Fund Manager EA

Lassen Sie uns ins Detail gehen:

1. Testen des Python-Skripts (deriv_api_handler.py)

Ich habe mein Python-Skript mit einem kostenlosen Tool namens Notepad++ bearbeitet. Nachfolgend sehen Sie einen animierten Clip, der zeigt, wie Sie die Eingabeaufforderung direkt aus dem Editor heraus aufrufen können. Diese Vorgehensweise ist wichtig, da sie sicherstellt, dass die Eingabeaufforderung zu dem Ordner mit dem Skript geleitet wird, sodass das Skript direkt von diesem Ort aus ausgeführt werden kann.

Starten von cmd aus Notepad++

Sobald das Fenster der Eingabeaufforderung geöffnet ist, können Sie den Befehl zur Ausführung des Skripts eingeben. Ziel ist es, die erfolgreiche Autorisierung und den Zugriff auf die Deriv-API zu überprüfen.

Geben Sie den folgenden Befehl in die Eingabeaufforderung ein und drücken Sie die Eingabetaste:

python deriv_api_handler.py

Antwort mit Standard-API-Anmeldedaten:

Mit dem Standardskript ohne gültige Anmeldeinformationen erhalten Sie die unten abgebildete Antwort. Es ist wichtig, dass Sie Ihre Arbeitsanmeldedaten (API Token und App ID) angeben, um eine ordnungsgemäße Autorisierung und Funktionalität zu gewährleisten.

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. Exiting.

Antwort mit korrekten Anmeldedaten:

Im folgenden Ergebnisausschnitt wird unter Verwendung der korrekten Anmeldeinformationen erfolgreich eine Verbindung und Autorisierung hergestellt. Das Programm sucht dann nach der Datei mql5_to_python.txt im gemeinsamen Dateiordner, wie unten gezeigt. Diese Textdatei enthält die Befehlsinformationen, die das Skript verarbeitet und über eine WebSocket-Verbindung weiterleitet. Die API sendet eine Antwort zurück, und in diesem Beispiel werden zufällige Kontodaten verwendet, um meine Anmeldedaten zu schützen. Um positive Ergebnisse zu erzielen, müssen Sie Ihre korrekten Angaben verwenden.

Unser Ziel wurde erfolgreich erreicht, da wir eine Antwort erhielten und eine python_to_mql5.txt-Datei mit der API-Antwort generiert wurde, die dann an MetaTrader 5 zurückübertragen wird.

Connected and authorized. Waiting for commands...
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. Exiting loop.

2. Testen des Fund Manager EA

Um unseren Expert Advisor (EA) zu testen, haben wir ihn in MetaTrader 5 gestartet. Wie bereits erwähnt, haben wir es so konzipiert, dass bei der Initialisierung eine Einzahlung versucht wird. Da wir mit einem Demokonto arbeiten, das ein Kapital von 10.000 hat, habe ich den Schwellenwert für den Saldo auf 100.000 gesetzt, um einen Einzahlungsversuch auszulösen, wenn der aktuelle Saldo unter diesem Wert liegt. Unten sehen Sie einen animierten Screenshot, der den Start zeigt, zusammen mit den Eingabeeinstellungen, die eine Anpassung dieser Werte ermöglichen.

Starten des Fund Manager EA

Auf der Registerkarte Experten des Fensters Werkzeuge in MetaTrader 5 können Sie das Protokoll aller vom EA durchgeführten Operationen einsehen. Nachfolgend finden Sie die angezeigten Protokollergebnisse.

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"}

Das obige Ergebnis zeigt eine erfolgreiche Interaktion zwischen dem Fund Manager EA, dem Python-Skript und der Deriv-API. Privat habe ich auf diese Weise erfolgreich Aufladevorgänge durchgeführt. In diesem Beispiel kam es jedoch zu dem Fehler „Permission Denied“, da zufällige Anmeldedaten verwendet wurden, um meine persönlichen API-Anmeldedaten zu schützen.

Schlussfolgerung

Wir haben MQL5 und Python erfolgreich integriert, um mit einem externen Broker-Server über dessen API zu interagieren. Diese Lösung löst das Problem, dass während des automatisierten Handels kein Geld mehr vorhanden ist, insbesondere bei Konten, die auf einem VPS gehostet werden. Der EA füllt das Konto automatisch wieder auf, wenn der Kontostand unter einen bestimmten Schwellenwert fällt. Wir haben uns zwar auf die Deriv-API konzentriert, aber ähnliche Integrationen können auch mit anderen Makler-APIs erreicht werden, von denen viele fortgeschrittene Funktionen und unterschiedliche Zugriffsebenen bieten. Zu Demonstrationszwecken haben wir den EA mit einem leeren Konto getestet und seine Funktionalität anhand der API-Antworten überprüft. Sie können dieses System um Abhebungsmöglichkeiten und andere erweiterte Funktionen erweitern.

Die Deriv-API-Anwendung ist einfach und erleichtert in erster Linie die Verwaltung der für die EA-Kommunikation benötigten API-Tokens. Sie können die API weiter erforschen, um zusätzliche Möglichkeiten zu erschließen. Im Anhang finden Sie das Python-Skript und die Fund Manager EA-Dateien zum Testen und Erweitern. Bitte zögern Sie nicht, uns Ihre Gedanken mitzuteilen oder Fragen in den unten stehenden Kommentaren zu stellen, um die Diskussion am Leben zu erhalten.