PATCH /orders/{orderId}, no need to cancel and re-place, and the order keeps its orderId. Like cancelling, updating requires a wallet signature in addition to your API key: you construct a short plaintext message, sign it with the funder wallet, and send both with the new price(s). The update signature is offchain and gasless; no transaction is sent, and the original order signature and token approval stay untouched.
What can be updated
An update carries a new limit price, a new trigger price, or both — or, on a bracket, both legs — depending on the order type:trailing-stop and trailing-stop-limit are not updatable: a PATCH returns 422. Cancel and place a new order to change trailPercent or activationPrice; see Trailing Stop Orders.
Limit price — send exactly one of limitNotionalPrice (USD price of the target asset) or limitCrossPrice (pair rate, target / contra). You are not restricted to the basis the order was placed with; the order carries whichever basis was set last. On the trigger types the limit is the post-trigger execution limit: the price the order fills at once the trigger has fired. See Pricing basis.
Trigger price — send a trigger object with the same shape as submit’s: exactly one of notionalPrice or crossPrice, plus triggerType (lower or upper). A trigger update moves the threshold only:
Bracket legs — send triggers with both legs, one lower (the stop-loss) and one upper (the take-profit), in any order. Each leg carries its new trigger price in the basis it was placed with and an optional limitPrice, in the same units as that leg’s trigger price (USD for notionalPrice, pair rate for crossPrice). The update replaces both legs’ prices and limits: a leg’s submitted state is its new state, so a leg sent without limitPrice sells at market when it fires, which removes any limit it had. Leg count and directions are fixed, and the same immediate-fire rule applies to each leg. A bracket takes no trigger object and no limit fields.
An attached bracket is updated through the pair’s own order: once the entry has filled, the entry’s attachedBracket.bracketOrderId is the orderId to PATCH. Before the first fill bracketOrderId is null because the pair is not an order yet, so there is nothing to update; triggers sent to the entry itself returns 422 on a market or twap entry and 400 on a limit entry. To change the legs before the first fill, cancel the entry and place a new one. An update applies the units above to both legs: for a pair placed before October 27 whose notionalPrice leg applied its limitPrice as a pair rate, send the new limitPrice in USD, and the leg reads it back as a USD price from then on.
To change any other parameter of an order, cancel it and place a new one.
The update message
Construct this exact UTF-8 string — a three-line header followed by one price line per updated value, joined by single newlines:-
The separator in the header is an em dash (
—, U+2014), not a hyphen. Unlike the cancel header, there is nov1— don’t copy the header from your cancel flow. -
Line breaks are single
\ncharacters. CRLF, blank lines, and a trailing newline are all rejected. -
<orderId>is the order’s UUID exactly as returned byPOST /order. -
Issued Atis an RFC3339 UTC timestamp and must be within 1 minute of server time — construct and sign the message immediately before sending. The stamp is what stops a captured signature from being replayed later to revert a newer price. Sub-second precision (e.g.new Date().toISOString()) is supported and recommended: two updates on the same order in the same second need distinct stamps to produce distinct signed bytes. -
The Limit line is exactly one of
Limit Cross Price: <decimal>orLimit Notional Price: <decimal>, matching the limit field you send in the request body. -
The Trigger line is
Trigger <Lower|Upper> <Cross|Notional> Price: <decimal>— direction matching thetrigger.triggerTypeyou send (lower→Lower,upper→Upper), kind matching which trigger price field is set. - On a single-trigger order, include only the lines for values you are updating, each at most once, with at least one present; when both are present the Limit line comes first.
-
A bracket update has no Limit line and one Trigger line per leg, the
lowerleg first, each followed byTrigger <Lower|Upper> Limit Price: <decimal>only when that leg carrieslimitPrice: -
Every decimal must be byte-identical to the request value — if the body says
"4000", the message must say4000, not4000.0. No normalization is applied.
updateMessage in the request body. The message is plaintext by design: a wallet’s message-signing prompt shows the user precisely which order is being repriced, and to what.
Signing the message
Sign with the funder wallet — the same wallet that signed the order. A signature from any other key is rejected.On EVM, the signature is verified onchain against the funder address using ERC-1271 with ERC-6492 support. EOAs, deployed smart accounts, and counterfactual (not-yet-deployed) smart accounts all work — sign with whatever
personal_sign flow the wallet provides.Examples
Move a stop-loss
The headline use case: raise a resting stop-loss’s trigger to $1,800 (notional basis) without touching anything else. Shown for EVM; on Solana only the signing primitive differs, exactly as in the limit examples below.take-profit update is identical with triggerType: "upper" and a Trigger Upper ... line. On a stop-limit or take-profit-limit you can move the limit in the same request: add the limit field to the body and its Limit ... Price: line to the message, above the trigger line.
Move both legs of a bracket
Tighten a resting bracket: raise the stop-loss to $1,800 and have it sell no lower than $1,774, and lift the take-profit to $2,400 at market. Both legs are always sent, in any order; the message signs thelower leg first with its limit line right after its trigger line. For an attached pair, orderId is the entry’s attachedBracket.bracketOrderId.
limitPrice and without its Limit Price line; the leg then sells at market when it fires. The order reads the new legs back under brackets, on REST and on the WebSocket, once the update applies. For an attached pair, the entry’s attachedBracket legs on GET /orders/{orderId} show the pair’s new legs too.
A bracket body with the wrong shape is rejected with 400 before the signature is checked: one or three legs, two legs in the same direction, a leg with both or neither trigger price, a limitPrice that is not positive, or triggers sent together with trigger, limitNotionalPrice, or limitCrossPrice. Sending a bracket the single-trigger trigger object, or a limit field on its own, is 400 as well.
Reprice a resting limit
Both examples move a resting limit order’s price to $4,000 (notional basis). To price in the pair rate instead, useLimit Cross Price: in the message and limitCrossPrice in the body.
EVM
EVM
SVM (Solana)
SVM (Solana)
What an update does
An accepted update is executed as a cancel-and-replace under the sameorderId: the remaining quantity is re-placed with the new price(s), and the order’s identity is stable everywhere — GET /orders/{orderId}, the Orders WebSocket, and any state you key by orderId.
Partial fills are kept. Fills that already settled onchain are final; only the unfilled remainder is re-placed.
The update is visible on the WebSocket. While the update is in flight, order frames carry pendingUpdate: true; once applied, the flag clears and the frames carry the new limitNotionalPrice / limitCrossPrice and trigger, or the new brackets legs. If the flag clears and the prices are unchanged, the update was rejected downstream.
Which orders can be updated
An order is updatable while it is live and unfilled under itsorderId — status ORDER_STATUS_ACCEPTED or ORDER_STATUS_PARTIALLY_FILLED, whether it is resting at a limit or armed waiting on a trigger. See Order statuses.
For the trigger types, what is updatable depends on whether the trigger has fired:
- Before the trigger fires, the trigger price can move, and on
stop-limit/take-profit-limitthe post-trigger execution limit can move with it — either or both in one update. - After the trigger fires, a
stop-limit/take-profit-limitorder is an ordinary resting limit order; a limit update reprices it in flight — cancelled and re-placed at the new price under the sameorderId. A trigger update at that point is rejected: there is no trigger left to move. (stopandtake-profitexecute at market on firing, so there is nothing to update after the fire.)
bracket is updatable while neither leg has fired. Once a leg fires the bracket is executing its exit and an update returns 422; a leg that fires while an update is in flight wins, and the update is rejected downstream: the PATCH has already returned 200, and the order’s frames show pendingUpdate clearing with the legs unchanged. An attached pair’s size grows with its entry’s fills, and an update re-checks the same minimum order size placement enforces, against the pair’s current size at the new prices — a pair still below the minimum is rejected with 400 (order below minimum notional size requirement) until further entry fills have grown it past the minimum; retry after the next fill.
The mechanics below apply to every updatable type:
- One update at a time. While an update is in flight, another
PATCHreturns422(order already has a pending update). Wait for the WebSocket frame with the new price, or re-read the order, before sending the next one. - Closed orders can’t be updated. Orders in
ORDER_STATUS_FILLED,ORDER_STATUS_CANCELLED(expired orders included),ORDER_STATUS_REJECTED, orORDER_STATUS_TERMINATEDreturn422(order is closed and can no longer be updated). - A
stop,stop-loss, ortake-profitthat fires on entry has nothing to reprice. If the market already satisfies the trigger the instant the order is placed, it executes without ever resting; a trigger update for it returns422, as for any trigger that has fired, and so does any update once it has closed. Abracketwith a leg already met at placement is closedREASON_ORDER_TRIGGERED_ON_ENTRY, so an update for it returns422as a closed order. - An update can race a fill. If the order fills before the update lands, the request returns
422— treat that as the order having executed at the old price, not as a failure to retry. 404covers a missing order, an order outside your API key’s portfolio, and a failed signature. If you get a404for an order you know exists, check the signature and the message bytes.400means the request itself can’t apply to this order: a field its type does not take (triggeron alimitorbracket, a limit on astoportake-profitor abracket), a trigger in a different direction or basis, a price or leg limit that is not positive, or new prices that would put the order below the minimum order size (order below minimum notional size requirement). Fix the request rather than retrying it. An order type that takes no update at all (market,twap) returns422.