FreelanceSecciones

VEE STRATEGY ROBOT

MQL5 Asesores Expertos Lo demás Depuración de robots/indicadores

Tarea técnica

//+------------------------------------------------------------------+
//| M5 Trend Pullback EA |
//| Exness / MT5 |
//| Forex + XAUUSD |
//| Risk: 0.5% per trade |
//+------------------------------------------------------------------+
#property strict
#property version "1.00"
#property description "M5 EMA50/EMA200 + RSI + ATR Trend Pullback EA"

#include <Trade/Trade.mqh>

CTrade trade;

//==================================================================
// INPUTS
//==================================================================

//--- General
input ulong MagicNumber = 20260922;
input ENUM_TIMEFRAMES TradingTF = PERIOD_M5;

//--- Risk
input double RiskPercent = 0.50;
input double RewardRiskRatio = 2.00;
input double ATR_SL_Multiplier = 1.50;

//--- Indicators
input int FastEMA = 50;
input int SlowEMA = 200;
input int RSIPeriod = 14;
input int ATRPeriod = 14;

//--- Entry filters
input double RSI_Buy_Level = 50.0;
input double RSI_Sell_Level = 50.0;
input double PullbackToleranceATR = 0.50;

//--- Spread
input double MaxSpreadPoints = 40;

//--- Daily protection
input double MaxDailyLossPercent = 2.0;
input int MaxConsecutiveLosses = 3;

//--- Break-even
input bool UseBreakEven = true;
input double BreakEvenAtR = 1.0;
input double BreakEvenOffsetPoints = 5;

//--- Trading session
input bool UseSessionFilter = true;
input int StartHour = 7;
input int EndHour = 19;

//--- Execution
input int SlippagePoints = 20;

//==================================================================
// GLOBAL VARIABLES
//==================================================================

int emaFastHandle = INVALID_HANDLE;
int emaSlowHandle = INVALID_HANDLE;
int rsiHandle = INVALID_HANDLE;
int atrHandle = INVALID_HANDLE;

datetime lastBarTime = 0;

double dayStartEquity = 0.0;
int consecutiveLosses = 0;
int currentDay = -1;

//==================================================================
// INITIALIZATION
//==================================================================

int OnInit()
{
   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetDeviationInPoints(SlippagePoints);

   emaFastHandle = iMA(
      _Symbol,
      TradingTF,
      FastEMA,
      0,
      MODE_EMA,
      PRICE_CLOSE
   );

   emaSlowHandle = iMA(
      _Symbol,
      TradingTF,
      SlowEMA,
      0,
      MODE_EMA,
      PRICE_CLOSE
   );

   rsiHandle = iRSI(
      _Symbol,
      TradingTF,
      RSIPeriod,
      PRICE_CLOSE
   );

   atrHandle = iATR(
      _Symbol,
      TradingTF,
      ATRPeriod
   );

   if(emaFastHandle == INVALID_HANDLE ||
      emaSlowHandle == INVALID_HANDLE ||
      rsiHandle == INVALID_HANDLE ||
      atrHandle == INVALID_HANDLE)
   {
      Print("ERROR: Failed to create indicator handles.");
      return(INIT_FAILED);
   }

   ResetDailyStats();

   Print("M5 Trend Pullback EA initialized.");
   Print("Symbol: ", _Symbol);
   Print("Risk: ", DoubleToString(RiskPercent, 2), "%");

   return(INIT_SUCCEEDED);
}

//==================================================================
// DEINITIALIZATION
//==================================================================

void OnDeinit(const int reason)
{
   if(emaFastHandle != INVALID_HANDLE)
      IndicatorRelease(emaFastHandle);

   if(emaSlowHandle != INVALID_HANDLE)
      IndicatorRelease(emaSlowHandle);

   if(rsiHandle != INVALID_HANDLE)
      IndicatorRelease(rsiHandle);

   if(atrHandle != INVALID_HANDLE)
      IndicatorRelease(atrHandle);
}

//==================================================================
// MAIN
//==================================================================

void OnTick()
{
   UpdateDailyStats();

   ManageBreakEven();

   if(!IsNewBar())
      return;

   if(!TradingAllowed())
      return;

   if(HasOpenPosition())
      return;

   if(!SpreadIsAcceptable())
      return;

   if(!SessionAllowed())
      return;

   CheckForEntry();
}

//==================================================================
// NEW BAR DETECTION
//==================================================================

