🚀 My ETH Scalping Setup: Automating Entries with TradingView & Pine Script

[PTScalper]

Hi all.

I've been heavily focused on scalping Ethereum (ETH/USD) on the 1-minute and 5-minute charts lately. As we all know, ETH has the perfect mix of high liquidity and volatility for short-term trades. But let’s be real—trying to manually enter trades, calculate lot sizes, and set Stop Losses (SL) and Take Profits (TP) before the market moves without you will literally give you gray hair. I wanted to share my approach and explain why using a custom MT4 script is the only way I can trade this strategy without losing my mind. I'd love to hear your thoughts or see how you guys handle your execution!The Core Strategy (Keep it Simple)When you're scalping, you only have seconds to make a decision. I try to avoid decision fatigue by sticking to a very basic setup:Timeframe: 1M or 5M chart.Indicators: 9 EMA and 21 EMA for trend direction, plus RSI (14) to spot overbought/oversold pullbacks.The Play: When the 9 EMA crosses above the 21 EMA (bullish), I don't chase the immediate crossover candle. Instead, I wait for a slight pullback to the fast EMA, ensure the RSI is cooling off, and then enter long on the bounce.Why You Need an MT4 Script for ThisThe problem with the strategy above is execution speed. By the time you right-click, hit "New Order," type in your lot size, and calculate your SL and TP, the move is usually gone.To fix this, I utilize custom MT4 scripts assigned to hotkeys (e.g., Ctrl+1 for Buy, Ctrl+2 for Sell). Here is what my scripts handle instantly:One-Click Execution: The script executes the trade at market price the exact millisecond I hit my hotkey.Auto SL and TP: The script automatically attaches a predefined Stop Loss and Take Profit (e.g., 20 points for TP, 10 points for SL) the moment the trade is placed. This guarantees a strict Risk:Reward ratio without me having to manually drag lines on the chart."Panic / Close All" Button: I have a separate script mapped to Ctrl+C that instantly closes all open ETH positions. This is a lifesaver if the market suddenly dumps or if I just want to secure all profits before a major news event.

[PTScalper]

A Basic MT4 Script Logic (MQL4)

If you're looking to code a 1-click execution script yourself in MetaEditor, the core function you want to use is OrderSend(). Here is a rough idea of the logic to automate your SL/TP on a buy entry:

Code: Select all

// Sample logic for an instant Buy Script
double TakeProfit = 200; // In points (adjust for your broker's ETH digits)
double StopLoss = 100;   // In points
double LotSize = 0.5;

void OnStart()
{
    double price = Ask;
    double sl = price - (StopLoss * Point);
    double tp = price + (TakeProfit * Point);
    
    // Execute trade instantly with SL and TP attached
    int ticket = OrderSend(Symbol(), OP_BUY, LotSize, price, 3, sl, tp, "ETH Scalp", 0, 0, Green);
    
    if(ticket < 0) {
        Print("Order failed with error: ", GetLastError());
    } else {
        Print("Scalp entered successfully!");
    }
}

A Quick Word on RiskScalping ETH can be incredibly risky. The spread and exchange commissions will eat you alive if you overtrade. Make sure your broker has a very tight raw spread for ETH/USD, otherwise, your script will just be automating your losses. You should always cap your risk per trade to around 1% of your account. What about you guys?Are any of you using EAs or custom scripts for scalping crypto on MT4? What does your hotkey setup look like? Do you have any script optimizations to share? Let me know below!

[PTScalper]

The Code: MT5 (MQL5) vs. cTrader (C#)

Both platforms are massive upgrades from MT4, but their coding languages handle execution very differently.

MT5 (MQL5) Script Logic

In MT5, the execution is asynchronous and much faster than MT4. If you want to map a 1-click Buy script to a hotkey, using the built-in CTrade class is the cleanest way to do it.

Code: Select all

// MQL5 Instant Buy Script with Auto SL/TP
#include <Trade\Trade.mqh>
CTrade trade;

void OnStart()
{
    double LotSize = 0.5;
    double TakeProfit = 200 * _Point; // Adjust points based on your broker's ETH pricing
    double StopLoss = 100 * _Point;

    double price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
    double sl = price - StopLoss;
    double tp = price + TakeProfit;

    // Execute trade instantly
    if(trade.Buy(LotSize, _Symbol, price, sl, tp, "ETH Scalp")) {
        Print("Scalp entered successfully!");
    } else {
        Print("Order failed: ", GetLastError());
    }
}

[PTScalper]

cTrader (C#) cBot Logic

cTrader is a dream for scalpers because its native QuickTrade features are already excellent, but C# gives you ultimate control. You can write a quick cBot to act as a script. Notice how much simpler the order command is compared to MQL:

Code: Select all

// cTrader cBot (C#) Instant Buy 
using cAlgo.API;

[Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
public class ETHScalper : Robot
{
    [Parameter("Volume (Lots)", DefaultValue = 0.5)]
    public double Volume { get; set; }

    protected override void OnStart()
    {
        // Execute Market Order with 10 pips SL and 20 pips TP instantly
        ExecuteMarketOrder(TradeType.Buy, SymbolName, Symbol.QuantityToVolumeInUnits(Volume), "ETH Scalp", 10, 20);
        
        // Stop the bot immediately so it acts exactly like a one-off script
        Stop(); 
    }
}

[PTScalper]

Why You Need Pine Script for This

Unlike standard desktop platforms where you use hotkeys, TradingView allows you to fully automate the process while you are asleep or away from your desk.

By wrapping this logic into a Pine Script strategy(), you get three massive benefits:

Instant Backtesting: You can instantly see how your SL and TP parameters would have performed over the last 10,000 bars.

Emotionless Execution: TradingView monitors the 1M chart 24/7 without blinking.

Webhook Automation: By using an alert webhook (via services like PineConnector, 3Commas, or direct exchange webhooks like Bybit/Binance), TradingView fires the trade, sets the exact lot size, and places your Stop Loss and Take Profit on your exchange in milliseconds.

The Code: Pine Script (v5)
Here is a basic blueprint of how you can code this scalping logic in Pine Script version 5. It handles the EMA trend, the pullback entry, and automatically calculates a percentage-based Stop Loss and Take Profit.

Code: Select all

//@version=5
strategy("ETH Scalper", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=10)

// 1. Define Indicators
fastEma = ta.ema(close, 9)
slowEma = ta.ema(close, 21)
rsi = ta.rsi(close, 14)

// 2. Entry Conditions
// Trend is up, low touches the fast EMA (pullback), and RSI isn't overbought
trendUp = fastEma > slowEma
pullback = low <= fastEma and close > fastEma 
rsiCool = rsi < 60

longCond = trendUp and pullback and rsiCool

// 3. Execute Entry
if (longCond)
    strategy.entry("Buy", strategy.long)

// 4. Risk Management (e.g., 0.2% Stop Loss, 0.4% Take Profit)
// We calculate this based on the average entry price of our position
if (strategy.position_size > 0)
    sl_price = strategy.position_avg_price * 0.998 // 0.2% SL
    tp_price = strategy.position_avg_price * 1.004 // 0.4% TP
    
    // Attach SL and TP to the open trade
    strategy.exit("Exit", "Buy", stop=sl_price, limit=tp_price)