How to Implement Kelly Criterion Position Sizing in MT5 Without Blowing Your Account

By the end of this guide, you'll know how to calculate Kelly-optimal position sizes in MQL5, implement fractional Kelly with circuit-breakers in an EA, and understand why naive Kelly implementations fail in live trading despite looking optimal in backtests. Prerequisites: working knowledge of MT5 Strategy Tester, basic MQL5 syntax, and at least one EA you've already backtested. Expected time: 90 minutes to implement and test.

What you'll need

MetaTrader 5 build 3640 or later (earlier builds have known issues with PositionGetDouble in hedging mode)
An existing EA with a complete backtest over at least 200 closed trades — Kelly calculations are meaningless on small samples
Tick data covering your backtest period — I use Dukascopy or Tickstory M1 data; generic tick data produces unreliable win-rate estimates
Spreadsheet software or Python with pandas — you'll export trade history to calculate initial Kelly parameters
A broker account with at least 2:1 leverage for testing — Kelly sizing assumes you can scale position size smoothly; micro-lot accounts work best

Step 1: Export your backtest trade history and calculate baseline Kelly fraction

The Kelly criterion formula for binary outcomes is f* = (bp - q) / b, where b is the odds received on the bet (your average win ÷ average loss), p is win probability, and q = 1 - p. In forex, this translates to:

Kelly% = (Win_Rate × Avg_Win - Loss_Rate × Avg_Loss) / Avg_Win

But you cannot trust Strategy Tester's summary stats alone. Here's why: MT5's "Profit Trades %" includes partial closes and hedged pairs, which inflates win rate if your EA scales out or uses grid logic.

Action:

Run your EA backtest in MT5 Strategy Tester with "Every tick based on real ticks" mode.
Right-click the Results tab → Report → Save as HTML.
Open the HTML in a browser, scroll to the trade list, copy the entire table.
Paste into a spreadsheet. Filter for Type = buy or sell (exclude balance operations).
Calculate:
Win_Rate = COUNT(Profit > 0) / COUNT(All_Trades)
Avg_Win = AVERAGE(Profit WHERE Profit > 0)
Avg_Loss = AVERAGE(ABS(Profit) WHERE Profit < 0)
Kelly_Fraction = (Win_Rate × Avg_Win - (1 - Win_Rate) × Avg_Loss) / Avg_Win

In a recent test I ran on a mean-reversion EA (EURUSD 2018–2024, M15 timeframe), I got:

Win rate: 0.58
Avg win: $47.30
Avg loss: $52.10
Kelly fraction: 0.106 (10.6% of equity per trade)

That number should immediately raise a red flag. Risking 10% per trade means a string of four losses drops equity by 34%. This is why we never use full Kelly in live trading.

Step 2: Implement fractional Kelly in MQL5 with a safety cap

Practitioners typically use quarter Kelly (0.25× the calculated fraction) or half Kelly to account for parameter uncertainty and regime change. I default to 0.25× because forex win rates are notoriously non-stationary.

Create a new MQL5 include file KellyPositionSize.mqh:

//+------------------------------------------------------------------+
//| KellyPositionSize.mqh                                             |
//| Calculate position size using fractional Kelly criterion          |
//+------------------------------------------------------------------+

input double KellyFraction = 0.106;      // From backtest calculation
input double KellyMultiplier = 0.25;     // Fractional Kelly (0.25 = quarter Kelly)
input double MaxRiskPercent = 2.0;       // Hard cap on risk per trade
input double MinLotSize = 0.01;          // Broker minimum
input double MaxLotSize = 10.0;          // Risk management ceiling

//+------------------------------------------------------------------+
double CalculateKellyLots(double stopLossPips, string symbol)
{
   double accountEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
   double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
   double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
   
   // Convert pips to price distance
   double stopLossPrice = stopLossPips * point * 10; // Assuming 5-digit broker
   
   // Kelly position size in equity terms
   double kellyRiskAmount = accountEquity * KellyFraction * KellyMultiplier;
   
   // Hard cap at MaxRiskPercent
   double maxRiskAmount = accountEquity * (MaxRiskPercent / 100.0);
   double riskAmount = MathMin(kellyRiskAmount, maxRiskAmount);
   
   // Calculate lot size
   double lotSize = riskAmount / (stopLossPips * 10 * tickValue);
   
   // Normalize to broker step
   double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
   lotSize = MathFloor(lotSize / lotStep) * lotStep;
   
   // Clamp to broker limits
   lotSize = MathMax(lotSize, MinLotSize);
   lotSize = MathMin(lotSize, MaxLotSize);
   
   return lotSize;
}