bool IsNewBar()
{
   datetime currentBar = iTime(_Symbol, TradingTF, 0);

   if(currentBar == 0)
      return false;

   if(currentBar != lastBarTime)
   {
      lastBarTime = currentBar;
      return true;
   }

   return false;
}

//==================================================================
// ENTRY LOGIC
//==================================================================

void CheckForEntry()
{
   double emaFast[3];
   double emaSlow[3];
   double rsi[3];
   double atr[3];
   double closePrice[3];

   ArraySetAsSeries(emaFast, true);
   ArraySetAsSeries(emaSlow, true);
   ArraySetAsSeries(rsi, true);
   ArraySetAsSeries(atr, true);
   ArraySetAsSeries(closePrice, true);

   if(CopyBuffer(emaFastHandle, 0, 0, 3, emaFast) < 3)
      return;

   if(CopyBuffer(emaSlowHandle, 0, 0, 3, emaSlow) < 3)
      return;

   if(CopyBuffer(rsiHandle, 0, 0, 3, rsi) < 3)
      return;

   if(CopyBuffer(atrHandle, 0, 0, 3, atr) < 3)
      return;

   if(CopyClose(_Symbol, TradingTF, 0, 3, closePrice) < 3)
      return;

   // Use the LAST CLOSED candle: index 1
   double price = closePrice[1];
   double previousPrice = closePrice[2];

   double currentATR = atr[1];

   if(currentATR <= 0)
      return;

   //==============================================================
   // BUY CONDITIONS
   //==============================================================

   bool bullishTrend =
      price > emaSlow[1] &&
      emaFast[1] > emaSlow[1];

   bool pullbackBuy =
      price <= emaFast[1] + (currentATR * PullbackToleranceATR);

   bool rsiBuy =
      rsi[2] <= RSI_Buy_Level &&
      rsi[1] > RSI_Buy_Level;

   bool bullishCandle =
      price > previousPrice;

   if(bullishTrend &&
      pullbackBuy &&
      rsiBuy &&
      bullishCandle)
   {
      OpenBuy(currentATR);
      return;
   }

   //==============================================================
   // SELL CONDITIONS
   //==============================================================

   bool bearishTrend =
      price < emaSlow[1] &&
      emaFast[1] < emaSlow[1];

   bool pullbackSell =
      price >= emaFast[1] - (currentATR * PullbackToleranceATR);

   bool rsiSell =
      rsi[2] >= RSI_Sell_Level &&
      rsi[1] < RSI_Sell_Level;

   bool bearishCandle =
      price < previousPrice;

   if(bearishTrend &&
      pullbackSell &&
      rsiSell &&
      bearishCandle)
   {
      OpenSell(currentATR);
      return;
   }
}

//==================================================================
// BUY
//==================================================================

void OpenBuy(double atr)
{
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   if(ask <= 0)
      return;

   double stopDistance = atr * ATR_SL_Multiplier;

   double sl = ask - stopDistance;
   double tp = ask + (stopDistance * RewardRiskRatio);

   AdjustStopsForBroker(ORDER_TYPE_BUY, ask, sl, tp);

   double lot = CalculateLotSize(
      ORDER_TYPE_BUY,
      ask,
      sl
   );

   if(lot <= 0)
      return;

   bool result = trade.Buy(
      lot,
      _Symbol,
      ask,
      sl,
      tp,
      "M5 Trend Pullback BUY"
   );

   if(result)
   {
      Print(
         "BUY opened | Lot=",
         DoubleToString(lot, 2),
         " | SL=",
         DoubleToString(sl, _Digits),
         " | TP=",
         DoubleToString(tp, _Digits)
      );
   }
   else
   {
      Print("BUY failed. Error: ", GetLastError());
   }
}

//==================================================================
// SELL
//==================================================================

void OpenSell(double atr)
{
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

   if(bid <= 0)
      return;

   double stopDistance = atr * ATR_SL_Multiplier;

   double sl = bid + stopDistance;
   double tp = bid - (stopDistance * RewardRiskRatio);

   AdjustStopsForBroker(ORDER_TYPE_SELL, bid, sl, tp);

   double lot = CalculateLotSize(
      ORDER_TYPE_SELL,
      bid,
      sl
   );

   if(lot <= 0)
      return;

   bool result = trade.Sell(
      lot,
      _Symbol,
      bid,
      sl,
      tp,
      "M5 Trend Pullback SELL"
   );

   if(result)
   {
      Print(
         "SELL opened | Lot=",
         DoubleToString(lot, 2),
         " | SL=",
         DoubleToString(sl, _Digits),
         " | TP=",
         DoubleToString(tp, _Digits)
      );
   }
   else
   {
      Print("SELL failed. Error: ", GetLastError());
   }
}

