What causes "Algo order type {order_type:?} requires a trigger price" in nautechsystems/nautilus_trader?

Set the trigger price on the order before submitting through the algo API

Algo order type {order_type:?} requires a trigger price

Error message

Algo order type {order_type:?} requires a trigger price

What it means

The same trigger-price pre-flight check applied on the algo order path of the futures HTTP client: STOP_MARKET, STOP_LIMIT, MARKET_IF_TOUCHED and LIMIT_IF_TOUCHED submissions through the algo endpoints must carry a trigger price. TRAILING_STOP_MARKET is exempt on this path because it is configured via callback rate instead.

Source

Thrown at crates/adapters/binance/src/futures/http/client.rs:2177

        working_type: Option<BinanceWorkingType>,
        good_till_date: Option<i64>,
    ) -> anyhow::Result<OrderStatusReport> {
        let symbol = format_binance_symbol(&instrument_id);
        let size_precision = self.get_size_precision(&symbol)?;
        let price_precision = self.get_price_precision(&symbol)?;

        let binance_side = BinanceSide::try_from(order_side)?;
        let binance_order_type = order_type_to_binance_futures(order_type)?;
        let binance_tif = BinanceTimeInForce::try_from(time_in_force)?;

        let requires_trigger_price = matches!(
            order_type,
            OrderType::StopMarket
                | OrderType::StopLimit
                | OrderType::MarketIfTouched
                | OrderType::LimitIfTouched
        );
        anyhow::ensure!(
            !requires_trigger_price || trigger_price.is_some(),
            "Algo order type {order_type:?} requires a trigger price"
        );

        // Limit orders require time in force
        let requires_time_in_force =
            matches!(order_type, OrderType::StopLimit | OrderType::LimitIfTouched);

        let price_str = price.map(|p| p.to_string());
        let trigger_price_str = if matches!(order_type, OrderType::TrailingStopMarket) {
            None
        } else {
            trigger_price.map(|p| p.to_string())
        };
        let reduce_only = reduce_only_param(reduce_only, position_side);
        let client_id_str = encode_broker_id(&client_order_id, BINANCE_NAUTILUS_FUTURES_BROKER_ID);

        // closePosition is mutually exclusive with quantity and reduceOnly

View on GitHub (pinned to a4b06ed870)

Solutions

Set the trigger price on the order before submitting through the algo API
If the order genuinely has no trigger, submit it through the standard order path instead of the algo path

Defensive patterns

Strategy: validation

Validate before calling

// Before submitting via the algo path
let needs_trigger = matches!(
    order.order_type(),
    OrderType::StopMarket | OrderType::StopLimit | OrderType::MarketIfTouched | OrderType::LimitIfTouched
);
assert!(!needs_trigger || trigger_price.is_some(), "algo order needs trigger price");

Type guard

fn algo_requires_trigger_price(order_type: OrderType) -> bool {
    matches!(
        order_type,
        OrderType::StopMarket | OrderType::StopLimit | OrderType::MarketIfTouched | OrderType::LimitIfTouched
    )
}

Try / catch

On this local rejection, resubmit with a trigger price set, or route the order through the standard (non-algo) submission path if it truly has no trigger.

Prevention

Verify stop-family orders carry triggers before enabling algo routing for them
Test algo-path submissions in testnet before live deployment
Keep trigger-price requirements in the order factory checks

When it happens

Trigger: Algo-routed submissions (strategy config or params selecting the algo API) with a stop-family order and trigger_price None.

Common situations: Enabling algo/SOR routing for stop orders whose factory config omitted the trigger; porting stop logic between the standard and algo order paths.

Related errors

AI-assisted analysis of nautechsystems/nautilus_trader@a4b06ed870 (2026-08-16). Data as JSON: /api/errors/80fedba265c99071. Report an issue: GitHub.