TSD_MT4_MR_Trade_0_24

Download script
Author: Copyright � 2005 Mindaugas
Profit factor:
1.08

Overview of the Trading Logic

This script is an automated trading system designed to manage multiple currency pairs simultaneously. It follows a structured logic that combines trend identification, specific entry filters, and automated risk management. Below is a breakdown of how the system operates in plain language.

1. Market Scanning and Pair Rotation

The script does not look at every market at once. Instead, it cycles through a pre-defined list of currency pairs (such as EURUSD, GBPJPY, etc.). It processes one pair at a time in a continuous loop, ensuring that it monitors each pair systematically without overloading the system.

2. Trend and Directional Analysis

To determine whether to buy or sell, the script looks at two primary "Directional" indicators:

  • MACD/OsMA: The system checks these indicators on a weekly timeframe to see the broad market momentum. If the indicator is rising compared to its previous state, it considers an upward (Buy) bias; if it is falling, it considers a downward (Sell) bias.

3. Entry Filtering

Even if a trend is identified, the script uses a secondary "Filter" to confirm the entry point on shorter timeframes. This acts as a gatekeeper:

  • Williams %R / Force Index: The system checks these values to ensure that price action aligns with the expected trend before allowing an order to be placed. If the filter does not provide a positive signal, no trade will be opened, even if the primary trend is strong.

4. Order Execution (Pending Orders)

Unlike systems that enter trades instantly at market price, this script uses Pending Orders (Buy Stops and Sell Stops).

  • It calculates specific entry points based on the high and low prices of previous candles.
  • Once a signal is confirmed, it places a "waiting" order.
  • The script constantly monitors these pending orders. If the market trend changes before the price hits the order, the script will automatically cancel the request. If the prices shift, it updates the pending orders to stay aligned with the most recent data.

5. Dynamic Risk Management

The script includes several automated safety features:

  • Dynamic Lot Sizing: Depending on the account balance and available margin, the system calculates how much "volume" to trade. It can scale positions up or down based on risk settings.
  • Automatic Stop Loss & Take Profit: Every trade is opened with a pre-calculated exit point. The profit target is intelligently scaled; if the stop loss is wide, the take profit is adjusted to maintain a balanced ratio.
  • Trailing Stop (ATR Based): This is a "moving" safety net. As a trade becomes profitable, the script moves the Stop Loss price forward to lock in gains. It uses a volatility calculation (ATR) and recent candle highs/lows to determine exactly how far behind the price the stop should sit.

6. Real-Time Monitoring

The script provides a visual summary on the trading screen. it displays the current status of all pairs, including their identified directions, current filter values, and trailing stop distances, allowing the user to see what the "brain" of the script is thinking in real-time.

Price Data Components
Series array that contains the highest prices of each barSeries array that contains the lowest prices of each bar
Orders Execution
Checks for the total of open orders
Indicators Used
Larry William percent range indicator
14 Views
0 Downloads
0 Favorites
TSD_MT4_MR_Trade_0_24 
/*-----------------------------+
|			       |
| Shared by www.Aptrafx.com    |
|			       |
+------------------------------*/

//+------------------------------------------------------------------+
//|                                   TSD_MR_Trade_MACD_WPR_0_24.mq4 |
//|                                       Copyright ® 2005 Mindaugas |
//|                                           TSD Trade version 0.24 |
//|                                                                  |
//|             o TSD idea and realization by Bob O'Brien / Barcode  |
//|               o TSD rewritten to MQL4 and enhanced by Mindaugas  |
//|                            o Enhanced comments by Mike aka FxMt  |
//|                    o Trailing Stop based on ATR by Loren Gordon  |
//+------------------------------------------------------------------+
#property copyright "Copyright ® 2005 Mindaugas"

#include <stdlib.mqh>

#define  DIRECTION_MACD 1
#define  DIRECTION_OSMA 2

#define  FILTER_WPR     1
#define  FILTER_FORCE   2

// Whether to put new orders or only track old ones
extern bool NewTrades = true;

// Modify expert's behaviour for backtesting purposes
bool BackTesting = true;

