OrderSend Error 130 in MT4/MQL4: Invalid Stops Fix

OrderSend Error 130 in MT4/MQL4 means that the stop settings in a trade request are not valid. The MQL4 error name is ERR_INVALID_STOPS.

The most common causes are a stop loss, take profit, or pending-order price that is too close to the current market price or does not satisfy the broker’s trading rules.

What Does OrderSend Error 130 Mean?

• Error code: 130
• Error name: ERR_INVALID_STOPS
• Meaning: Invalid stops

Error 130 means that MT4 or the trade server rejected a stop-related price in the request.

For a market order, this usually means the stop loss or take profit. For a pending order, the pending-order entry price itself must also satisfy the broker’s minimum distance rules.

int ticket = OrderSend(
    Symbol(),
    OP_BUY,
    Lots,
    Ask,
    Slippage,
    StopLoss,
    TakeProfit,
    "buy order",
    Magic,
    0,
    clrBlue
);

If StopLoss or TakeProfit violates the server’s stop rules, OrderSend() can return -1 with Error 130.

Common Causes of OrderSend Error 130

Check MODE_STOPLEVEL First

MT4 provides the broker’s minimum stop distance through MODE_STOPLEVEL.

int stopLevel =
    (int)MarketInfo(Symbol(), MODE_STOPLEVEL);

double minStopDistance =
    stopLevel * Point;

Print("StopLevel=", stopLevel, " points");
Print("Minimum stop distance=", minStopDistance);

The value returned by MODE_STOPLEVEL is measured in points.

For example:

StopLevel = 20
Point     = 0.00001

Minimum distance = 20 * 0.00001
                 = 0.00020

Correct Stop Loss and Take Profit Direction

Even when the distance is large enough, SL and TP must also be placed on the correct side of the market.

Buy Example

RefreshRates();

double sl =
    NormalizeDouble(Bid - 100 * Point, Digits);

double tp =
    NormalizeDouble(Bid + 100 * Point, Digits);

Sell Example

RefreshRates();

double sl =
    NormalizeDouble(Ask + 100 * Point, Digits);

double tp =
    NormalizeDouble(Ask - 100 * Point, Digits);

MQL4 Code Example: Validate SL and TP Before OrderSend

A simple helper function can check the visible MODE_STOPLEVEL requirement before sending a market order.

bool IsStopDistanceValid(int orderType,
                         double sl,
                         double tp)
{
    RefreshRates();

    double minDistance =
        MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;

    if(orderType == OP_BUY)
    {
        if(sl > 0)
        {
            if(sl >= Bid)
                return false;

            if((Bid - sl) < minDistance)
                return false;
        }

        if(tp > 0)
        {
            if(tp <= Bid)
                return false;

            if((tp - Bid) < minDistance)
                return false;
        }

        return true;
    }

    if(orderType == OP_SELL)
    {
        if(sl > 0)
        {
            if(sl <= Ask)
                return false;

            if((sl - Ask) < minDistance)
                return false;
        }

        if(tp > 0)
        {
            if(tp >= Ask)
                return false;

            if((Ask - tp) < minDistance)
                return false;
        }

        return true;
    }

    return false;
}

Example for a Buy order:

RefreshRates();

double sl =
    NormalizeDouble(Bid - 100 * Point, Digits);

double tp =
    NormalizeDouble(Bid + 100 * Point, Digits);

if(!IsStopDistanceValid(OP_BUY, sl, tp))
{
    Print("Invalid SL/TP.");
    return;
}

double price =
    NormalizeDouble(Ask, Digits);

ResetLastError();

int ticket = OrderSend(
    Symbol(),
    OP_BUY,
    Lots,
    price,
    Slippage,
    sl,
    tp,
    "buy order",
    Magic,
    0,
    clrBlue
);

if(ticket < 0)
{
    int err = GetLastError();

    Print("OrderSend failed. Error=", err,
          " Bid=", Bid,
          " Ask=", Ask,
          " SL=", sl,
          " TP=", tp);
}

Pending Orders Can Also Produce Error 130

A pending order must satisfy both its basic price direction and the broker’s minimum distance requirement.

For example, a Buy Limit must be below Ask and far enough away to satisfy the applicable stop-distance rule.

RefreshRates();

double minDistance =
    MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;

double price =
    NormalizeDouble(Ask - 100 * Point, Digits);

if(price >= Ask)
{
    Print("Buy Limit price must be below Ask.");
    return;
}

if((Ask - price) < minDistance)
{
    Print("Buy Limit is too close to Ask.");
    return;
}

ResetLastError();

int ticket = OrderSend(
    Symbol(),
    OP_BUYLIMIT,
    Lots,
    price,
    Slippage,
    0,
    0,
    "buy limit",
    Magic,
    0,
    clrBlue
);

if(ticket < 0)
{
    Print("OrderSend failed. Error=",
          GetLastError());
}

MODE_STOPLEVEL Is Zero but Error 130 Still Occurs

