Creare un Expert Advisor (EA) Forex per MetaTrader 4 (MT4): Guida Completa

Forex • Finance | Ottobre 3, 2025

Updated: March 5, 2026

Sviluppare un Expert Advisor (EA) per MetaTrader 4 (MT4) è un processo che coinvolge diversi passaggi, dalla concettualizzazione della tua strategia di trading al coding, testing e deployment. Ecco una guida completa per iniziare.

1. Definisci la Tua Strategia di Trading

Prima di scrivere una sola riga di codice, è fondamentale avere una strategia di trading ben definita. Questo è il passo più importante. Chiediti:

  • Quali indicatori userai? (es. Medie Mobili, RSI, MACD, Stocastico)
  • Quali sono le tue condizioni di ingresso? (es. Quando una MA incrocia, l’RSI supera un livello, l’istogramma MACD cambia direzione)
  • Quali sono le tue condizioni di uscita?
    • Take Profit (TP): A quanti pip punti?
    • Stop Loss (SL): A quanti pip punti?
    • Trailing Stop: Userai una stop loss mobile per proteggere i profitti?
    • Uscite temporali: Uscirai dopo un certo numero di barre?
    • Uscite basate su indicatori: Uscirai quando un altro indicatore darà un segnale?
  • Quali sono le tue regole di gestione del rischio?
    • Calcolo delle dimensioni del lotto: Dimensione fissa, percentuale del saldo del conto o una formula più complessa?
    • Numero massimo di trade aperti: Limiterai il numero di trade contemporanei?
    • Drawdown massimo: Smetterai di trading se il conto scende di una certa percentuale?
  • Quali coppie di valute e timeframe tradare?
  • Quali sono i tuoi orari di trading?

2. Impara il MQL4 (MetaQuotes Language 4)

MQL4 è il linguaggio di programmazione utilizzato per creare EA, indicatori e script in MT4. Non è necessario essere programmatori esperti, ma una comprensione di base è essenziale.

Risorse per imparare il MQL4:

  • Documentazione MQL4: Il tuo riferimento principale. Accessibile direttamente da MT4 (premi F1 in MetaEditor) o online.
  • Community MQL4: Il sito ufficiale MQL4 (mql4.com) ha un vasto forum, articoli ed esempi di codice.
  • Tutorial Online: Molti siti web e canali YouTube offrono tutorial MQL4 per principianti.
  • Libri: Sono disponibili diversi libri sulla programmazione MQL4.

3. Configura il Tuo Ambiente di Sviluppo

MetaTrader 4 include un ambiente di sviluppo integrato (IDE) chiamato MetaEditor.

  • Apri MetaEditor: In MT4, vai su “Strumenti” > “MetaQuotes Language Editor” o premi F4.
  • Crea un Nuovo EA:
    1. In MetaEditor, clicca “File” > “Nuovo”.
    2. Seleziona “Expert Advisor (template)” e clicca “Avanti”.
    3. Dai al tuo EA un nome descrittivo (es. “IlMioPrimoEA_MA”).
    4. Clicca “Avanti” nelle schermate successive, lasciando le impostazioni predefinite per ora.
    5. Clicca “Fine”.

4. Struttura di un EA in MQL4

Un EA MQL4 ha una struttura specifica con diverse funzioni chiave:

  • OnInit(): Questa funzione viene chiamata una volta quando l’EA è associato a un grafico. Viene utilizzata per attività di inizializzazione come la configurazione degli handle degli indicatori, la definizione di variabili globali o l’esecuzione di controlli iniziali.
  • OnDeinit(): Questa funzione viene chiamata quando l’EA viene rimosso da un grafico o quando il terminale viene chiuso. Viene utilizzata per attività di pulizia, come il rilascio degli handle degli indicatori.
  • OnTick(): Questa è la funzione principale che viene eseguita su ogni tick di dati sui prezzi in arrivo. Qui risiederà la tua logica di trading.
  • OnTimer() (Opzionale): Se devi eseguire azioni a intervalli regolari (es. ogni minuto, ogni ora), puoi utilizzare questa funzione insieme a SetTimer().
  • OnChartEvent() (Opzionale): Utilizzata per gestire eventi del grafico come clic del mouse o input da tastiera.

5. Programmare la Logica di Trading in OnTick()

Questo è il punto in cui traduci la tua strategia di trading in codice MQL4.

Ottenere i Valori degli Indicatori

// Esempio: Ottenere i valori delle Medie Mobili
double ma_veloce_valore = iMA(Symbol(), Period(), 10, 0, MODE_SMA, PRICE_CLOSE, 1); // Barra precedente
double ma_lenta_valore = iMA(Symbol(), Period(), 50, 0, MODE_SMA, PRICE_CLOSE, 1); // Barra precedente

Controllare le Condizioni di Ingresso

// Esempio: Condizione di Acquisto (MA veloce incrocia sopra la MA lenta)
if (ma_veloce_valore > ma_lenta_valore && ma_veloce_valore[1] <= ma_lenta_valore[1])
{
    // Piazzare ordine di Acquisto
}

