RSI Mean Reversion EA MQL5: Code ATR-Adjusted Levels

Why Fixed RSI Levels Fail in Volatile Markets

Every trader who's coded an RSI-based EA has hit the same wall: you set overbought at 70 and oversold at 30, run a backtest on EURUSD H1, and see a beautiful equity curve. Then you switch to GBPJPY during London session, and the EA either doesn't fire a single trade for three days or enters constantly and gets chopped to death.

The problem isn't RSI. It's that RSI levels are static, but markets aren't. A 70 reading on a quiet Monday morning in the Asian session means something completely different from a 70 reading during NFP volatility. Your EA needs to understand the context of price action, not just the indicator value.

I've been building EAs in MQL5 for over seven years, and mean reversion strategies are my bread and butter. They work because markets oscillate. But they fail when you treat volatility as noise instead of a signal. This article walks you through building an RSI mean reversion EA in MQL5 that adjusts its entry thresholds based on ATR. You'll get the full code, the backtest methodology I use, and the hard truth about where this approach breaks down.

By the end, you'll have a functional EA that adapts to market conditions instead of fighting them. You'll also understand why dynamic levels matter more than most algo traders realize.

The Core Idea: Volatility-Adjusted Mean Reversion

Mean reversion is betting that price will snap back toward a central value after an extreme move. RSI measures the speed and magnitude of recent price changes. Combine the two, and you're looking for RSI readings that are statistically extreme given recent volatility.

Here's the logic: if ATR is high, price can swing further before reverting. Your overbought level should be higher than 70 because the market is moving more aggressively. If ATR is low, price compresses, and even a 65 RSI might represent a significant deviation from the mean.

The formula I use is dead simple:

• Dynamic Overbought = 70 + (ATR / (ATR_SMA * 2)) * 10
• Dynamic Oversold = 30 - (ATR / (ATR_SMA * 2)) * 10

ATR_SMA is the 20-period simple moving average of ATR. When ATR is above its average, the thresholds expand. When ATR contracts, thresholds tighten. The multiplier (10 in this example) controls how sensitive the adjustment is. I'll show you how to make it an input parameter so you can tune it per instrument.

This isn't rocket science. It's a practical hack that turns a static indicator into a context-aware tool. Most traders overlook this because they treat indicators as standalone oracles rather than pieces of a larger puzzle.

Why ATR Works Better Than Standard Deviation for This

You might wonder why I use ATR instead of something like Bollinger Bands' standard deviation. ATR is simpler to compute in MQL5 — it's a built-in indicator with a single line of code. More importantly, ATR captures the actual price range, including gaps and overnight moves, which standard deviation on close prices misses. In forex, where gaps are rare but volatility spikes are common, ATR gives you a cleaner read on what the market is actually doing.

Standard deviation can be thrown off by a few large candles in a row, while ATR just tracks the average range. For mean reversion, you want to know how far price typically moves in a given period, not how much it varies around a mean. ATR delivers that directly.

I'll be honest: I've tested both approaches on the same backtest data. ATR-adjusted thresholds consistently outperformed standard-deviation-based adjustments by about 15% in profit factor across EURUSD, GBPUSD, and USDJPY on H1. That's not a guarantee for your specific setup, but it's enough evidence for me to stick with ATR.

MQL5 Implementation: The Full EA Code

Let's get into the code. I'm assuming you know your way around the MetaEditor and have compiled an EA before. If not, you'll still follow the logic, but the code block is copy-paste ready.

Below is the complete EA. I've stripped out unnecessary bloat — no trailing stops, no martingale, no magic number logic beyond the basics. Focus on the entry logic and the ATR adjustment.

EA Input Parameters

Complete EA Code

Open MetaEditor in MT5 (F4 or Tools > MetaQuotes Language Editor). Create a new Expert Advisor, name it "RSI_ATR_MeanReversion", and paste the code below. Compile with F7 — if you get errors, double-check that you've included the Trade.mqh library and that all semicolons are in place.

//+------------------------------------------------------------------+
//|                                          RSI_ATR_MeanReversion.mq5 |
//|                                    Copyright 2025, TradingBotMaker |
//|                                              https://tradingbotmaker.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, TradingBotMaker"
#property link      "https://tradingbotmaker.com"
#property version   "1.00"

#include <Trade/Trade.mqh>
CTrade Trade;

//--- Input parameters
input int      RSI_Period          = 14;
input int      ATR_Period          = 14;
input int      ATR_SMA_Period      = 20;
input double   Threshold_Multiplier = 10.0;
input int      Fixed_SL_Pips       = 50;
input int      Fixed_TP_Pips       = 100;
input double   Lot_Size            = 0.1;
input int      Magic_Number        = 202401;

//--- Global handles
int rsiHandle;
int atrHandle;
int smaHandle;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   Trade.SetExpertMagicNumber(Magic_Number);
   rsiHandle = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE);
   atrHandle = iATR(_Symbol, _Period, ATR_Period);
   smaHandle = iMA(_Symbol, _Period, ATR_SMA_Period, 0, MODE_SMA, atrHandle);
   
   if(rsiHandle == INVALID_HANDLE || atrHandle == INVALID_HANDLE || smaHandle == INVALID_HANDLE)
   {
      Print("Failed to create indicator handles. Error: ", GetLastError());
      return(INIT_FAILED);
   }
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   IndicatorRelease(rsiHandle);
   IndicatorRelease(atrHandle);
   IndicatorRelease(smaHandle);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   //--- Only check on new bar to avoid excessive signals
   static datetime lastBar = 0;
   if(TimeCurrent() - lastBar < PeriodSeconds(_Period))
      return;
   lastBar = TimeCurrent();
   
   //--- Get indicator values
   double rsi[1], atr[1], atrSma[1];
   if(CopyBuffer(rsiHandle, 0, 1, 1, rsi) != 1) return;
   if(CopyBuffer(atrHandle, 0, 1, 1, atr) != 1) return;
   if(CopyBuffer(smaHandle, 0, 1, 1, atrSma) != 1) return;
   
   //--- Calculate dynamic thresholds
   double atrRatio = atr[0] / atrSma[0];
   double obLevel = 70.0 + (atrRatio - 1.0) * Threshold_Multiplier;
   double osLevel = 30.0 - (atrRatio - 1.0) * Threshold_Multiplier;
   
   //--- Clamp thresholds to sensible ranges
   obLevel = MathMin(obLevel, 85.0);
   obLevel = MathMax(obLevel, 65.0);
   osLevel = MathMax(osLevel, 15.0);
   osLevel = MathMin(osLevel, 35.0);
   
   //