Skip to main content
Change the limit price or trigger price of a resting order — move a stop-loss, take profit sooner, reprice a resting limit, move both legs of a bracket — with 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:
The trigger’s direction and price basis are fixed for the life of the order. triggerType must match the direction the trigger was placed with — always lower for stop-loss, always upper for take-profit, and whichever direction your stop order used (typically upper for a breakout buy). The price must likewise be in the same basis the trigger was placed with — a trigger placed with notionalPrice can only be updated with notionalPrice. This differs from the limit price, whose basis you may switch freely. A new trigger price that the market already satisfies is rejected — an update never causes an immediate fire.
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:
In code — a stop-limit update moving both prices:
The message bytes are identical on EVM and Solana; only the signing primitive differs. The server validates the message byte-for-byte, so:
  • The separator in the header is an em dash (—, U+2014), not a hyphen. Unlike the cancel header, there is no v1 — don’t copy the header from your cancel flow.
  • Line breaks are single \n characters. CRLF, blank lines, and a trailing newline are all rejected.
  • <orderId> is the order’s UUID exactly as returned by POST /order.
  • Issued At is 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> or Limit 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 the trigger.triggerType you 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 lower leg first, each followed by Trigger <Lower|Upper> Limit Price: <decimal> only when that leg carries limitPrice:
  • Every decimal must be byte-identical to the request value — if the body says "4000", the message must say 4000, not 4000.0. No normalization is applied.
Send the exact string you signed back as 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.
A 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 the lower leg first with its limit line right after its trigger line. For an attached pair, orderId is the entry’s attachedBracket.bracketOrderId.
To drop a leg’s limit, send that leg without 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, use Limit Cross Price: in the message and limitCrossPrice in the body.

EVM

SVM (Solana)

What an update does

An accepted update is executed as a cancel-and-replace under the same orderId: 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 its orderId — 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-limit the post-trigger execution limit can move with it — either or both in one update.
  • After the trigger fires, a stop-limit / take-profit-limit order is an ordinary resting limit order; a limit update reprices it in flight — cancelled and re-placed at the new price under the same orderId. A trigger update at that point is rejected: there is no trigger left to move. (stop and take-profit execute at market on firing, so there is nothing to update after the fire.)
A 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 PATCH returns 422 (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, or ORDER_STATUS_TERMINATED return 422 (order is closed and can no longer be updated).
  • A stop, stop-loss, or take-profit that 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 returns 422, as for any trigger that has fired, and so does any update once it has closed. A bracket with a leg already met at placement is closed REASON_ORDER_TRIGGERED_ON_ENTRY, so an update for it returns 422 as 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.
  • 404 covers a missing order, an order outside your API key’s portfolio, and a failed signature. If you get a 404 for an order you know exists, check the signature and the message bytes.
  • 400 means the request itself can’t apply to this order: a field its type does not take (trigger on a limit or bracket, a limit on a stop or take-profit or a bracket), 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) returns 422.