//==================================================================
// LOT SIZE CALCULATION
//==================================================================

double CalculateLotSize(
   ENUM_ORDER_TYPE orderType,
   double entryPrice,
   double stopLoss
)
{
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);

   double riskMoney =
      equity * (RiskPercent / 100.0);

   if(riskMoney <= 0)
      return 0;

   double tickSize =
      SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);

   double tickValue =
      SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);

   if(tickSize <= 0 || tickValue <= 0)
      return 0;

   double priceDistance =
      MathAbs(entryPrice - stopLoss);

   double ticks =
      priceDistance / tickSize;

   double lossPerLot =
      ticks * tickValue;

   if(lossPerLot <= 0)
      return 0;

   double lot =
      riskMoney / lossPerLot;

   return NormalizeVolume(lot);
}

//==================================================================
// VOLUME NORMALIZATION
//==================================================================

double NormalizeVolume(double volume)
{
   double minLot =
      SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);

   double maxLot =
      SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);

   double lotStep =
      SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);

   if(lotStep <= 0)
      return 0;

   volume =
      MathFloor(volume / lotStep) * lotStep;

   volume =
      MathMax(volume, minLot);

   volume =
      MathMin(volume, maxLot);

   int digits = 2;

   if(lotStep == 0.1)
      digits = 1;

   if(lotStep == 0.01)
      digits = 2;

   if(lotStep == 0.001)
      digits = 3;

   return NormalizeDouble(volume, digits);
}

//==================================================================
// OPEN POSITION CHECK
//==================================================================

bool HasOpenPosition()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket =
         PositionGetTicket(i);

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      string symbol =
         PositionGetString(POSITION_SYMBOL);

      long magic =
         PositionGetInteger(POSITION_MAGIC);

      if(symbol == _Symbol &&
         magic == (long)MagicNumber)
      {
         return true;
      }
   }

   return false;
}

//==================================================================
// SPREAD FILTER
//==================================================================

bool SpreadIsAcceptable()
{
   double ask =
      SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   double bid =
      SymbolInfoDouble(_Symbol, SYMBOL_BID);

   if(ask <= 0 || bid <= 0)
      return false;

   double spreadPoints =
      (ask - bid) / _Point;

   if(spreadPoints > MaxSpreadPoints)
   {
      Print(
         "Spread too high: ",
         DoubleToString(spreadPoints, 1),
         " points"
      );

      return false;
   }

   return true;
}

//==================================================================
// SESSION FILTER
//==================================================================

bool SessionAllowed()
{
   if(!UseSessionFilter)
      return true;

   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);

   if(StartHour < EndHour)
   {
      if(dt.hour >= StartHour &&
         dt.hour < EndHour)
         return true;

      return false;
   }

   // Handles sessions crossing midnight
   if(dt.hour >= StartHour ||
      dt.hour < EndHour)
      return true;

   return false;
}

//==================================================================
// DAILY PROTECTION
//==================================================================

bool TradingAllowed()
{
   if(dayStartEquity <= 0)
      return false;

   double equity =
      AccountInfoDouble(ACCOUNT_EQUITY);

   double dailyLossPercent =
      ((dayStartEquity - equity) /
       dayStartEquity) * 100.0;

   if(dailyLossPercent >= MaxDailyLossPercent)
   {
      Print("Daily loss limit reached.");

      return false;
   }

   if(consecutiveLosses >= MaxConsecutiveLosses)
   {
      Print("Maximum consecutive losses reached.");

      return false;
   }

   return true;
}

//==================================================================
// DAILY STATS
//==================================================================

void ResetDailyStats()
{
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);

   currentDay = dt.day;

   dayStartEquity =
      AccountInfoDouble(ACCOUNT_EQUITY);

   consecutiveLosses = 0;
}

void UpdateDailyStats()
{
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);

   if(dt.day != currentDay)
   {
      ResetDailyStats();
   }
}

//==================================================================
// BREAK-EVEN
//==================================================================

