Manage working orders

Move a resting order to a new price, cancel it, or clear every working order on the account. Use this page when your screen lets a trader drag an order on a chart or click to cancel it. By the end you can move an order and tell a real success from a move that only looked accepted, move an entry with its bracket, and cancel one order or all of them.

Before you start

The examples use the variables from the programmatic quickstart and a limit order resting on ESZ6, the December 2026 E-mini S&P 500 contract, on a Demo in production. A Demo prices futures only from your own futures login, as Place your first order explains, so in the sandbox you run the same calls on a HYPERLIQUID:BTC order, sized in bitcoin, as Test it end to end does. The TypeScript SDK isn’t published, so call the routes over HTTP, as the curl examples do. The TypeScript examples show the same calls through the SDK’s client, with provider and account set. Every call on this page names the order by providerOrderId, the id the provider or the paper book gave it. On a Demo it’s the clientOrderId the order was placed under. You get it in three places, and they agree:

Where	When
The response to Place an order	The moment the order is placed.
List orders	Whenever you ask. With no `filter`, it returns the working orders.
Each frame of the account stream	Every time the account changes, in the `orders` array.

Save the one you’ll work with:

export ORDER_ID=<providerOrderId of the resting order>

Move a resting order to a new price

Send the order’s full description with the new price to Replace an order. It’s one operation under one clientOrderId, so a retry after a timeout can’t move the order twice.

curl -X POST "$TRDRS_API_BASE_URL/api/trading/replace?provider=$PROVIDER&account=$ACCOUNT" \
  -H "Authorization: Bearer $TRDRS_TRADING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "providerOrderId": "'"$ORDER_ID"'",
    "instrument": "ESZ6",
    "side": "sell",
    "qty": 2,
    "orderType": "limit",
    "price": 6497.25,
    "clientOrderId": "replace-1"
  }'

const moved = await client.trading.replaceAnOrder({
  provider,
  account,
  providerOrderId: orderId,
  instrument: 'ESZ6',
  side: 'sell',
  qty: 2,
  orderType: 'limit',
  price: 6497.25,
  clientOrderId: 'replace-1',
})

price is a limit’s resting price or a stop’s trigger. A stop_limit also needs stopLimitPrice, the limit its trigger turns into. orderType must match the order’s type as the engine reports it, because a replace never converts one type into another.On the paper book, send orderQty in place of qty: the order’s whole quantity after the change, filled and open, as FIX’s OrderQty. What can still fill is orderQty less what the order has filled when the change is made, so a fill that lands while your request is on its way is counted. An orderQty no more than what has filled ends the order filled, and nothing rests. Every other provider states the quantity in its own terms and answers orderQty with 400 order_qty_unsupported: send qty there. Send one of the two.Mint a new clientOrderId each time the trader moves the order somewhere new, and reuse it only when you retry the same move.On the paper book, a limit moved to a price the market already crosses fills at once, as a new limit order at that price would. It takes the market’s price, the ask for a buy and the bid for a sell, and never a worse one than the new limit, and it pays a taker’s commission. The old order ends replaced in the same moment, a bracket waiting on the entry is armed by the fill, and nothing rests.

Read the outcome

The response is 200 whenever the replace finished, but that doesn’t mean the order moved. Some providers change an order in one step, and the paper book is one of them. Everywhere else the engine cancels the order and places it again, and that can end several ways. outcome says which:

{ "outcome": "amended", "providerOrderId": "replace-1" }

On a Demo the moved order rests under the replace’s clientOrderId, so providerOrderId is replace-1.

`outcome`	What happened	What to show
`amended`	The provider changed the order in one step. `providerOrderId` is the id it rests under now, a new one on the paper book, or null where nothing rests: an `orderQty` no more than what had filled ended the order filled, or the new price crossed the market and the replacement filled at once.	Success. Use the id from the response; on null, nothing rests, and the account shows the fill.
`replaced`	A new order took the old one’s place. `providerOrderId` is the new id.	Success. Use the new id from now on.
`restored`	The new order was refused, and the original was put back under the id in `providerOrderId`.	The order didn’t move.
`gone`	There was no working order left to move. It may have filled.	Read the account.
`order_lost`	The new order was refused and the original couldn’t be put back, so nothing rests.	Read the account before doing anything else.
`unconfirmed`	The new order didn’t acknowledge, so it may be resting.	Read the account before you act again.

Only amended and replaced are successes. Read providerOrderId from every response, because a replace can give the order a new id. Every other outcome also carries message, which says what happened in English.

Move an entry that has a bracket

