FreelanceKategorien

VEE STRATEGY ROBOT

MQL5 Experten Sonstiges Debugging eines Roboters/Indikators

Spezifikation

//+------------------------------------------------------------------+
//| 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."
      );
   }
}
//+------------------------------------------------------------------+

Bewerbungen

1
Entwickler 1
Bewertung
(406)
Projekte
524
24%
Schlichtung
62
58% / 24%
Frist nicht eingehalten
60
11%
Beschäftigt
2
Entwickler 2
Bewertung
(2)
Projekte
4
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
3
Entwickler 3
Bewertung
(24)
Projekte
34
41%
Schlichtung
9
22% / 33%
Frist nicht eingehalten
5
15%
Überlastet
Veröffentlicht: 8 Artikel, 35 Beispiele
4
Entwickler 4
Bewertung
(2)
Projekte
2
0%
Schlichtung
1
0% / 100%
Frist nicht eingehalten
0
Frei
5
Entwickler 5
Bewertung
(565)
Projekte
862
61%
Schlichtung
33
27% / 45%
Frist nicht eingehalten
24
3%
Frei
Veröffentlicht: 1 Beispiel
6
Entwickler 6
Bewertung
(258)
Projekte
269
29%
Schlichtung
2
50% / 0%
Frist nicht eingehalten
3
1%
Arbeitet
Veröffentlicht: 2 Beispiele
7
Entwickler 7
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
8
Entwickler 8
Bewertung
(266)
Projekte
316
74%
Schlichtung
17
71% / 0%
Frist nicht eingehalten
6
2%
Arbeitet
9
Entwickler 9
Bewertung
(10)
Projekte
12
33%
Schlichtung
0
Frist nicht eingehalten
2
17%
Arbeitet
Veröffentlicht: 1 Beispiel
10
Entwickler 10
Bewertung
(64)
Projekte
145
46%
Schlichtung
21
38% / 24%
Frist nicht eingehalten
32
22%
Frei
11
Entwickler 11
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
12
Entwickler 12
Bewertung
Projekte
1
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
13
Entwickler 13
Bewertung
(14)
Projekte
23
35%
Schlichtung
0
Frist nicht eingehalten
2
9%
Frei
14
Entwickler 14
Bewertung
(2)
Projekte
3
33%
Schlichtung
0
Frist nicht eingehalten
2
67%
Arbeitet
15
Entwickler 15
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
16
Entwickler 16
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
17
Entwickler 17
Bewertung
(4)
Projekte
9
56%
Schlichtung
0
Frist nicht eingehalten
2
22%
Beschäftigt
Veröffentlicht: 6 Beispiele
18
Entwickler 18
Bewertung
(6)
Projekte
8
38%
Schlichtung
1
0% / 100%
Frist nicht eingehalten
0
Frei
19
Entwickler 19
Bewertung
Projekte
1
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 11 Beispiele
20
Entwickler 20
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
21
Entwickler 21
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
22
Entwickler 22
Bewertung
(1)
Projekte
1
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 4 Beispiele
23
Entwickler 23
Bewertung
(10)
Projekte
14
43%
Schlichtung
0
Frist nicht eingehalten
3
21%
Frei
24
Entwickler 24
Bewertung
(6)
Projekte
6
67%
Schlichtung
0
Frist nicht eingehalten
0
Frei
25
Entwickler 25
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
26
Entwickler 26
Bewertung
(12)
Projekte
12
17%
Schlichtung
2
0% / 50%
Frist nicht eingehalten
1
8%
Frei
27
Entwickler 27
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
28
Entwickler 28
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
29
Entwickler 29
Bewertung
(1)
Projekte
1
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
30
Entwickler 30
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
31
Entwickler 31
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
32
Entwickler 32
Bewertung
(574)
Projekte
945
47%
Schlichtung
309
58% / 27%
Frist nicht eingehalten
125
13%
Frei
33
Entwickler 33
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 1 Beispiel
34
Entwickler 34
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Ähnliche Aufträge
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

Projektdetails

Budget
30 - 200 USD
Ausführungsfristen
von 10 bis 60 Tag(e)