// Esempio: Condizione di Vendita (MA veloce incrocia sotto la MA lenta)
if (ma_veloce_valore < ma_lenta_valore && ma_veloce_valore[1] >= ma_lenta_valore[1])
{
    // Piazzare ordine di Vendita
}

Piazzare Ordini

// Esempio: Piazzare un ordine di Acquisto
double lotto_dimensione = 0.01; // Il tuo calcolo delle dimensioni del lotto
double stop_loss = Ask - 50 * Point; // Stop loss di 50 pip
double take_profit = Ask + 100 * Point; // Take profit di 100 pip

int ordine_ticket = OrderSend(Symbol(), OP_BUY, lotto_dimensione, Ask, 3, stop_loss, take_profit, "Ordine Acquisto Mio EA", 0, 0, Green);

Gestione degli Ordini Aperti e Gestione del Rischio

Dovrai utilizzare funzioni per controllare gli ordini esistenti, modificarli (es. per trailing stop) e chiuderli. Implementa anche il tuo calcolo delle dimensioni del lotto e altre regole di rischio.

6. Aggiungere Input (Variabili Esterne)

Gli input consentono di modificare i parametri dell’EA senza ricompilare il codice.

//--- Inputs
extern int PeriodoMAVeloce = 10;
extern int PeriodoMALenta = 50;
extern double DimensioneLotto = 0.01;
extern int StopLossPips = 50;
extern int TakeProfitPips = 100;

7. Gestione degli Errori e Logging

È fondamentale gestire gli errori potenziali e registrare gli eventi per il debug.

  • GetLastError(): Ottiene il codice dell’ultima operazione.
  • Print(): Stampa messaggi nella scheda “Expert” nella finestra del Terminale di MT4.
  • Comment(): Visualizza messaggi direttamente sul grafico.

8. Compilare il Tuo EA

Una volta scritto il codice:

  1. Clicca il pulsante “Compila” in MetaEditor o premi F7.
  2. Controlla la scheda “Errori” in MetaEditor per eventuali errori di sintassi. Correggili prima di procedere.

9. Testare il Tuo EA

Questa è una fase critica per garantire che il tuo EA funzioni come previsto e sia redditizio.

  • Strategy Tester in MT4:
    1. In MT4, vai su “Visualizza” > “Strategy Tester” o premi Ctrl+R.
    2. Seleziona il tuo EA.
    3. Scegli la coppia di valute, il timeframe e l’intervallo di date.
    4. Seleziona la modalità di modellazione:
      • Ogni tick: Più accurato ma più lento.
      • OHLC a 1 minuto: Più veloce, utilizza i dati delle barre a 1 minuto.
      • Solo prezzi di apertura: Il più veloce, utilizza solo i prezzi di apertura delle barre.
    5. Imposta il deposito iniziale e la leva.
    6. Clicca “Avvia”.

10. Forward Testing (Conto Demo)

Dopo un backtesting soddisfacente, installa il tuo EA su un conto demo per almeno alcune settimane o mesi. Questo simula le condizioni di trading reali senza rischiare denaro reale.

11. Trading Live (Piccola Dimensione del Lotto)

Una volta sicuro delle sue prestazioni su un conto demo, puoi iniziare il trading live con una dimensione del lotto molto piccola per minimizzare il rischio. Monitorane da vicino le prestazioni.

12. Ottimizzazione (Opzionale)

Se il tuo EA ha parametri regolabili, puoi utilizzare la funzione di ottimizzazione dello Strategy Tester per trovare le migliori combinazioni di parametri. Tuttavia, fai attenzione all’overfitting.

Trappole Comuni da Evitare

  • Strategia mal definita: Se la tua strategia non è robusta, non lo sarà nemmeno il tuo EA.
  • Mancanza di gestione degli errori: Errori non gestiti possono portare a comportamenti imprevisti.
  • Test insufficienti: Affrettarsi nel trading live senza un adeguato backtesting e forward testing è rischioso.
  • Overfitting: Ottimizzare troppo i parametri per i dati storici.
  • Ignorare spread e slippage: Possono influenzare significativamente la redditività.
  • Non utilizzare magic number: Questo rende difficile gestire gli ordini da più EA o trade manuali.
  • Trading senza stop loss: È una ricetta per il disastro.

Esempio di Struttura di un Semplice EA a Incrocio di Medie Mobili

//+------------------------------------------------------------------+
//| SimpleMACross.mq4 |
//| Copyright 2023, Il Tuo Nome |
//| https://www.tuosito.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, Il Tuo Nome"
#property link "https://www.tuosito.com"
#property version "1.00"
#property strict

//--- Inputs
extern int PeriodoMAVeloce = 10;
extern int PeriodoMALenta = 50;
extern double DimensioneLotto = 0.01;
extern int StopLossPips = 50;
extern int TakeProfitPips = 100;
extern int MagicNumber = 12345; // Identificatore unico per gli ordini di questo EA

