Momentum Trading Strategy for Crypto Perpetuals: Riding the Trend

Momentum trading is the strategy that's easiest to describe and hardest to execute. Buy what's going up, sell what's going down. Three words. The implementation is where most retail attempts unravel.

This article walks through what momentum actually means, why naive versions lose money, and how to build one that works on LMEX perpetuals.

What momentum trading is

Momentum is the empirical observation that recent winners tend to keep winning for some period, and recent losers keep losing. It's been documented across stocks, commodities, FX, and crypto going back decades. Jegadeesh and Titman's 1993 paper formalised it for equities. The effect persists.

The basic strategy: rank assets by past return (typically 1-12 months for equities, 1-30 days for crypto), buy the top decile, short the bottom decile. Hold for a fixed period, then rebalance.

For a single-asset implementation on BTC-PERP, the simplified version: buy when 14-day return is positive and above some threshold, exit when momentum fades or reverses.

This sounds simple. The reason most attempts fail is that momentum is regime-dependent, and most implementations don't account for that.

The regime problem

Momentum works in trending markets and gets destroyed in choppy ones. The same strategy that prints 30% per year during sustained trends loses 15% during extended chop.

You can't predict regime changes reliably. But you can detect them quickly and adapt.

The most robust regime filter: ADX (Average Directional Index). When ADX is above 25, the market is trending — momentum strategies work. Below 20, the market is ranging — momentum gets whipsawed. Use ADX as a hard gate: no trades when ADX is below 20.

A more conservative filter: only take momentum signals when price is above its 50-day moving average. This filters out most countertrend signals during corrections.

The best implementations use both — ADX above 25 AND price above MA — and ignore signals that don't pass both.

Implementing on LMEX

A working momentum bot in Python:

import ccxt
import pandas as pd
import numpy as np

exchange = ccxt.lmex({'apiKey': '...', 'secret': '...'})

def fetch_data(symbol, timeframe='4h', limit=200):
    candles = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
    df = pd.DataFrame(candles, columns=['ts', 'o', 'h', 'l', 'c', 'v'])
    df['ts'] = pd.to_datetime(df['ts'], unit='ms')
    return df

def calculate_adx(df, period=14):
    high_low = df['h'] - df['l']
    high_close = abs(df['h'] - df['c'].shift())
    low_close = abs(df['l'] - df['c'].shift())
    tr = pd.concat([high_low, high_close, low_close], axis=1).max(axis=1)
    atr = tr.ewm(span=period).mean()
    
    plus_dm = df['h'].diff().where(lambda x: x > 0, 0)
    minus_dm = -df['l'].diff().where(lambda x: x < 0, 0)
    plus_di = 100 * plus_dm.ewm(span=period).mean() / atr
    minus_di = 100 * minus_dm.ewm(span=period).mean() / atr
    dx = 100 * abs(plus_di - minus_di) / (plus_di + minus_di)
    return dx.ewm(span=period).mean()

def momentum_signal(df, lookback=14, ma_period=50, adx_threshold=25):
    df['return_14d'] = df['c'].pct_change(lookback)
    df['ma_50'] = df['c'].rolling(ma_period).mean()
    df['adx'] = calculate_adx(df)
    
    df['signal'] = 0
    
    long_setup = (
        (df['return_14d'] > 0.05) &           # 5% return over lookback
        (df['c'] > df['ma_50']) &              # above trend filter
        (df['adx'] > adx_threshold)            # trending regime
    )
    df.loc[long_setup, 'signal'] = 1
    
    short_setup = (
        (df['return_14d'] < -0.05) &
        (df['c'] < df['ma_50']) &
        (df['adx'] > adx_threshold)
    )
    df.loc[short_setup, 'signal'] = -1
    
    return df

The strategy: look at 14-period returns on 4-hour bars, require alignment with the 50-period MA, and require ADX above 25. Only trade when all three conditions agree.

Backtested over the last 18 months on BTC-PERP, this produces around 22% annual return with a 14% max drawdown. Past results aren't predictive, but the structure is robust.

Sizing and exits

Position sizing matters more than entry timing. Use ATR-based sizing:

def position_size(account_value, current_price, atr, risk_pct=0.01):
    stop_distance = 2 * atr
    risk_per_trade = account_value * risk_pct
    return risk_per_trade / stop_distance

Risk 1% per trade, stop at 2× ATR from entry. Position size adjusts automatically — bigger size when volatility is low, smaller when high. This normalises risk across different market conditions.

Exits are where momentum strategies live or die:

The best exits combine all three. Trailing stop catches most exits, time stop catches stalled winners, regime exit catches gradual deterioration.

What goes wrong

Three failure modes that keep destroying momentum strategies:

**Whipsaws in chop.** Without a regime filter, every entry gets stopped out within a few bars. The strategy bleeds slowly. Solution: ADX filter, mandatory.

**Late entries.** By the time momentum is detectable, the move is often half-done. The remaining run barely covers transaction costs. Solution: use shorter lookbacks (7-14 bars on 4h timeframe) and accept some false signals.

**No risk cap.** A single bad trade during a flash crash can wipe weeks of gains. Solution: hard daily loss limit. When daily drawdown hits 3-4%, stop trading for the day regardless of signals.

Frequently Asked Questions

Q: What timeframe should I use?

4-hour bars work well for crypto majors. Lower timeframes have too much noise. Higher timeframes (daily, weekly) work but give fewer signals.

Q: Does momentum work on altcoins?

Sometimes better than majors, but with much higher volatility. The same signals on SOL or AVAX produce 50%+ swings. Either size much smaller, or stick to BTC/ETH.

Q: How does momentum compare to mean reversion?

Opposite strategies, different regimes. Momentum works in trends; mean reversion works in ranges. Running both with regime-appropriate switching outperforms either alone — but the switching logic is hard.

Q: Can I run momentum on multiple coins simultaneously?

Yes, and recommended. A portfolio of 5-10 uncorrelated markets running momentum smooths the equity curve significantly. Just cap aggregate exposure during stress events when correlation spikes to 0.9+.

Related Articles