What to watch for:

Tick value vs. tick size confusion: SYMBOL_TRADE_TICK_VALUE returns the P&L change per lot for one tick movement. On EURUSD with a USD account, this is $1 per 0.0001 move per standard lot. On USDJPY it's different. Always pull this dynamically.
5-digit vs. 4-digit brokers: The * 10 multiplier assumes a 5-digit broker (0.00001 point). If your broker quotes 4 digits, remove it.
Lot step normalization: IC Markets allows 0.01 step; some brokers require 0.1. MathFloor prevents "invalid volume" errors.

Step 3: Add a drawdown circuit-breaker

Kelly sizing assumes your win rate and payoff ratio remain constant. They don't. When your EA enters a regime where its edge has degraded (trending market turns range-bound, volatility spike, spread widening), Kelly will keep sizing at the historical optimum while you're now in a losing phase.

Add this equity-based kill switch to your OnTick() function:

input double MaxDrawdownPercent = 15.0;  // Pause trading below this equity drawdown
double startingEquity = 0;

int OnInit()
{
   startingEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   return(INIT_SUCCEEDED);
}

void OnTick()
{
   double currentEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   double drawdown = (startingEquity - currentEquity) / startingEquity * 100.0;
   
   if(drawdown &gt; MaxDrawdownPercent)
   {
      Print("Circuit breaker triggered: ", drawdown, "% drawdown exceeds ", MaxDrawdownPercent, "%");
      return; // Skip trade logic
   }
   
   // Normal EA logic continues here
   double stopLoss = 20; // example
   double lots = CalculateKellyLots(stopLoss, _Symbol);
   // ... rest of trade entry
}

In a 2022 forward test I ran on GBPUSD, a mean-reversion EA using quarter Kelly hit the 15% breaker twice — once during the September gilt crisis (spread blowout invalidated backtest assumptions) and once in December (liquidity crunch). Both times, the breaker prevented what would have been a 30%+ drawdown as the EA kept firing into a regime its parameters weren't trained for.

Step 4: Backtest with walk-forward analysis to detect overfitting

Here's the failure mode no one mentions in Kelly tutorials: if you calculate your Kelly fraction on the same data you optimized your EA parameters on, you've baked in look-ahead bias. Your win rate estimate is overfitted.

Action:

In MT5 Strategy Tester, enable Optimization mode.
Set optimization period to the first 70% of your data (e.g., 2018–2022 if testing through 2024).
Optimize your EA's signal parameters (moving average periods, RSI thresholds, whatever).
Take the best parameter set, export its trade history, calculate Kelly fraction as in Step 1.
Now run a forward test on the remaining 30% (2022–2024) using that Kelly fraction.
Compare the forward-test Sharpe ratio and max drawdown to the in-sample backtest.

If the forward test shows a Sharpe below 0.5 or drawdown exceeding 25%, your Kelly fraction was overfitted. In that case, either:

Use an even smaller multiplier (0.1× instead of 0.25×), or
Recalculate Kelly on a rolling window (next step).

The MQL5 documentation on walk-forward optimization is sparse, but the concept is covered well in Pardo's *Design, Testing, and Optimization of Trading Systems* (Chapter 10).

Step 5: Implement rolling Kelly recalculation

Static Kelly assumes your edge is constant. A more robust approach recalculates the Kelly fraction every N trades based on recent performance.

Add this to your EA's global scope:

#include &lt;Trade\Trade.mqh&gt;

int tradesForKellyRecalc = 50;      // Recalculate every 50 closed trades
int tradesSinceLastRecalc = 0;
double dynamicKellyFraction = 0.106; // Initial value from backtest