// which indicators to use
int DirectionMode = DIRECTION_OSMA, FilterMode = FILTER_WPR;
// trading periods
int PeriodDirection = PERIOD_W1, PeriodTrade = PERIOD_D1, PeriodTrailing = PERIOD_H4, CandlesTrailing = 3;
// currency pairs to trade
string pairs[] = { "AUDUSD", "EURCHF", "EURGBP", "EURJPY", "EURUSD", "GBPCHF", "GBPJPY", "GBPUSD",
                   "USDCAD", "USDCHF", "USDJPY" };

// parameters for MACD and OsMA
int DirectionFastEMA = 12, DirectionSlowEMA = 26, DirectionSignal = 9;
// parameters for iWPR and iForce indicators
int WilliamsP = 24, WilliamsL = -75, WilliamsH = -25;
int ForceP = 2;

int MagicNumber = 2005072001;

bool TrailingStop = true;
int TakeProfit = 100, Slippage = 5, LotsMax = 50, MM = 0, Leverage = 1, MarginChoke = 200;
double Lots = 0.1;

string TradeSymbol, CommentHeader, CommentsPairs[];
int Pair = -1, SDigits;
datetime LastTrade = 0;
double Spread, SPoint, STS, StopLevel;

//+------------------------------------------------------------------+
int init() {
   string DirInd, FilterInd;

   if ( BackTesting ) { if ( ArrayResize(pairs,1) != 0 )  pairs[0] = Symbol(); }
   else {
      ArrayCopy (CommentsPairs, pairs);
   
      if ( DirectionMode == DIRECTION_MACD )       DirInd = "MACD";
      else if ( DirectionMode == DIRECTION_OSMA )  DirInd = "OsMA";
      
      if ( FilterMode == FILTER_WPR )         FilterInd = "WPR("+WilliamsP+","+WilliamsL+","+WilliamsH+")";
      else if ( FilterMode == FILTER_FORCE )  FilterInd = "Force("+ForceP+")";
      
      CommentHeader = ("\nTSD Trade P("+PeriodDirection+","+PeriodTrade+","+PeriodTrailing+","+CandlesTrailing+")"+
                       " "+DirInd+"("+DirectionFastEMA+","+DirectionSlowEMA+","+DirectionSignal+")"+
                       " "+FilterInd+"\n");
   }
   return(0);
}
//+------------------------------------------------------------------+
int deinit() { return(0); }
//+------------------------------------------------------------------+