void ManageBreakEven()
{
   if(!UseBreakEven)
      return;

   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket =
         PositionGetTicket(i);

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      string symbol =
         PositionGetString(POSITION_SYMBOL);

      long magic =
         PositionGetInteger(POSITION_MAGIC);

      if(symbol != _Symbol ||
         magic != (long)MagicNumber)
         continue;

      long type =
         PositionGetInteger(POSITION_TYPE);

      double openPrice =
         PositionGetDouble(POSITION_PRICE_OPEN);

      double currentSL =
         PositionGetDouble(POSITION_SL);

      double currentTP =
         PositionGetDouble(POSITION_TP);

      double currentPrice;

      if(type == POSITION_TYPE_BUY)
         currentPrice =
            SymbolInfoDouble(_Symbol, SYMBOL_BID);
      else
         currentPrice =
            SymbolInfoDouble(_Symbol, SYMBOL_ASK);

      if(currentPrice <= 0)
         continue;

      double riskDistance =
         MathAbs(openPrice - currentSL);

      if(riskDistance <= 0)
         continue;

      if(type == POSITION_TYPE_BUY)
      {
         double profitDistance =
            currentPrice - openPrice;

         if(profitDistance >=
            riskDistance * BreakEvenAtR)
         {
            double newSL =
               openPrice +
               BreakEvenOffsetPoints * _Point;

            if(currentSL < newSL)
            {
               trade.PositionModify(
                  ticket,
                  NormalizeDouble(newSL, _Digits),
                  currentTP
               );
            }
         }
      }

      if(type == POSITION_TYPE_SELL)
      {
         double profitDistance =
            openPrice - currentPrice;

         if(profitDistance >=
            riskDistance * BreakEvenAtR)
         {
            double newSL =
               openPrice -
               BreakEvenOffsetPoints * _Point;

            if(currentSL == 0 ||
               currentSL > newSL)
            {
               trade.PositionModify(
                  ticket,
                  NormalizeDouble(newSL, _Digits),
                  currentTP
               );
            }
         }
      }
   }
}

//==================================================================
// BROKER STOP LEVEL ADJUSTMENT
//==================================================================

void AdjustStopsForBroker(
   ENUM_ORDER_TYPE orderType,
   double entry,
   double &sl,
   double &tp
)
{
   long stopLevel =
      SymbolInfoInteger(
         _Symbol,
         SYMBOL_TRADE_STOPS_LEVEL
      );

   double minimumDistance =
      stopLevel * _Point;

   if(orderType == ORDER_TYPE_BUY)
   {
      if(entry - sl < minimumDistance)
         sl = entry - minimumDistance;

      if(tp - entry < minimumDistance)
         tp = entry + minimumDistance;
   }

   if(orderType == ORDER_TYPE_SELL)
   {
      if(sl - entry < minimumDistance)
         sl = entry + minimumDistance;

      if(entry - tp < minimumDistance)
         tp = entry - minimumDistance;
   }

   sl = NormalizeDouble(sl, _Digits);
   tp = NormalizeDouble(tp, _Digits);
}

//==================================================================
// TRADE TRANSACTION
//==================================================================

void OnTradeTransaction(
   const MqlTradeTransaction &trans,
   const MqlTradeRequest &request,
   const MqlTradeResult &result
)
{
   if(trans.type != TRADE_TRANSACTION_DEAL_ADD)
      return;

   ulong dealTicket = trans.deal;

   if(dealTicket == 0)
      return;

   if(!HistoryDealSelect(dealTicket))
      return;

   long magic =
      HistoryDealGetInteger(
         dealTicket,
         DEAL_MAGIC
      );

   if(magic != (long)MagicNumber)
      return;

   long entryType =
      HistoryDealGetInteger(
         dealTicket,
         DEAL_ENTRY
      );

   if(entryType != DEAL_ENTRY_OUT)
      return;

   double profit =
      HistoryDealGetDouble(
         dealTicket,
         DEAL_PROFIT
      );

   double commission =
      HistoryDealGetDouble(
         dealTicket,
         DEAL_COMMISSION
      );

   double swap =
      HistoryDealGetDouble(
         dealTicket,
         DEAL_SWAP
      );

   double netResult =
      profit + commission + swap;

   if(netResult < 0)
   {
      consecutiveLosses++;

      Print(
         "Losing trade. Consecutive losses: ",
         consecutiveLosses
      );
   }
   else if(netResult > 0)
   {
      consecutiveLosses = 0;

      Print(
         "Winning trade. Consecutive losses reset."
      );
   }
}
//+------------------------------------------------------------------+

