Unlimited profits from advanced Trailing stop strategy

A trailing stop strategy is a technique used in forex trading to manage a trade's stop loss level as the price moves in a favorable direction. It aims to lock in profits by allowing the stop loss level to adjust dynamically, following the price as it moves in the trader's favor. This can help traders capture more gains while minimizing the risk of losing accumulated profits if the market reverses.

Here's how a trailing stop strategy works in forex trading:

Initial Entry: The trader enters a trade (either a buy or sell position) based on their trading strategy and analysis.
Setting Trailing Stop: Instead of using a fixed stop loss level, the trader sets a trailing stop, which is a certain distance away from the current price. For example, if the trailing stop is set at 30 pips for a buy trade, and the entry price was 1.1000, the initial stop loss would be at 1.0970 (1.1000 - 0.0030).
Price Movement: As the price moves in the trader's favor, the trailing stop follows it. If the price moves 30 pips in the trader's favor, the trailing stop would be adjusted to 1.1000 (current price) - 0.0030 = 1.0970.
Locking in Profits: If the price continues to move in the trader's favor, the trailing stop keeps adjusting and effectively locks in profits. This means that if the price reverses, the trade will be closed out at the new trailing stop level, which is better than the initial stop loss level.
Price Reversal: If the price reverses and moves against the trader, the trailing stop remains unchanged until it's hit. This means the trade can close with profits even if the market reverses, but it also means giving up some potential profit if the price retraces only temporarily.
Exiting the Trade: The trade is eventually closed when either the trailing stop is hit due to a price reversal, or the price reaches the trader's take profit level, which is a predefined level of profit the trader aims to achieve.

Trailing stop strategies can be effective in trending markets where the price tends to move in one direction for a prolonged period. However, in choppy or sideways markets, a trailing stop might lead to premature exits due to small price fluctuations.

It's important to note that there's no one-size-fits-all trailing stop distance. Traders should adjust the trailing stop based on the volatility of the currency pair being traded and their individual risk tolerance.

Before implementing a trailing stop strategy or any trading strategy, it's crucial to thoroughly backtest it, understand its strengths and weaknesses, and practice it on a demo account to gain familiarity with its behavior in different market conditions.

Explaining the code

The code provided is a Pine Script snippet for implementing a trailing stop strategy in TradingView. Let's go through the code step by step to understand its functionality:

The code starts by setting the version and initiating the strategy using the strategy() function.

The length variable is defined to specify the length parameter for calculating momentum.

The momentum() function calculates the momentum of a given series using the specified length. It subtracts the current value from the value length periods ago.

Two momentum variables, mom0 and mom1, are calculated using the momentum() function on the closing price.

The code defines two input variables, tsact and ts, to set the trailing stop activation and the trailing stop distance respectively. These inputs are specified as percentages relative to the position's average price.

The code checks whether the current position is long or short using the strategy.position_size variable.

If the position is long:

If the current high surpasses the position's average price plus the specified percentage (tsact), the trailing stop is activated.

If the trailing stop size array (ts_) is not empty and the current high is higher than the last value in the array, the current high is added to the trailing stop size array.

If the trailing stop size array is empty, the current high is added.

If the position is short:

If the current low falls below the position's average price minus the specified percentage (tsact), the trailing stop is activated.

If the trailing stop size array is not empty and the current low is lower than the last value in the array, the current low is added to the trailing stop size array.

If the trailing stop size array is empty, the current low is added.

The trail variable is set to true if the trailing stop condition is met, which means that the price has crossed the trailing stop level.

If the trail condition is true, the strategy.close_all() function is called to close all open positions.

If there are no open trades (strategy.opentrades is false), the trailing stop size array (ts_) is cleared.

Various plot statements are used to visualize the trailing stop activation, trailing stop level, and position's average price.

That's a brief explanation of the provided code. Keep in mind that this is a snippet and may need customization or further integration into a complete trading strategy based on your specific requirements and market conditions.