int start() {
   int TradesThisSymbol, Direction;
   int i, ticket;
   
   bool okSell, okBuy;
   
   double PriceOpen, Buy_Sl, Buy_Tp, LotMM;
   string ValueComment;
   
   Pair = (Pair+1) % ArraySize(pairs);
   TradeSymbol = pairs[Pair];
   
   TradesThisSymbol = TotalTradesThisSymbol (TradeSymbol);
   
   SPoint    = MarketInfo (TradeSymbol, MODE_POINT);
   Spread    = MarketInfo (TradeSymbol, MODE_SPREAD) * SPoint;
   SDigits   = MarketInfo (TradeSymbol, MODE_DIGITS);
   StopLevel = MarketInfo (TradeSymbol, MODE_STOPLEVEL) * SPoint + 1*SPoint;
   STS = iATR (TradeSymbol, PeriodTrailing, PeriodDirection*3/PeriodTrailing, 1) + Spread + 1*SPoint;
   
   Direction = Direction (TradeSymbol, PeriodDirection, DirectionMode);
   ValueComment = Filter(TradeSymbol, PeriodTrade, FilterMode, okBuy, okSell);
   
   CommentAll (Direction, ValueComment);

   if ( ! IsTradeAllowed() )  return(0);

   ///////////////////////////////////////////////////////////////////////////////
   //  Place new orders and modify pending ones only on the beginning of new bar
   ///////////////////////////////////////////////////////////////////////////////
   if ( NewBar() ) {
      /////////////////////////////////////////////////
      //  Place new order
      /////////////////////////////////////////////////
      if ( TradesThisSymbol < 1 && NewTrades ) {

         LotMM = CalcMM(MM);
         if ( LotMM < 0 )  return(0);

         ticket = 0;

         if ( Direction == 1 && okBuy ) {
            MarkTrade();
	         Print ("TSD BuyStop: ", TradeSymbol, " ", LotMM, " ", CalcOpenBuy(), " ", CalcSlBuy(), " ", CalcTpBuy(),
	                ", ", MarketInfo(TradeSymbol, MODE_ASK), " ", ValueComment);
            ticket = OrderSend (TradeSymbol, OP_BUYSTOP, LotMM, CalcOpenBuy(), Slippage, CalcSlBuy(), CalcTpBuy(),
		                       "TSD BuyStop", MagicNumber, 0);
         } 
		   
         if ( Direction == -1 && okSell ) {
            MarkTrade();
	         Print ("TSD SellStop: ", TradeSymbol, " ", LotMM, " ", CalcOpenSell(), " ", CalcSlSell(), " ", CalcTpSell(),
	                ", ", MarketInfo(TradeSymbol, MODE_BID), " ", ValueComment);
	         ticket = OrderSend (TradeSymbol, OP_SELLSTOP, LotMM, CalcOpenSell(), Slippage, CalcSlSell(), CalcTpSell(),
	                             "TSD SellStop", MagicNumber, 0);
   	   }
 
   	   if ( ticket == -1 )  ReportError ();
	      if ( ticket != 0 )   return(0);
   	} // End of TradesThisSymbol < 1 && NewTrades

      /////////////////////////////////////////////////
      //  Pending Order Management
      /////////////////////////////////////////////////
      for (i = 0; i < OrdersTotal(); i++) {
         if ( OrderSelect (i, SELECT_BY_POS) == false )  continue;
         if ( OrderSymbol() != TradeSymbol || OrderMagicNumber() != MagicNumber)  continue;

         if ( OrderType () == OP_BUYSTOP ) {
            if ( Direction != 1 ) {
               MarkTrade();
               OrderDelete ( OrderTicket() );
               return(0);
            }
            if ( ComparePrices (CalcOpenBuy(), OrderOpenPrice()) != 0 ||
                 ComparePrices (CalcSlBuy(), OrderStopLoss()) != 0 ) {
               MarkTrade();
   	         Print ("TSD modify BuyStop: ", TradeSymbol, " ", CalcOpenBuy(), " ", CalcSlBuy(), " ", CalcTpBuy(),
	                   ", ", MarketInfo(TradeSymbol, MODE_ASK));
     		      OrderModify (OrderTicket(), CalcOpenBuy(), CalcSlBuy(), CalcTpBuy(), 0);
               return(0);
            }
         }

         if ( OrderType () == OP_SELLSTOP ) {
            if ( Direction != -1 ) {
               MarkTrade();
               OrderDelete ( OrderTicket() );
               return(0);
            }
            if ( ComparePrices (CalcOpenSell(), OrderOpenPrice()) != 0 ||
                 ComparePrices (CalcSlSell(), OrderStopLoss()) != 0 ) {
               MarkTrade();
   	         Print ("TSD modify SellStop: ", TradeSymbol, " ", CalcOpenSell(), " ", CalcSlSell(), " ", CalcTpSell(),
	                   ", ", MarketInfo(TradeSymbol, MODE_BID));
     		      OrderModify (OrderTicket(), CalcOpenSell(), CalcSlSell(), CalcTpSell(), 0);
               return(0);
            }
         }
      } // End of Pending Order Management
   } // End of NewBar()

   /////////////////////////////////////////////////
   //  Stop Loss Management
   /////////////////////////////////////////////////
   if ( TrailingStop ) {
      for (i = 0; i < OrdersTotal(); i++) {
         if ( OrderSelect (i, SELECT_BY_POS) == false )  continue;
         if ( OrderSymbol() != TradeSymbol || OrderMagicNumber() != MagicNumber)  continue;
         if ( TrailStop (i, STS) )  return(0);
      }
   }

   return(0);
}
//+------------------------------------------------------------------+
double CalcOpenBuy  () { return (MathMax (iHigh(TradeSymbol, PeriodTrade, 1) + 1*SPoint + Spread,
                                          MarketInfo(TradeSymbol, MODE_ASK) + StopLevel)); }
double CalcOpenSell () { return (MathMin (iLow(TradeSymbol, PeriodTrade, 1) - 1*SPoint,
                                          MarketInfo(TradeSymbol, MODE_BID) - StopLevel)); }
