# Reduce only order: meaning, rejections and API fixes

URL: https://fincodelabs.com/en/blog/reduce-only-order · Publisher: Fincode (Fincode Yazılım ve Teknoloji A.Ş.), Istanbul, Turkey · Category: Exchange APIs · Published: 2026-11-06 · Updated: 2026-11-06

Reduce only order meaning, why reduceOnly orders are rejected on Binance, Bybit and others, error codes -2022 and -4118, and a tested Python fix flow.

**Short answer:** A **reduce-only order** is an order the exchange may use only to shrink an open position, never to increase it or flip it to the other side. On Binance USD-M futures a rejection appears as `-2022` (ReduceOnly Order is rejected) or `-4118` (ReduceOnly Order Failed), as documented on 5 November 2026. The usual causes are a position that has already closed, the wrong side, a size above the position once other open orders count, or Hedge Mode, so the fix is to read the position again rather than to retry.

The flag marks an order as an exit, which matters when the position changes while the order is working. Everything below comes from official pages read on 5 November 2026; the fix flow ran on synthetic positions.

This page explains mechanics and recommends no setting, size or exit, and its examples are hypothetical. Reduce-only flags sit on leveraged products, and leverage can lose the whole margin; see [perpetual futures and funding](https://fincodelabs.com/en/blog/perpetual-futures-funding-rate) and the [liquidation price calculator](https://fincodelabs.com/en/tools/liquidation-price-calculator). Rules depend on your jurisdiction and the platform's terms. Leverage is not available on platforms on the list of Turkey's Capital Markets Board, SPK (Communiqué III-35/B.2, Article 14), and this page is not aimed at Turkish residents. Article 99/A of Capital Markets Law No. 6362 treats activity by foreign crypto-asset platforms directed at Turkish residents as unauthorized.

## What does reduce only mean?

It means the order can only bring a position closer to zero: if filling it would add to the position or carry it through zero, the venue refuses, trims or cancels it.

> **Hypothetical example.** You are long 1.0 with a resting sell of 1.0 as an exit, and a stop closes the position first. Without the flag, the resting sell can later fill and open a short of 1.0. With it, the order cannot open anything.

**Reduce-only fields and oversized orders, documents read 5 November 2026 (alphabetical, not a ranking)**

| Venue | Field | Oversized or wrong-side order |
| --- | --- | --- |
| Binance USD-M | `reduceOnly` on `POST /fapi/v1/order` and `/fapi/v1/algoOrder` | FAQ updated 7 April 2026: rejected if on the same side as the position, or opposite but too large and failing the margin check |
| Bybit | `reduceOnly`, `closeOnTrigger` | No position: rejected. Too large: "automatically reduced or cancelled", with cancel type `CancelByReduceOnly` |
| Coinbase Advanced Trade | No request field in the create-order schema | Its failure reasons still list `REDUCE_ONLY_INCREASED_POSITION_SIZE`; the page does not say how an order becomes reduce-only |
| Hyperliquid | `r` in the order action | Rejected: Reduce only order would increase position. |
| Kraken | `reduce_only` | `EOrder:Reduce only:No position exists`; `EOrder:Reduce only:Position is closed` means it would flip, so it partly fills and the rest is canceled |
| OKX | `reduceOnly` (margin, and futures or swaps in net mode) | Size above the position: "the entire order is rejected", with no automatic trim |

Since results differ, a bot cannot assume the working quantity equals what it sent; read the order back.

## ReduceOnly order is rejected: error codes and messages

Binance documents about a dozen reduce-only codes, and they split into conflicts you can fix and restrictions you cannot.

**Binance USD-M error page, last modified 30 October 2026, read 5 November 2026**

| Code | Message | What it means |
| --- | --- | --- |
| `-2022` | ReduceOnly Order is rejected. | Conflicts with existing open orders; Binance says cancel the existing order and resubmit |
| `-4118` | ReduceOnly Order Failed. Please check your existing position and open orders | With a same-side open order it would create an opposite position and lack margin; cancel the open order |
| `-4062` | Invalid or improper reduceOnly value. | The flag does not fit this request; the page says no more |
| `-2026` | This OrderType is not supported when reduceOnly. | That order type cannot carry the flag |
| `-5047` | The original order is not a reduce-only order. | `reduceOnly=true` sent when modifying a normal order |
| `-4087`, `-4189` | User can only place reduce only order; Restricted account permission: can only place reduceOnly order on the symbol. | Account limited to reducing |
| `-4105`, `-4106`, `-4107` | Symbol is under position risk control, only reduce-only order is allowed. (`-4105`; the others name buys or sells) | Symbol limited to reducing |
| `-4400`, `-4401` | Futures Trading Quantitative Rules violated, only reduceOnly order is allowed, please try again later. (`-4400`) | Binance's quantitative rules; `-4401` covers large positions and says to reduce the position |

Elsewhere, Bybit returns `110023` (you can only reduce your position on this contract) and `110042` (the same before delivery). OKX returns `51169` (no position in this direction), `51170` (same direction as your position) and `51205` (Reduce Only is not available).

Binance's page explains `-2022` and `-4118` only in terms of open orders and maps no other cause to a code, and none of this could be provoked without a key: on 5 November 2026 a reduce-only request with a placeholder key got `-2015` from the USD-M demo host and retCode `10003` from Bybit's testnet, before any order check. Spot codes are in [Binance API error codes](https://fincodelabs.com/en/blog/binance-api-error-codes), and Bybit signing in the [Bybit API Python guide](https://fincodelabs.com/en/blog/bybit-api-python).

## Reduce only order failed on Binance: causes and fixes

Each of these four causes needs a fresh read of the position, not a resend.

1. **No position, or the wrong side.** A stop, a liquidation or a person closed it first. Read the position; if it is flat, cancel the stale exits. Never flip the side to make the order pass.
2. **Size above what is left.** OKX states the rule most clearly: the order plus reduce-only orders ahead of it in price-time priority cannot exceed the position. Size from the position minus the exits you are keeping.
3. **Canceled by a higher-priority order.** Binance's FAQ gives the case: with a long of 100, a sell of 50 at 1,000 is canceled when a sell of 60 at 999 arrives, because the new order has the more aggressive price and exceeds the 50 the first order leaves. Treat a cancel you did not request as a reason to read again. The FAQ adds that market and stop-market reduce-only orders with a quantity at or above the position have the highest priority, and gives the message: Reduce-only order failed. Please cancel existing open orders for this symbol and try again. That describes the rule and is not advice on which to use.
4. **A leftover below the lot step.** Round down to the step from `exchangeInfo`. A residue smaller than the step cannot be sent as a normal order, so decide in advance who handles it. Size minimums differ: `-4164`'s own message exempts reduce-only orders from the minimum notional.

A rejection means your picture of the account is out of date. Compare it with the venue using [position reconciliation](https://fincodelabs.com/en/blog/position-reconciliation). Exits placed as linked pairs are covered in [OCO orders](https://fincodelabs.com/en/blog/oco-order).

## Reduce only in one-way and hedge mode

The flag's role changes with position mode: in hedge mode the position side says which position an order acts on, and Binance refuses the flag altogether.

**Marking a closing order, documents read 5 November 2026**

| Venue | One-way or net mode | Hedge mode | Close without a size |
| --- | --- | --- | --- |
| Binance USD-M | `reduceOnly=true` | `reduceOnly` "cannot be sent"; send `positionSide` `LONG` or `SHORT` | `closePosition=true` on stop-market or take-profit-market algo orders |
| Bybit | `positionIdx=0` with `reduceOnly=true` | `positionIdx` 1 for the buy side, 2 for the sell side; the page asks for `reduceOnly=true` when closing | `qty="0"` with `reduceOnly` and `closeOnTrigger`, up to the maximum order size |
| OKX | `posSide` net with `reduceOnly=true` | Closing orders apply reduce-only whatever the flag says | `closeFraction=1` on algo orders |

On Binance, a mode mismatch can also surface as `-4061` (order's position side does not match user's setting). Two documents disagree here: the algo order page says `closePosition` cannot be used with `reduceOnly`, while the error list keeps `-4138`, Reduce only must be true with closePosition equals true. Follow the endpoint page and test it, which needs a key. On Bybit, an order with `reduceOnly` cannot carry take-profit or stop-loss fields, and one above the maximum order quantity is split into several orders.

## User can only place reduce only order: when the venue limits you

This message means the exchange has limited the account or symbol to reducing, which no code change can fix.

Stop sending opening orders, alert the account's owner and read the venue's notice. A limit based on region or account standing is a matter for the platform's terms; do not try to route around it. Binance's Futures Trading Risk Control FAQ, updated 3 July 2026, describes one trigger based on position size and distance to liquidation, lifted within 10 minutes after a cut of at least 30% of the open notional value or with the liquidation price more than 40% from the mark price. Those conditions can change without notice, and the page names no error code. Check the symbol side at startup: USD-M `exchangeInfo` carries a `POSITION_RISK_CONTROL` filter, and on 5 November 2026 all 804 trading symbols in production showed `positionControlSide` `NONE`. The documents read do not define its other values, so log anything else and stop. Under load, Binance's general information page says close-position, reduce-only and cancel orders are exempt from `-1008` throttling, with conditions such as `positionSide` `BOTH` for reduce-only.

## A tested reduce-only fix flow in Python

Read the position, clear stale exits, size to the lot step and send, then read again at most once if the venue refuses; this runs on a synthetic venue with no network.

```python
from decimal import Decimal as D, ROUND_DOWN

class Rejected(Exception):
    pass

class Venue:
    """Synthetic. Binance's messages; which code goes with which cause is illustrative."""
    def __init__(self, pos, exits=(), closes_before_send=False):
        self.pos, self.exits = D(pos), [D(q) for q in exits]
        self.closes_before_send, self.sent = closes_before_send, 0
    def read(self):
        return self.pos, list(self.exits)
    def cancel_exits(self):
        self.exits.clear()
    def send(self, side, qty):
        self.sent += 1
        if self.closes_before_send:            # a stop closed it after our read
            self.pos, self.closes_before_send = D(0), False
        if self.pos == 0 or (side == "SELL") == (self.pos < 0):  # flat, or adds
            raise Rejected("-2022 ReduceOnly Order is rejected.")
        if qty + sum(self.exits) > abs(self.pos):
            raise Rejected("-4118 ReduceOnly Order Failed.")
        return "NEW"

def exit_order(venue, want, step, attempts=2):
    """Read, clear stale exits, size to the lot step, send. Never loop."""
    want, step = D(str(want)), D(str(step))    # str(): D(0.3) is 0.2999...
    if not (want.is_finite() and step.is_finite() and want > 0 and step > 0):
        return "bad size or step: nothing sent, alert"
    last = "nothing sent"
    for _ in range(attempts):
        pos, exits = venue.read()
        if pos == 0:
            venue.cancel_exits()
            return "flat: stale exits canceled, nothing sent"
        if exits:
            venue.cancel_exits()               # no exit rests until the send
        units = (min(want, abs(pos)) / step).to_integral_value(ROUND_DOWN)
        if units == 0:
            return "below the lot step: nothing sent, alert"
        side = "SELL" if pos > 0 else "BUY"
        try:
            return f"{venue.send(side, units * step)} {side} {units * step}"
        except Rejected as err:
            last = str(err)                    # state changed: read again once
    return f"stopped after {attempts} attempts: {last}, alert"

try:
    Venue("1.000", ["0.600"]).send("SELL", D("1.000"))
except Rejected as err:
    print("no cancel first:", err)
for name, want, venue in [
    ("long 1.000, stale exit 0.600", "1.000", Venue("1.000", ["0.600"])),
    ("flat, stale exit 0.500", "1.000", Venue("0", ["0.500"])),
    ("long 0.0155, want 0.02", "0.02", Venue("0.0155")),
    ("short 0.300", "0.300", Venue("-0.300")),
    ("long 0.0004", "1.000", Venue("0.0004")),
    ("closes between read and send", "1.000", Venue("0.500", closes_before_send=True)),
]:
    print(f"{name}: {exit_order(venue, want, '0.001')} [{venue.sent} sent]")
```

Output on Python 3.11, run 5 November 2026:

```
no cancel first: -4118 ReduceOnly Order Failed.
long 1.000, stale exit 0.600: NEW SELL 1.000 [1 sent]
flat, stale exit 0.500: flat: stale exits canceled, nothing sent [0 sent]
long 0.0155, want 0.02: NEW SELL 0.015 [1 sent]
short 0.300: NEW BUY 0.300 [1 sent]
long 0.0004: below the lot step: nothing sent, alert [0 sent]
closes between read and send: flat: stale exits canceled, nothing sent [1 sent]
```

In the last line the position closed after the read, and the second read ended the attempt instead of a loop. Between the cancel and the send, no exit rests on the book, so whether to cancel a protective stop is a rule for the owner to write. Retry loops around these rejections are one thing to look for in a [trading bot code review](https://fincodelabs.com/en/services/trading-bot-code-review); naming a venue here does not mean Fincode integrates it or has built on it.

## Frequently asked questions

### Why is my reduce only order rejected?

Usually the position has already closed, the order is on the same side as the position, or its size plus other exit orders exceeds the position. Read the position and open orders again before sending anything.

### Can I use reduceOnly in Binance hedge mode?

No. Binance's order page says reduceOnly cannot be sent in Hedge Mode, as read on 5 November 2026. Send positionSide LONG or SHORT instead.

### Does a reduce only order guarantee the position closes?

No. It limits what the order may do, not whether it fills. A limit exit can stay unfilled, and prices can move past any trigger.

### How does reduce only work on Bybit?

Set reduceOnly to true on linear, inverse or option orders. Bybit's help article says an order larger than the position is automatically reduced or cancelled, and that an order with no open position is rejected.

## Sources

- [Binance USD-M Futures: Error codes (last modified 30 October 2026)](https://developers.binance.com/en/docs/products/derivatives-trading-usds-futures/error-code)
- [Binance USD-M Futures: Trade endpoints (New Order, New Algo Order)](https://developers.binance.com/en/docs/catalog/core-trading-derivatives-trading-usd-s-m-futures/api/rest-api/trade)
- [Binance USD-M Futures: General info (-1008 exemptions, last modified 30 October 2026)](https://developers.binance.com/en/docs/products/derivatives-trading-usds-futures/general-info)
- [Binance: Summary of Failed Orders in Binance Futures (updated 7 April 2026)](https://www.binance.com/en/support/faq/summary-of-failed-orders-in-binance-futures-360039707291)
- [Binance: Futures Trading Risk Control FAQ (updated 3 July 2026)](https://www.binance.com/en/support/faq/binance-futures-trading-risk-control-f1afe9cbcd7a438492a0676e024f1897)
- [Bybit V5 API: Place Order (reduceOnly, closeOnTrigger, positionIdx)](https://bybit-exchange.github.io/docs/v5/order/create-order)
- [Bybit V5 API: Error codes (110023, 110042)](https://bybit-exchange.github.io/docs/v5/error)
- [Bybit Help Center: Reduce-Only Order (last updated 29 June 2026)](https://www.bybit.com/en/help-center/article/Reduce-Only-Order)
- [Bybit V5 API: Enums (cancelType)](https://bybit-exchange.github.io/docs/v5/enum)
- [Hyperliquid Docs: Error responses](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/error-responses)
- [Kraken Developers: Errors (EOrder:Reduce only variants)](https://docs.kraken.com/exchange/guides/general/errors)
- [OKX API v5: Place order (reduceOnly, long/short mode)](https://www.okx.com/docs-v5/en/#order-book-trading-trade-post-place-order)
- [Coinbase Advanced Trade API: Create Order](https://docs.cdp.coinbase.com/api-reference/advanced-trade-api/rest-api/orders/create-order)
- [Resmî Gazete: SPK Communiqué III-35/B.2, 13 March 2025, no. 32840, Article 14 (Turkish)](https://www.resmigazete.gov.tr/eskiler/2025/03/20250313-6.htm)
- [Capital Markets Law No. 6362, consolidated text, Article 99/A (Turkish)](https://www.mevzuat.gov.tr/mevzuatmetin/1.5.6362.pdf)

> This guide is general information about software and markets, not investment, legal or tax advice. Automated trading can lose money, past or backtested performance does not guarantee future results, and the rules that apply depend on your jurisdiction and your exchange's terms. Sources, checks and corrections: see the [editorial policy](https://fincodelabs.com/en/editorial-policy).

---

Published by Fincode (Fincode Yazılım ve Teknoloji A.Ş.), a software company in Istanbul, Turkey: https://fincodelabs.com/en/blog/reduce-only-order

Cite as: Fincode, "Reduce only order: meaning, rejections and API fixes", updated November 6, 2026, https://fincodelabs.com/en/blog/reduce-only-order