A MODE_STOPLEVEL value of zero does not always mean that every stop distance will be accepted.

It can mean that there is no fixed minimum distance reported to MT4. The server may still apply a dynamic or floating restriction that the terminal cannot represent as one constant StopLevel value.

If Error 130 occurs while MODE_STOPLEVEL is zero:

• Increase the SL/TP or pending-order distance.
• Refresh Bid and Ask before recalculating the prices.
• Normalize all calculated price values.
• Print the exact Bid, Ask, SL, TP, and pending price used.
• Check whether the restriction changes under different market conditions.

OrderModify Can Also Fail Because of Stop Restrictions

Error 130 is not limited to the initial OrderSend(). An OrderModify() request can also fail when a new SL or TP violates the allowed price-distance rules.

When modifying an existing order, it is also useful to check MODE_FREEZELEVEL.

int stopLevel =
    (int)MarketInfo(Symbol(), MODE_STOPLEVEL);

int freezeLevel =
    (int)MarketInfo(Symbol(), MODE_FREEZELEVEL);

Print("StopLevel=", stopLevel);
Print("FreezeLevel=", freezeLevel);

The freeze level defines a price area in which some order operations may be restricted. This is especially relevant when modifying or deleting orders close to the current market price.

Send the Market Order First, Then Add SL/TP

In some trading environments, a market order may be accepted more reliably when it is first opened without SL and TP and then modified afterward.

The workflow is:

1. Send the market order with SL and TP set to zero.
2. Confirm that the order was opened.
3. Select the new ticket.
4. Calculate valid SL and TP levels.
5. Apply them with OrderModify().

RefreshRates();

double price =
    NormalizeDouble(Ask, Digits);

ResetLastError();

int ticket = OrderSend(
    Symbol(),
    OP_BUY,
    Lots,
    price,
    Slippage,
    0,
    0,
    "buy order",
    Magic,
    0,
    clrBlue
);

if(ticket < 0)
{
    Print("OrderSend failed. Error=",
          GetLastError());

    return;
}

if(OrderSelect(ticket, SELECT_BY_TICKET))
{
    RefreshRates();

    double sl =
        NormalizeDouble(Bid - 100 * Point, Digits);

    double tp =
        NormalizeDouble(Bid + 100 * Point, Digits);

    ResetLastError();

    bool modified = OrderModify(
        ticket,
        OrderOpenPrice(),
        sl,
        tp,
        0,
        clrNONE
    );

    if(!modified)
    {
        Print("OrderModify failed. Error=",
              GetLastError());
    }
}

How to Debug OrderSend Error 130

When Error 130 occurs, print the actual market and stop values used by the EA.

RefreshRates();

int stopLevel =
    (int)MarketInfo(Symbol(), MODE_STOPLEVEL);

int freezeLevel =
    (int)MarketInfo(Symbol(), MODE_FREEZELEVEL);

double minStopDistance =
    stopLevel * Point;

Print("Bid=", Bid);
Print("Ask=", Ask);
Print("Digits=", Digits);
Print("Point=", Point);
Print("StopLevel=", stopLevel);
Print("FreezeLevel=", freezeLevel);
Print("MinimumStopDistance=", minStopDistance);
Print("SL=", StopLoss);
Print("TP=", TakeProfit);

Then inspect the Experts and Journal tabs in MT4.

A practical troubleshooting order is:

1. Confirm that the actual error is 130.
2. Check the SL/TP direction.
3. Check MODE_STOPLEVEL.
4. Compare the actual SL/TP distance with the minimum distance.
5. Normalize calculated prices.
6. For pending orders, check both direction and distance.
7. If modifying an existing order, also check MODE_FREEZELEVEL.
8. If StopLevel is zero, allow for possible dynamic server restrictions.

Error 129 vs Error 130

Errors 129 and 130 are closely related to price values, but they refer to different parts of the trade request.

If a Buy market order uses an invalid execution price, investigate Error 129. If the market entry price is valid but the SL, TP, or pending-order distance is rejected, investigate Error 130.

Related OrderSend Errors

Related MQL4 OrderSend Guides

FAQ About OrderSend Error 130

Summary

OrderSend Error 130 in MT4/MQL4 is ERR_INVALID_STOPS. The fastest way to diagnose it is to compare the actual SL, TP, or pending-order price with the current Bid/Ask and the broker’s stop-distance rules.

• Error 130 means Invalid Stops.
• Check MODE_STOPLEVEL and remember that it is returned in points.
• Buy SL is below Bid and Buy TP is above Bid.
• Sell SL is above Ask and Sell TP is below Ask.
• Pending orders must satisfy both direction and minimum-distance rules.
• A StopLevel of zero can still be associated with dynamic server-side restrictions.
• OrderModify() can also fail because of stop restrictions.
• When modifying orders, MODE_FREEZELEVEL may also be relevant.
• Do not confuse Error 130 with Error 129, which concerns the execution price itself.

Back to MT4/MQL4 Technical Notes