An entry keeps its bracket when it moves. Send the replace exactly as above: the bracket waiting on the entry follows it to the order it rests as afterwards, and rests its pairs on that order’s fills. The bracket’s take profits and stop losses keep their prices. If they should move with the entry, change them with Change a bracket.Two moves are refused with 409, and the order stays where it was:

Code	What it means	What to do
`bracket_order`	The order is a take profit or stop loss of a bracket. The body names its `bracketId`.	Change it through its bracket.
`bracket_attached`	The provider holds the bracket with the entry and can’t change the entry in one step, so placing it again would lose the bracket.	Cancel the entry and place it again with its bracket.

Cancel one order

Send the order’s id to Cancel an order. The engine answers only once the provider has accepted the cancel.

curl -X POST "$TRDRS_API_BASE_URL/api/trading/cancel?provider=$PROVIDER&account=$ACCOUNT" \
  -H "Authorization: Bearer $TRDRS_TRADING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "providerOrderId": "'"$ORDER_ID"'" }'

await client.trading.cancelAnOrder({ provider, account, providerOrderId: orderId })

A 200 means the cancel was accepted. The order leaves the next account frame. A cancel takes no clientOrderId, because cancelling the same order twice is harmless.

Cancel every working order

Cancel all working orders cancels them one by one. Send instrument to clear just that instrument, or an empty body to clear the whole account. It leaves positions alone.

curl -X POST "$TRDRS_API_BASE_URL/api/trading/cancel-all?provider=$PROVIDER&account=$ACCOUNT" \
  -H "Authorization: Bearer $TRDRS_TRADING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "instrument": "ESZ6" }'

const swept = await client.trading.cancelAllWorkingOrders({ provider, account, instrument: 'ESZ6' })

The response counts what it cancelled out of what was working:

{ "cancelled": 3, "total": 3 }

If the provider refuses one cancel, the sweep stops there and answers with the refusal’s status, usually 422, and the code cancel_all_incomplete with the same two counts. Read the account and send the sweep again. Cancelling is safe to repeat.

When a change is refused

Route	Status	Code	What it means	What to do
Replace	`400`	`order_type_mismatch`	`orderType` doesn’t match the order’s type.	Send the type the account reports for the order.
Replace	`400`	`reduce_only_exit`	The order can only close a position, and its provider can’t change it in one step, so placing it again would drop that.	Cancel it, and place a new close-only order.
Replace	`400`	`tif_unknown`	The provider doesn’t report the order’s time in force, so it can’t be placed again as it was.	Cancel it, and place it again at the new price.
Replace	`400`	`order_qty_unsupported`	The provider states a replaced order’s quantity in its own terms, so it doesn’t take `orderQty`.	Send `qty`.
Replace	`400`	`quantity_ambiguous`	The request sends both `orderQty` and `qty`.	Send one of the two.
Replace	`400`	none	A field is missing, or a `stop_limit` has no `stopLimitPrice`.	Fix the request.
Replace	`409`	none	This `clientOrderId` was already used. The first move stands.	Read the account.
Replace	`423`	`risk_locked` or `reconciliation_hold`	A hold is on the account. On the paper book an order that only reduces a position still moves, and every other order is refused.	Show the hold.
Cancel	`400`	none	`providerOrderId` is missing.	Send the order’s id.
Cancel all	`422`, or the status the provider’s refusal states	`cancel_all_incomplete`	The provider refused one cancel part way through. `cancelled` and `total` say how far it got.	Read the account, then sweep again.
Cancel all	`400`	none	The provider has no way to list working orders, so it can’t sweep.	Cancel orders one at a time.

A risk lock never blocks a cancel. The lock stops new exposure, and a cancel only removes it.

Test it end to end

On your Demo in the sandbox, with HYPERLIQUID:BTC sized in bitcoin:

Buy 0.01 with a limit well below the market so it rests, and save its providerOrderId.
Replace it at a new price, still below the market, and confirm outcome is amended, as it is on the paper book.
Cancel it using the id the replace returned, then confirm it’s gone from List orders.
Place two resting orders and cancel all. The response reports cancelled equal to total.

Next steps

Close a position

Choose between the four ways out by what each cancels first.

Protect a position

Move a bracket’s take profits and stop losses, which change only through their bracket.

Stream live data

Follow the account’s orders as they change instead of reading them again.

Start here

Trading

Before you start

When a change is refused

Test it end to end

Next steps

Close a position

Protect a position

Stream live data

​Before you start

​When a change is refused

​Test it end to end

​Next steps

Close a position

Protect a position

Stream live data

Before you start

When a change is refused

Test it end to end

Next steps