Copypaste code to your Tradingview Strategy Tester


//@version=5
strategy("Trailing Stop Snippet", overlay=true)

length = input(12)
price = close
momentum(seria, length) =>
    mom = seria - seria[length]
    mom
mom0 = momentum(price, length)
mom1 = momentum( mom0, 1)

tsact = input.float(0.0, "Trailing Stop Activation |", group="strategy", tooltip="Activates the Trailing Stop once this PnL is reached.") / 100
tsact := tsact ? tsact : na
ts = input.float(0.0, "Position Trailing Stop |", group="strategy", tooltip="Trails your position with a stop loss at this distance from the highest PnL") / 100
ts := ts ? ts : na

in_long = strategy.position_size > 0
in_short = strategy.position_size < 0

var ts_ = array.new_float()
ts_size = array.size(ts_)
ts_get = ts_size > 0 ? array.get(ts_, ts_size - 1) : 0

if in_long
    if tsact and high > strategy.position_avg_price + strategy.position_avg_price * tsact
        if ts_size > 0 and ts_get < high
            array.push(ts_, high)
        if ts_size < 1
            array.push(ts_, high)
    if not tsact
        if ts_size > 0 and ts_get < high
            array.push(ts_, high)
        if ts_size < 1
            array.push(ts_, high)
if in_short
    if tsact and low < strategy.position_avg_price - strategy.position_avg_price * tsact
        if ts_size > 0 and ts_get > low
            array.push(ts_, low)
        if ts_size < 1
            array.push(ts_, low)
    if not tsact
        if ts_size > 0 and ts_get > low
            array.push(ts_, low)
        if ts_size < 1
            array.push(ts_, low)

trail = in_long and ts_size > 0 ? low < ts_get - ts_get * ts : in_short and ts_size > 0 ? high > ts_get + ts_get * ts : na

if (mom0 > 0 and mom1 > 0)
    strategy.entry("MomLE", strategy.long, stop=high+syminfo.mintick, comment="MomLE")
else
    strategy.cancel("MomLE")
if (mom0 < 0 and mom1 < 0)
    strategy.entry("MomSE", strategy.short, stop=low-syminfo.mintick, comment="MomSE")
else
    strategy.cancel("MomSE")

tsClose = in_long ? ts_get - ts_get * ts : in_short ? ts_get + ts_get * ts : na
if trail
    strategy.close_all()
if not strategy.opentrades
    array.clear(ts_)

//plot(strategy.equity, title="equity", color=color.red, linewidth=2, style=plot.style_areabr)

plotchar(ts_get, "GET", "")
plot(strategy.position_avg_price > 0 ? strategy.position_avg_price : na, "Average", color.rgb(251, 139, 64), 2, plot.style_cross)
plot(tsClose > 0 ? tsClose : na, "Trailing", color.rgb(251, 64, 64), 2, plot.style_cross)
plot(strategy.position_avg_price - strategy.position_avg_price * tsact > 0 ? strategy.position_avg_price - strategy.position_avg_price * tsact : na, "TS Activation", color.fuchsia, 2, plot.style_cross)

In this script, a buy order is opened at the current Ask price with an initial stop loss and take profit. The trailing stop level is set to a certain distance above the entry price. The OnTick function is used to monitor the price movement, and if the Bid price rises above the trailing stop level, the stop loss is updated to trail the price movement.

Please note that this is a basic example to illustrate the concept. In a real trading environment, you may need to implement additional features like position sizing, risk management, and error handling. Always test any trading strategy thoroughly in a demo environment before deploying it on a live account.

Copy this code to your MT4 Editor