//--- Variabili Globali (opzionali)
int handle_ma_veloce;
int handle_ma_lenta;

//+------------------------------------------------------------------+
//| Funzione di inizializzazione dell'experts |
//+------------------------------------------------------------------+
int OnInit()
{
    //--- Crea gli handle degli indicatori
    handle_ma_veloce = iMA(Symbol(), Period(), PeriodoMAVeloce, 0, MODE_SMA, PRICE_CLOSE);
    handle_ma_lenta = iMA(Symbol(), Period(), PeriodoMALenta, 0, MODE_SMA, PRICE_CLOSE);

    //--- Controlla se gli handle sono stati creati con successo
    if (handle_ma_veloce == INVALID_HANDLE || handle_ma_lenta == INVALID_HANDLE)
    {
        Print("Errore nella creazione degli handle degli indicatori. Codice errore: ", GetLastError());
        return(INIT_FAILED);
    }

    //--- Stampa un messaggio nella scheda Experts
    Print("EA SimpleMACross inizializzato con successo.");
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Funzione di deinizializzazione dell'expert |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    //--- Rilascia gli handle degli indicatori
    IndicatorRelease(handle_ma_veloce);
    IndicatorRelease(handle_ma_lenta);
    Print("EA SimpleMACross deinizializzato.");
}

//+------------------------------------------------------------------+
//| Funzione tick expert |
//+------------------------------------------------------------------+
void OnTick()
{
    //--- Ottieni i valori degli indicatori per la barra precedente (indice 1)
    double ma_veloce_prec = 0;
    double ma_lenta_prec = 0;
    double ma_veloce_corr = 0;
    double ma_lenta_corr = 0;

    //--- Copia i dati dal buffer degli indicatori
    if (CopyBuffer(handle_ma_veloce, 0, 1, 1, &ma_veloce_prec) <= 0 ||
        CopyBuffer(handle_ma_lenta, 0, 1, 1, &ma_lenta_prec) <= 0 ||
        CopyBuffer(handle_ma_veloce, 0, 0, 1, &ma_veloce_corr) <= 0 ||
        CopyBuffer(handle_ma_lenta, 0, 0, 1, &ma_lenta_corr) <= 0)
    {
        Print("Errore nella copia dei dati del buffer degli indicatori. Codice errore: ", GetLastError());
        return;
    }

    //--- Controlla gli ordini aperti esistenti di questo EA
    if (IsTradeAllowed() && ContaMieiOrdini() == 0) // Tradare solo se non ci sono altri ordini aperti di questo EA
    {
        //--- Condizione di Acquisto: MA veloce incrocia sopra la MA lenta
        if (ma_veloce_prec <= ma_lenta_prec && ma_veloce_corr > ma_lenta_corr)
        {
            PiazzOrdine(OP_BUY);
        }
        //--- Condizione di Vendita: MA veloce incrocia sotto la MA lenta
        else if (ma_veloce_prec >= ma_lenta_prec && ma_veloce_corr < ma_lenta_corr)
        {
            PiazzOrdine(OP_SELL);
        }
    }
}

//+------------------------------------------------------------------+
//| Funzione per piazzare un ordine |
//+------------------------------------------------------------------+
void PiazzOrdine(int tipo_ordine)
{
    double prezzo_apertura = 0;
    double stop_loss = 0;
    double take_profit = 0;
    string commento = "EA SimpleMACross";

    if (tipo_ordine == OP_BUY)
    {
        prezzo_apertura = Ask;
        stop_loss = prezzo_apertura - StopLossPips * Point;
        take_profit = prezzo_apertura + TakeProfitPips * Point;
    }
    else if (tipo_ordine == OP_SELL)
    {
        prezzo_apertura = Bid;
        stop_loss = prezzo_apertura + StopLossPips * Point;
        take_profit = prezzo_apertura - TakeProfitPips * Point;
    }

    //--- Invia l'ordine
    int ticket = OrderSend(Symbol(), tipo_ordine, DimensioneLotto, prezzo_apertura, 3, stop_loss, take_profit, commento, MagicNumber, 0, Green);
    if (ticket < 0)
    {
        Print("OrderSend fallita. Codice errore: ", GetLastError());
    }
    else
    {
        Print("Ordine piazzato con successo. Ticket: ", ticket);
    }
}

//+------------------------------------------------------------------+
//| Funzione per contare gli ordini aperti per questo EA |
//+------------------------------------------------------------------+
int ContaMieiOrdini()
{
    int conteggio = 0;
    for (int i = OrdersTotal() - 1; i >= 0; i--)
    {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
            {
                conteggio++;
            }
        }
    }
    return conteggio;
}
//+------------------------------------------------------------------+

Questo è un framework di base. Costruire un EA redditizio richiede una strategia solida, una codifica diligente e test estensivi. Buona fortuna!

Youtube Video Downloader
Youtube Audio Downloader
TikTok Content Downloade
Example: https://www.tiktok.com/@khaby.lame/video/7038280908994120966

Leave a Comment

Money Robot