double CalcSlBuy  () { return (iLow (TradeSymbol, PeriodTrade, 1) - 1*SPoint); }
double CalcSlSell () { return (iHigh(TradeSymbol, PeriodTrade, 1) + 1*SPoint + Spread); }
double CalcTpBuy  () {
   double PriceOpen = CalcOpenBuy(), SL = CalcSlBuy();
   if ( TakeProfit == 0 )  return(0);
   return (PriceOpen + MathMax(TakeProfit*SPoint, (PriceOpen - SL)*2));
}
double CalcTpSell () {
   double PriceOpen = CalcOpenSell(), SL = CalcSlSell();
   if ( TakeProfit == 0 )  return(0);
   return (PriceOpen - MathMax(TakeProfit*SPoint, (SL - PriceOpen)*2));
}
//+------------------------------------------------------------------+
bool TrailStop (int i, int TrailingStop) {
   double StopLoss;

   if ( OrderType() == OP_BUY ) {
      if ( MarketInfo (TradeSymbol, MODE_BID) < OrderOpenPrice () )  return(false);
      StopLoss = iLow(TradeSymbol, PeriodTrailing, Lowest (TradeSymbol, PeriodTrailing, MODE_LOW, CandlesTrailing+1, 0)) - 1*SPoint;
      StopLoss = MathMin (MarketInfo (TradeSymbol, MODE_BID)-TrailingStop*SPoint, StopLoss);
      if ( ComparePrices (StopLoss, OrderStopLoss() + 4*SPoint) == 1 ) {
         MarkTrade();
         Print ("TSD trailstop Buy: ", TradeSymbol, " ", StopLoss, ", ", MarketInfo(TradeSymbol, MODE_ASK));
         OrderModify (OrderTicket(), OrderOpenPrice(), StopLoss, OrderTakeProfit(), 0);
         return(true);
      }
   }
   
   if ( OrderType() == OP_SELL ) {
      if ( MarketInfo (TradeSymbol, MODE_ASK) > OrderOpenPrice () )  return(false);
      StopLoss = iHigh(TradeSymbol, PeriodTrailing, Highest (TradeSymbol, PeriodTrailing, MODE_HIGH, CandlesTrailing+1, 0)) + 1*SPoint
                 + Spread;
      StopLoss = MathMax (MarketInfo (TradeSymbol, MODE_ASK)+TrailingStop*SPoint, StopLoss);
      if ( ComparePrices (StopLoss, OrderStopLoss() - 4*SPoint) == -1 ) {
         MarkTrade();
         Print ("TSD trailstop Sell: ", TradeSymbol, " ", StopLoss, ", ", MarketInfo(TradeSymbol, MODE_BID));
         OrderModify (OrderTicket(), OrderOpenPrice(), StopLoss, OrderTakeProfit(), 0);
         return(true);
      }
   }
   
   return(false);
}
//+------------------------------------------------------------------+
int Direction (string TradeSymbol, int PeriodDirection, int Mode) {
   double Previous, Previous2;

   if (Mode == DIRECTION_MACD ) {
	   Previous  = iMACD (TradeSymbol, PeriodDirection, DirectionFastEMA, DirectionSlowEMA, DirectionSignal,
	                      PRICE_CLOSE, MODE_MAIN, 1);
	   Previous2 = iMACD (TradeSymbol, PeriodDirection, DirectionFastEMA, DirectionSlowEMA, DirectionSignal,
	                      PRICE_CLOSE, MODE_MAIN, 2);
	}
	else if (Mode == DIRECTION_OSMA) {
	   Previous  = iOsMA (TradeSymbol, PeriodDirection, DirectionFastEMA, DirectionSlowEMA, DirectionSignal,
	                      PRICE_CLOSE, 1);
	   Previous2 = iOsMA (TradeSymbol, PeriodDirection, DirectionFastEMA, DirectionSlowEMA, DirectionSignal,
	                      PRICE_CLOSE, 2);
	}

   if ( Previous > Previous2 )
      return(1);
   if ( Previous < Previous2 )
      return(-1);
   return(0);
}
//+------------------------------------------------------------------+
string Filter (string TradeSymbol, int PeriodTrade, int Mode, bool &okBuy, bool &okSell) {
   double Value;
   
   okBuy = false; okSell = false;
   
   if (Mode == FILTER_WPR) {
      Value = iWPR(TradeSymbol, PeriodTrade, WilliamsP, 1);
	   if (Value < WilliamsH)  okBuy = true;
   	if (Value > WilliamsL)  okSell = true;
   	return ("iWPR: " + DoubleToStr(Value, 2));
   }
   else if (Mode == FILTER_FORCE) {
      Value = iForce (TradeSymbol, PeriodTrade, ForceP, MODE_EMA, PRICE_CLOSE, 1);
      if (Value < 0)  okBuy = true;
      if (Value > 0)  okSell = true;
   	return ("iForce: " + DoubleToStr(Value, 2));
   }
}
//+------------------------------------------------------------------+
double CalcMM (int MM) {
   double LotMM;

   if ( MM < -1) {
      if ( AccountFreeMargin () < 5 )  return(-1);
		LotMM = MathFloor (AccountBalance()*Leverage/1000);
		if ( LotMM < 1 )  LotMM = 1;
		LotMM = LotMM/100;
   }
	if ( MM == -1 ) {
		if ( AccountFreeMargin() < 50 )  return(-1);
		LotMM = MathFloor(AccountBalance()*Leverage/10000);
		if ( LotMM < 1 )  LotMM = 1;
		LotMM = LotMM/10;
   }
	if ( MM == 0 ) {
		if ( AccountFreeMargin() < MarginChoke ) return(-1); 
		LotMM = Lots;
	}
	if ( MM > 0 ) {
      if ( AccountFreeMargin() < 500 )  return(-1);
		LotMM = MathFloor(AccountBalance()*Leverage/100000);
 		if ( LotMM < 1 )  LotMM = 1;
	}
	if ( LotMM > LotsMax )  LotMM = LotsMax;
	return(LotMM);
}
//+------------------------------------------------------------------+
int TotalTradesThisSymbol (string TradeSymbol) {
   int i, TradesThisSymbol = 0;
   
   for (i = 0; i < OrdersTotal(); i++)
      if ( OrderSelect (i, SELECT_BY_POS) )
         if ( OrderSymbol() == TradeSymbol && OrderMagicNumber() == MagicNumber )
            TradesThisSymbol++;

   return (TradesThisSymbol);
}
//+------------------------------------------------------------------+
void ReportError () {
   int err = GetLastError();
   Print("Error(",err,"): ", ErrorDescription(err));
}
//+------------------------------------------------------------------+
void MarkTrade () {
   LastTrade = CurTime();
}
//+------------------------------------------------------------------+
int ComparePrices (double Price1, double Price2) {
   double p1 = NormalizeDouble (Price1, SDigits), p2 = NormalizeDouble (Price2, SDigits);
   if ( p1 > p2 )  return(1);
   if ( p1 < p2 )  return(-1);
   return(0);
}
//+------------------------------------------------------------------+
bool NewBar () {
   static datetime BarTime = 0;
   static int NewBarPairs = 999;
   int i;
   
   if ( NewBarPairs < ArraySize(pairs)*2 ) {
      NewBarPairs++;
      return (true);
   }

   if ( BarTime != iTime (pairs[i], PeriodTrade, 0 ) ) {
      for (i = 0; i < ArraySize(pairs); i++) 
         if ( BarTime == iTime (pairs[i], PeriodTrade, 0 ) )
            return (false);
      BarTime = iTime (TradeSymbol, PeriodTrade, 0 );
      NewBarPairs = 0;
   }

   return(false);
}
//+------------------------------------------------------------------+
void CommentAll (int Direction, string ValueComment) {
   string Comments = "";
   int i, next = (Pair+1) % ArraySize(pairs);
   
   CommentsPairs[Pair] = TradeSymbol + ": " + " Dir("+Direction+") " + ValueComment + 
                         " TS(" + DoubleToStr (STS/SPoint, 0) + ")";
   CommentsPairs[next] = ">" + CommentsPairs[next];
   for (i=0; i < ArraySize(CommentsPairs); i++)
      Comments = Comments + "\n" + CommentsPairs[i];
   Comment (CommentHeader + Comments);
}