//+------------------------------------------------------------------+
//|                            TrailingStopStrategy                 |
//|                       Copyright 2023, YourNameHere              |
//|                         http://www.yourwebsite.com               |
//+------------------------------------------------------------------+
//| This script implements a Trailing Stop strategy with            |
//| take profit and stop loss levels.                               |
//+------------------------------------------------------------------+
extern double TrailingStopPips = 20.0;   // Trailing stop in pips
extern double TakeProfitPips = 50.0;     // Take profit in pips
extern double StopLossPips = 30.0;       // Stop loss in pips

double trailingStopLevel = 0.0;
double initialStopLoss = 0.0;

//+------------------------------------------------------------------+
void OnStart()
{
   // Calculate initial stop loss and trailing stop levels
   initialStopLoss = Bid - StopLossPips * Point;
   trailingStopLevel = Bid + TrailingStopPips * Point;

   // Open a buy order
   int ticket = OrderSend(Symbol(), OP_BUY, 1, Ask, 2, initialStopLoss, Bid + TakeProfitPips * Point, "Trailing Stop Buy", 0, clrNONE);
   if (ticket > 0)
   {
      Print("Buy order opened at price:", Ask);
      Print("Initial stop loss:", initialStopLoss);
   }
}

//+------------------------------------------------------------------+
void OnTick()
{
   if (OrdersTotal() > 0)
   {
      double currentStopLoss = OrderStopLoss();
      
      // Update the trailing stop if the price is higher than the trailingStopLevel
      if (Bid > trailingStopLevel)
      {
         double newTrailingStop = Bid - TrailingStopPips * Point;
         
         // Adjust the stop loss only if the new trailing stop is lower than the current stop loss
         if (newTrailingStop > currentStopLoss)
         {
            OrderModify(OrderTicket(), OrderOpenPrice(), newTrailingStop, OrderTakeProfit(), 0, clrNONE);
            trailingStopLevel = Bid + TrailingStopPips * Point; // Update trailingStopLevel
            Print("Trailing stop updated to:", newTrailingStop);
         }
      }
   }
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                            TrailingStopStrategy                 |
//|                       Copyright 2023, YourNameHere              |
//|                         http://www.yourwebsite.com               |
//+------------------------------------------------------------------+
//| This script implements a Trailing Stop strategy with            |
//| take profit and stop loss levels.                               |
//+------------------------------------------------------------------+
extern double TrailingStopPips = 20.0;   // Trailing stop in pips
extern double TakeProfitPips = 50.0;     // Take profit in pips
extern double StopLossPips = 30.0;       // Stop loss in pips

double trailingStopLevel = 0.0;
double initialStopLoss = 0.0;

//+------------------------------------------------------------------+
void OnStart()
{
   // Calculate initial stop loss and trailing stop levels
   initialStopLoss = Bid - StopLossPips * Point;
   trailingStopLevel = Bid + TrailingStopPips * Point;

   // Open a buy order
   int ticket = OrderSend(Symbol(), OP_BUY, 1, Ask, 2, initialStopLoss, Bid + TakeProfitPips * Point, "Trailing Stop Buy", 0, clrNONE);
   if (ticket > 0)
   {
      Print("Buy order opened at price:", Ask);
      Print("Initial stop loss:", initialStopLoss);
   }
}

//+------------------------------------------------------------------+
void OnTick()
{
   if (OrdersTotal() > 0)
   {
      double currentStopLoss = OrderStopLoss();
      
      // Update the trailing stop if the price is higher than the trailingStopLevel
      if (Bid > trailingStopLevel)
      {
         double newTrailingStop = Bid - TrailingStopPips * Point;
         
         // Adjust the stop loss only if the new trailing stop is lower than the current stop loss
         if (newTrailingStop > currentStopLoss)
         {
            OrderModify(OrderTicket(), OrderOpenPrice(), newTrailingStop, OrderTakeProfit(), 0, clrNONE);
            trailingStopLevel = Bid + TrailingStopPips * Point; // Update trailingStopLevel
            Print("Trailing stop updated to:", newTrailingStop);
         }
      }
   }
}
//+------------------------------------------------------------------+

Posts you may Like !