Han respondido

1
Desarrollador 1
Evaluación
(406)
Proyectos
524
24%
Arbitraje
62
58% / 24%
Caducado
60
11%
Trabajando
2
Desarrollador 2
Evaluación
(2)
Proyectos
4
0%
Arbitraje
0
Caducado
0
Libre
3
Desarrollador 3
Evaluación
(24)
Proyectos
34
41%
Arbitraje
9
22% / 33%
Caducado
5
15%
Ocupado
Ha publicado: 8 artículos, 35 ejemplos
4
Desarrollador 4
Evaluación
(2)
Proyectos
2
0%
Arbitraje
1
0% / 100%
Caducado
0
Libre
5
Desarrollador 5
Evaluación
(565)
Proyectos
862
61%
Arbitraje
33
27% / 45%
Caducado
24
3%
Libre
Ha publicado: 1 ejemplo
6
Desarrollador 6
Evaluación
(258)
Proyectos
269
29%
Arbitraje
2
50% / 0%
Caducado
3
1%
Trabaja
Ha publicado: 2 ejemplos
7
Desarrollador 7
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
8
Desarrollador 8
Evaluación
(266)
Proyectos
316
74%
Arbitraje
17
71% / 0%
Caducado
6
2%
Trabaja
9
Desarrollador 9
Evaluación
(10)
Proyectos
12
33%
Arbitraje
0
Caducado
2
17%
Trabaja
Ha publicado: 1 ejemplo
10
Desarrollador 10
Evaluación
(64)
Proyectos
145
46%
Arbitraje
21
38% / 24%
Caducado
32
22%
Libre
11
Desarrollador 11
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
12
Desarrollador 12
Evaluación
Proyectos
1
0%
Arbitraje
0
Caducado
0
Libre
13
Desarrollador 13
Evaluación
(14)
Proyectos
23
35%
Arbitraje
0
Caducado
2
9%
Libre
14
Desarrollador 14
Evaluación
(2)
Proyectos
3
33%
Arbitraje
0
Caducado
2
67%
Trabaja
15
Desarrollador 15
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
16
Desarrollador 16
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
17
Desarrollador 17
Evaluación
(4)
Proyectos
9
56%
Arbitraje
0
Caducado
2
22%
Trabajando
Ha publicado: 6 ejemplos
18
Desarrollador 18
Evaluación
(6)
Proyectos
8
38%
Arbitraje
1
0% / 100%
Caducado
0
Libre
19
Desarrollador 19
Evaluación
Proyectos
1
0%
Arbitraje
0
Caducado
0
Libre
Ha publicado: 11 ejemplos
20
Desarrollador 20
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
21
Desarrollador 21
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
22
Desarrollador 22
Evaluación
(1)
Proyectos
1
0%
Arbitraje
0
Caducado
0
Libre
Ha publicado: 4 ejemplos
23
Desarrollador 23
Evaluación
(10)
Proyectos
14
43%
Arbitraje
0
Caducado
3
21%
Libre
24
Desarrollador 24
Evaluación
(6)
Proyectos
6
67%
Arbitraje
0
Caducado
0
Libre
25
Desarrollador 25
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
26
Desarrollador 26
Evaluación
(12)
Proyectos
12
17%
Arbitraje
2
0% / 50%
Caducado
1
8%
Libre
27
Desarrollador 27
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
28
Desarrollador 28
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
29
Desarrollador 29
Evaluación
(1)
Proyectos
1
0%
Arbitraje
0
Caducado
0
Libre
30
Desarrollador 30
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
31
Desarrollador 31
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
32
Desarrollador 32
Evaluación
(574)
Proyectos
945
47%
Arbitraje
309
58% / 27%
Caducado
125
13%
Libre
33
Desarrollador 33
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
Ha publicado: 1 ejemplo
34
Desarrollador 34
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
Solicitudes similares
Metafix 50 - 200 USD
Here is a professional specification you can send directly to your developer. # Project Requirements Specification: MetaTrader 5 Trading Robot Development ### 1. Project Overview I want to develop an automated Forex trading robot (Expert Advisor) for MetaTrader 5 (MT5). The robot should analyse the financial markets, identify trading opportunities, and execute trades automatically based on predefined strategies. ###
FTMO-Compliant TradingView Webhook Multi-Timeframe & Dual-Position EA for XAUUSD (MT5) 150 - 200 USD
Overview: Build an MT5 Expert Advisor that receives webhook alerts from TradingView (RayAlgo indicator) across three timeframes ( H1, M5, M1 ) for XAUUSD and executes a dual-position strategy when all three conditions align, including strict FTMO server-request limits and automated pre-market-close trade closures. 1. Webhook Receiver & Multi-Timeframe State Logic: H1 Bias State: Updates to BULLISH or BEARISH upon
Experienced Trading Software Developer Needed for Long-Term Collaboration 50 - 200 USD
I am looking for an experienced trading software developer interested in building a long-term working relationship. Im a professional Trader, Coach and Mentor, I work with traders and Student who require customized trading solutions, including automated trading bots, Expert Advisors, custom indicators, trading strategies and other algorithmic trading tools. I am looking for a technically skilled developer who can
Salman serhal 30 - 100 USD
MT5 ICT XAUUSD Sell-Only Trading Robot with Fibonacci Confirmation I am looking for an experienced MQL5 developer to create a custom Expert Advisor (EA) for MetaTrader 5, specifically for trading Gold (XAUUSD). 1. Trading Strategy The robot must use the ICT trading methodology and focus on SELL trades only. The strategy should include: * Identify important resistance and premium zones. * Use Fibonacci retracement
MT5 Quantitative Strategy Validation, Deep Backtesting & Walk-Forward Optimization 100 - 200 USD
Objective: I am looking for an experienced MQL5 quantitative developer to code an Expert Advisor (EA) from scratch based on a fully defined, rule-based strategy, and then rigorously validate, optimize, and stress-test it before I deploy it on a live VPS environment. Note: The exact mathematical rules, indicator names, and chart screenshots will be shared privately with shortlisted candidates. Strategy Overview
Automated ES trading bot for tradovate or ninjatrader 50 - 300 USD
JOB SPECIFICATION: Fully Automated ES/MES 5-Minute NY Opening Range Breakout EA 1. Project objective I am looking for an experienced trading algo developer to build a fully automated trading bot (EA) based on my specific 5-minute New York Opening Range Breakout strategy. The EA must identify setups, confirm breakouts, identify retests, confirm continuation, execute trades, calculate position size, place stop-loss and
Profitable Smart Auto trade EA 30 - 80 USD
Custom MT5 Expert Advisor – Developer Specification 1. Project Objective Develop a fully autonomous, custom MetaTrader 5 Expert Advisor (EA) using native MQL5. The EA must independently analyze financial markets, generate its own trading signals, evaluate opportunities, execute trades, and manage open positions without requiring an external signal provider, another trading bot, or manual intervention. The EA must
Create a Combined Indicator from 3 EX4 Indicators + Fully Automatic Trading EA (MT4) 100+ USD
​​ Title: ​Create a Combined Indicator from 3 EX4 Indicators + Fully Automatic Trading EA (MT4) ​ Description: ​Hello, ​I need an experienced MQL4 developer to build a custom trading system based on 3 existing .ex4 indicators. ​ Project Requirements: ​ Combined Custom Indicator: ​Read and merge signals from 3 specified .ex4 indicators via buffer reading (iCustom). ​Generate a consolidated BUY or SELL arrow/signal
نازدك 30+ USD
Specify your Requirements Specification here point by point. Try to describe your requirements briefly and clearly, so that your potential developer is able to correctly assess its complexity and cost, as well as the required execution time. A bad or too generic description will result in your order being ignored, or you will spend a lot of time negotiating the details with each applicant. Remember: It is better to
Development of MT5 Expert Advisor (EA) – DSTR Novaa Strategy Replica with MQ5 Source Code 30 - 100 USD
I am looking for an experienced MQL5 developer to recreate my existing MT5 Expert Advisor (DSTR Novaa). I have the original compiled EX5 file, Vantage MT5 live trading history and original Strategy Tester report. Required Trading Logic: EMA Period: 3. BUY when price crosses below EMA 3. SELL when price crosses above EMA 3. Starting Lot: 0.01 (configurable). Martingale Multiplier: 2.0. Maximum Martingale Cycle: 9

Información sobre el proyecto

Presupuesto
30 - 200 USD
Plazo límite de ejecución
de 10 a 60 día(s)