Profitability Reports

PERFORMANCE BY SYMBOL

Expected payoff

Average expected payoff across the available backtests for each symbol.

Positive Negative
24 reports
GBP/CAD Jul 2025 - Sep 2025
2.08
Total Trades 7
Won Trades 4
Lost trades 3
Win Rate 57.14 %
Expected payoff 21.37
Gross Profit 287.47
Gross Loss -137.88
Total Net Profit 149.59
-100%
-50%
0%
50%
100%
View Full Report
GBP/AUD Jul 2025 - Sep 2025
2.03
Total Trades 8
Won Trades 4
Lost trades 4
Win Rate 50.00 %
Expected payoff 17.28
Gross Profit 271.99
Gross Loss -133.75
Total Net Profit 138.24
-100%
-50%
0%
50%
100%
View Full Report
GBP/USD Jul 2025 - Sep 2025
1.82
Total Trades 11
Won Trades 5
Lost trades 6
Win Rate 45.45 %
Expected payoff 11.18
Gross Profit 273.30
Gross Loss -150.30
Total Net Profit 123.00
-100%
-50%
0%
50%
100%
View Full Report
GBP/CAD Jul 2025 - Sep 2025
1.82
Total Trades 7
Won Trades 4
Lost trades 3
Win Rate 57.14 %
Expected payoff 17.84
Gross Profit 278.10
Gross Loss -153.20
Total Net Profit 124.90
-100%
-50%
0%
50%
100%
View Full Report
USD/JPY Jan 2025 - Jul 2025
1.63
Total Trades 28
Won Trades 14
Lost trades 14
Win Rate 50.00 %
Expected payoff 11.53
Gross Profit 837.52
Gross Loss -514.73
Total Net Profit 322.79
-100%
-50%
0%
50%
100%
View Full Report
USD/CHF Jan 2025 - Jul 2025
1.55
Total Trades 24
Won Trades 11
Lost trades 13
Win Rate 45.83 %
Expected payoff 11.04
Gross Profit 743.00
Gross Loss -478.07
Total Net Profit 264.93
-100%
-50%
0%
50%
100%
View Full Report
USD/JPY Jul 2025 - Sep 2025
1.47
Total Trades 15
Won Trades 7
Lost trades 8
Win Rate 46.67 %
Expected payoff 5.57
Gross Profit 263.05
Gross Loss -179.46
Total Net Profit 83.59
-100%
-50%
0%
50%
100%
View Full Report
EUR/USD Jul 2025 - Sep 2025
1.08
Total Trades 15
Won Trades 6
Lost trades 9
Win Rate 40.00 %
Expected payoff 1.36
Gross Profit 274.10
Gross Loss -253.70
Total Net Profit 20.40
-100%
-50%
0%
50%
100%
View Full Report
EUR/USD Jul 2025 - Sep 2025
1.07
Total Trades 15
Won Trades 6
Lost trades 9
Win Rate 40.00 %
Expected payoff 1.17
Gross Profit 273.00
Gross Loss -255.50
Total Net Profit 17.50
-100%
-50%
0%
50%
100%
View Full Report
GBP/USD Oct 2024 - Jan 2025
1.02
Total Trades 9
Won Trades 5
Lost trades 4
Win Rate 55.56 %
Expected payoff 0.51
Gross Profit 196.80
Gross Loss -192.20
Total Net Profit 4.60
-100%
-50%
0%
50%
100%
View Full Report
USD/JPY Jul 2025 - Sep 2025
1.01
Total Trades 15
Won Trades 6
Lost trades 9
Win Rate 40.00 %
Expected payoff 0.15
Gross Profit 237.74
Gross Loss -235.42
Total Net Profit 2.32
-100%
-50%
0%
50%
100%
View Full Report
USD/CAD Jul 2025 - Sep 2025
0.97
Total Trades 14
Won Trades 6
Lost trades 8
Win Rate 42.86 %
Expected payoff -0.37
Gross Profit 165.74
Gross Loss -170.96
Total Net Profit -5.22
-100%
-50%
0%
50%
100%
View Full Report
GBP/CAD Oct 2025 - Feb 2026
0.96
Total Trades 19
Won Trades 9
Lost trades 10
Win Rate 47.37 %
Expected payoff -0.54
Gross Profit 266.82
Gross Loss -277.06
Total Net Profit -10.24
-100%
-50%
0%
50%
100%
View Full Report
NZD/USD Jul 2025 - Sep 2025
0.88
Total Trades 16
Won Trades 9
Lost trades 7
Win Rate 56.25 %
Expected payoff -1.41
Gross Profit 170.50
Gross Loss -193.00
Total Net Profit -22.50
-100%
-50%
0%
50%
100%
View Full Report
USD/CHF Jul 2025 - Sep 2025
0.80
Total Trades 17
Won Trades 5
Lost trades 12
Win Rate 29.41 %
Expected payoff -4.70
Gross Profit 318.99
Gross Loss -398.86
Total Net Profit -79.87
-100%
-50%
0%
50%
100%
View Full Report
USD/CHF Jul 2025 - Sep 2025
0.80
Total Trades 17
Won Trades 5
Lost trades 12
Win Rate 29.41 %
Expected payoff -4.76
Gross Profit 319.51
Gross Loss -400.37
Total Net Profit -80.86
-100%
-50%
0%
50%
100%
View Full Report
GBP/AUD Jan 2025 - Jul 2025
0.78
Total Trades 26
Won Trades 7
Lost trades 19
Win Rate 26.92 %
Expected payoff -7.11
Gross Profit 637.83
Gross Loss -822.78
Total Net Profit -184.95
-100%
-50%
0%
50%
100%
View Full Report
USD/CAD Jan 2025 - Jul 2025
0.74
Total Trades 26
Won Trades 7
Lost trades 19
Win Rate 26.92 %
Expected payoff -5.46
Gross Profit 399.40
Gross Loss -541.28
Total Net Profit -141.88
-100%
-50%
0%
50%
100%
View Full Report
AUD/USD Jul 2025 - Sep 2025
0.73
Total Trades 12
Won Trades 6
Lost trades 6
Win Rate 50.00 %
Expected payoff -4.85
Gross Profit 154.00
Gross Loss -212.20
Total Net Profit -58.20
-100%
-50%
0%
50%
100%
View Full Report
NZD/USD Jan 2025 - Jul 2025
0.71
Total Trades 27
Won Trades 11
Lost trades 16
Win Rate 40.74 %
Expected payoff -5.33
Gross Profit 349.10
Gross Loss -493.00
Total Net Profit -143.90
-100%
-50%
0%
50%
100%
View Full Report
AUD/USD Oct 2025 - Feb 2026
0.65
Total Trades 15
Won Trades 5
Lost trades 10
Win Rate 33.33 %
Expected payoff -6.27
Gross Profit 173.60
Gross Loss -267.70
Total Net Profit -94.10
-100%
-50%
0%
50%
100%
View Full Report
NZD/USD Oct 2024 - Jan 2025
0.58
Total Trades 6
Won Trades 2
Lost trades 4
Win Rate 33.33 %
Expected payoff -8.90
Gross Profit 73.40
Gross Loss -126.80
Total Net Profit -53.40
-100%
-50%
0%
50%
100%
View Full Report
GBP/CAD Jan 2025 - Jul 2025
0.58
Total Trades 23
Won Trades 8
Lost trades 15
Win Rate 34.78 %
Expected payoff -12.09
Gross Profit 383.67
Gross Loss -661.68
Total Net Profit -278.01
-100%
-50%
0%
50%
100%
View Full Report
GBP/AUD Oct 2025 - Feb 2026
0.20
Total Trades 17
Won Trades 4
Lost trades 13
Win Rate 23.53 %
Expected payoff -20.62
Gross Profit 87.23
Gross Loss -437.77
Total Net Profit -350.54
-100%
-50%
0%
50%
100%
View Full Report

Similar scripts

TSD_MT4_MR_Trade_0_5F25

TSD_MT4_MR_Trade_0_23

TSD v.32 IBFX mini

TSD_MT4_MR_Trade_0_32

TSD_MT4_MR_Trade_0_361

TSD_MT4_MR_Trade_0_25

TSD MT4 MR Trade 0 36

TSD_MT4_MR_Trade_0_34b

TSD_MT4_MR_Trade_0_30

TSD_MT4_MR_Trade_0_34

TSD_MT4_MR_Trade_0_33

Comments