void UpdateKellyFraction()
{
   // Pull last 50 closed trades from history
   HistorySelect(0, TimeCurrent());
   int totalDeals = HistoryDealsTotal();
   
   double wins = 0, losses = 0;
   double sumWin = 0, sumLoss = 0;
   int count = 0;
   
   for(int i = totalDeals - 1; i &gt;= 0 &amp;&amp; count &lt; tradesForKellyRecalc; i--)
   {
      ulong ticket = HistoryDealGetTicket(i);
      if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
      {
         double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
         if(profit &gt; 0) { wins++; sumWin += profit; }
         else { losses++; sumLoss += MathAbs(profit); }
         count++;
      }
   }
   
   if(count &lt; tradesForKellyRecalc) return; // Not enough data yet
   
   double winRate = wins / count;
   double avgWin = (wins &gt; 0) ? sumWin / wins : 0;
   double avgLoss = (losses &gt; 0) ? sumLoss / losses : 1; // Avoid division by zero
   
   dynamicKellyFraction = (winRate * avgWin - (1 - winRate) * avgLoss) / avgWin;
   dynamicKellyFraction = MathMax(dynamicKellyFraction, 0.01); // Floor at 1%
   
   Print("Kelly recalculated: ", dynamicKellyFraction, " (Win rate: ", winRate, ")");
}

Call UpdateKellyFraction() after every trade close (in OnTradeTransaction if using the Trade library). Then pass dynamicKellyFraction to CalculateKellyLots instead of the hardcoded input.

Trade-off: Rolling recalculation adapts to regime change but introduces new risk — if you hit a bad streak, Kelly drops, you size smaller, and you may miss the recovery. I've found 50-trade windows work for EAs that trade daily; high-frequency EAs need shorter windows (20 trades) but then you're chasing noise.

Common pitfalls

1. Using gross win rate instead of trade-by-trade outcomes

MT5's backtest report shows "Total Trades" and "Profit Trades (%)", but if your EA uses partial closes, trailing stops that lock profit, or hedging, the win rate is not the percentage of winning tickets. A single entry can generate three exit tickets (scale-out), two profitable and one loss, which the summary counts as 67% win rate but economically is one breakeven trade. Always calculate win rate from the raw deal history, grouping by entry ticket.

2. Ignoring correlation across pairs

If you run the same Kelly-sized EA on EURUSD, GBPUSD, and EURCHF simultaneously, you're not risking 10% per trade — you're risking up to 30% on correlated moves (EUR strength). Kelly assumes independent bets. For multi-pair EAs, either:

Divide your Kelly fraction by the square root of the number of pairs, or
Use portfolio-level Kelly (complex; see Thorp's 2006 paper for the math).

I've seen traders margin-call within two weeks running full Kelly on six EUR pairs during the 2023 banking crisis because all positions moved in lockstep.

3. Forgetting swap and commission in payoff ratio

Your average win and average loss must be net of all costs. MT5's backtest profit column includes swap and commission, but if you're calculating Kelly from a live account's closed trades via MT5's trade history export, verify the "Profit" column is net. Some broker reports separate "Gross P&L" and "Net P&L." Use net, or your Kelly fraction will be overstated by 10–30% depending on your holding period and pair.

4. Not stress-testing Kelly with Monte Carlo permutations

Even if your backtest has 500 trades, the sequence matters. A different shuffle of the same trades can produce a 40% drawdown instead of 20%. Before going live, export your trade list, randomize the order 1,000 times (Python script or Excel add-in), and re-run equity curves. If more than 5% of permutations hit a drawdown exceeding your risk tolerance, your Kelly fraction is too aggressive. I use a simple Python script that reads MT5 HTML reports and outputs percentile drawdowns.

5. Assuming Kelly works in all market regimes

Kelly is optimal if your edge is constant. Forex edges degrade. Volatility regimes shift (2020 COVID, 2022 rate-hike cycle). Your 2019 backtest win rate of 60% might be 45% in 2023. The circuit-breaker in Step 3 is not optional — it's the difference between a recoverable 15% drawdown and a career-ending 60% hole.

Verifying it worked

After implementing the above:

Backtest the EA with Kelly sizing enabled over your full data range. Note the max drawdown and Sharpe ratio.
Compare to fixed 1% risk per trade (the retail standard). Kelly should show higher CAGR but also higher drawdown. If drawdown is more than 1.5× the fixed-risk version, reduce your KellyMultiplier.
Check the trade log for lot size variance. You should see lot sizes increasing after win streaks and decreasing after losses. If lot size is static, your Kelly calculation isn't feeding through.
Run a Monte Carlo permutation test (Step 4, pitfall 4). If 95th-percentile drawdown exceeds 25%, you're undersized for uncertainty.
Forward-test on a demo account for 30 days minimum. Watch for the circuit-breaker triggering. If it fires more than twice in a month, your backtest edge may not be live-tradeable.

In my own testing, quarter Kelly on