# Create new order

`POST /orders`

Places an order and returns it as the trading engine stored it. Increase orders (`market`, `limit`, `stop_market`, `stop_limit`) open or grow a position;
close orders (`stop`, `take`, `trailing_stop`) attach to an existing position through `positionId`.

`amount` is read in a different unit by each of the two: on an increase order it is a quote amount reserved from the free balance, on a close
order it is the base asset size of the position to close, with nothing reserved. The rest of the size fields (`expectedAmount`, `sizeMode`,
`baseSize`, `leverage`) belong to increase orders only.

Beyond the field-level schema the request is checked for:

- **Shape for the type.** Every rejection here is a `400` whose code names the field combination at fault:
  - size — `amount_not_positive`, `base_size_required`, `base_size_negative`, `base_size_not_allowed`;
  - leverage — `leverage_required`, `leverage_negative`;
  - trigger price — `trigger_price_required`, `trigger_price_negative`;
  - stop-loss / take-profit attached to an increase order — `stop_trigger_price_negative`, `take_trigger_price_negative`,
    `stop_trigger_price_gt_trigger_price`, `stop_trigger_price_lt_trigger_price`, `take_trigger_price_gt_trigger_price`,
    `take_trigger_price_lt_trigger_price`;
  - stop-limit price — `stop_limit_price_required`, `stop_limit_price_negative`, `stop_limit_price_gt_trigger_price`,
    `stop_limit_price_lt_trigger_price`;
  - trailing stop — `trailing_stop_activation_price_negative`, `trailing_stop_offset_required`, `trailing_stop_offset_conflict`,
    `trailing_stop_offset_negative`, `trailing_stop_offset_percent_negative`, `trailing_stop_offset_percent_gte_one`;
  - close orders — `position_id_required`.
- **Leverage** of an increase order. Must stay within market bounds: not below the market minimum and not above the phase maximum,
  with `invalid_leverage` (`leverage` plus `minLeverage` or `maxLeverage` in the body).
- **Account.** Must belong to the caller and be in a trading status; increase orders are additionally refused while the account is locked by the managed
  capital limit, and need `amount` available as free balance.
- **Market.** Must be open and inside the category the account may trade (crypto or RWA). A close-only market takes nothing but a `take` order created
  without a trigger price.
- **Position**, when `positionId` is given: it must exist (`position_not_found`), be open, sit on the same account, belong to the same
  market and run in the same direction as the order (`position_not_available`).
- **Trigger price**, against the current market price and — for `stop` / `take` — against the liquidation price of the position
  (`trigger_price_gt_current`, `trigger_price_lt_current`, `trigger_price_gt_liquidation`, `trigger_price_lt_liquidation`).
  A `market` order with an attached stop-loss / take-profit is checked against the liquidation price its position would have after the fill:
  `market_price_unavailable` when there is no current price to check against, `order_validation_invariant` when the size fields needed for
  that projection are missing.
- **Notional** of an increase order. `(amount − fee) × leverage` must fit the max open notional the market allows in that direction
  (`order_exceeds_max_open_notional`).

A deferred order is not executed here, so it can still fail when its trigger fires later: it then ends up with status `canceled_by_error` and an
`errorCode` (`insufficient_reserve_at_execution`, `order_below_min_notional`, `order_exceeds_market_depth`, `order_exceeds_max_open_notional`,
`order_zero_size_at_execution`, `slippage_tolerance`, `market_close_only_at_execution`), and its reserve is released.

Send an `x-idempotency-key` header to make the call replay-safe: inside the replay window stated on that header, the same key on the same route replays the stored response (marked with `X-Idempotency-Cached: true` and `X-Idempotency-Timestamp`) instead of acting again, and a second call arriving while the first one is still running gets `409` (`idempotency_key_in_flight`).

## Authorization

bearer: http · bearer (required). Personal API key, prefixed with `usk_`.

## Parameters

- header: x-idempotency-key (string; optional). Idempotency key — any opaque string, a uuid v4 works well. Repeating the call with the same key on this route within 1 hour replays the stored response instead of acting again; a replay carries `X-Idempotency-Cached: true` and `X-Idempotency-Timestamp`. Omit the header to opt out.

Type: string

Example: "9f1c2b7e-5a3d-4f61-9b0e-2c7d4a8e1f35"

## Request body · OrderCreateRequest

application/json · required

Schema: OrderCreateRequest

Type: object

Required fields: accountId, marketId, type, direction, amount

Required field types: accountId (string · uuid; required), marketId (string · uuid; required), type (string · enum; required), direction (string · enum; required), amount (string · int32; required)

- accountId (string · uuid; required)

accountId example: 00000000-0000-4000-8000-000000000000

accountId.Type: string · uuid

accountId.Trader account the order is placed on. Must belong to the caller.

accountId.format: uuid

accountId.pattern: ^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$

- marketId (string · uuid; required)

marketId example: 00000000-0000-4000-8000-000000000000

marketId.Type: string · uuid

marketId.Market the order is placed on, as returned by `GET /v2/markets`.

marketId.format: uuid

marketId.pattern: ^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$

- type (string · enum; required)

type example: market

type.Type: string · enum

type.Order type. Increase (position-opening) types: `market`, `limit`, `stop_market`, `stop_limit`. Close types, attached to an existing position: `stop`, `take`, `trailing_stop`. `liquidation` is raised by the platform itself and `add_margin` / `remove_margin` are legacy — none of the three is accepted here.

type.Allowed values: ["market","limit","stop","trailing_stop","take","stop_limit","stop_market"]

- direction (string · enum; required)

direction example: long

direction.Type: string · enum

direction.Order direction. For a close order it must match the direction of the position it is attached to.

direction.Allowed values: ["long","short"]

- positionId (string · uuid · nullable; optional)

positionId example: 00000000-0000-4000-8000-000000000000

positionId.Type: string · uuid · nullable

positionId.Position a close order (`stop`, `take`, `trailing_stop`) is attached to. Required for those types, ignored for increase orders.

positionId.format: uuid

positionId.pattern: ^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$

- amount (string · int32; required)

amount example: 100000000000

amount.Type: string · int32

amount.What the order is sized by, fp9 raw — the unit depends on the order class. On an increase order (`market`, `limit`, `stop_market`, `stop_limit`) it is a **quote** amount reserved from the free balance (margin, fee, spread and buffer): the account must hold at least this much, and the reserve is released when the order is cancelled. On a close order (`stop`, `take`, `trailing_stop`) it is the **base asset** size of the position to close and nothing is reserved; a size larger than the position holds closes it in full.

amount.format: int32

amount.pattern: ^(?:-?[1-9][0-9]*|0)$

- expectedAmount (string · int32 · nullable; optional)

expectedAmount example: 0

expectedAmount.Type: string · int32 · nullable

expectedAmount.Slippage tolerance for increase orders: the position size the caller expects for `amount`, fp9 raw. Execution outside the tolerance fails with `slippage_tolerance`. Omitted or `0` — no tolerance check. Not applicable to close orders.

expectedAmount.format: int32

expectedAmount.pattern: ^(?:-?[1-9][0-9]*|0)$

- leverage (string · int32 · nullable; optional)

leverage example: 10000000000

leverage.Type: string · int32 · nullable

leverage.Leverage, fp9 raw (`10000000000` = 10x). Required for increase orders and must be within the leverage bounds of the market.

leverage.format: int32

leverage.pattern: ^(?:-?[1-9][0-9]*|0)$

- triggerPrice (string · int32 · nullable; optional)

triggerPrice example: 65000000000000

triggerPrice.Type: string · int32 · nullable

triggerPrice.Price at which the order fires, fp9 raw. Required for `limit`, `stop`, `take`, `stop_market` and `stop_limit`, and rejected for `market`. For `stop` / `take`, `0` means the order is created without a trigger and can be set later.

triggerPrice.format: int32

triggerPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- stopTriggerPrice (string · int32 · nullable; optional)

stopTriggerPrice example: 1000000000

stopTriggerPrice.Type: string · int32 · nullable

stopTriggerPrice.Stop-loss attached to an increase order, fp9 raw. Must sit below the entry trigger price for `long` and above it for `short`.

stopTriggerPrice.format: int32

stopTriggerPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- takeTriggerPrice (string · int32 · nullable; optional)

takeTriggerPrice example: 1000000000

takeTriggerPrice.Type: string · int32 · nullable

takeTriggerPrice.Take-profit attached to an increase order, fp9 raw. Must sit above the entry trigger price for `long` and below it for `short`.

takeTriggerPrice.format: int32

takeTriggerPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- trailingStopActivationPrice (string · int32 · nullable; optional)

trailingStopActivationPrice example: 1000000000

trailingStopActivationPrice.Type: string · int32 · nullable

trailingStopActivationPrice.Price at which a `trailing_stop` starts trailing, fp9 raw. Omitted — the order trails from the moment it is created.

trailingStopActivationPrice.format: int32

trailingStopActivationPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- trailingStopOffset (string · int32 · nullable; optional)

trailingStopOffset example: 1000000000

trailingStopOffset.Type: string · int32 · nullable

trailingStopOffset.Trailing distance as an absolute quote amount, fp9 raw. Exactly one of `trailingStopOffset` / `trailingStopOffsetPercent` is required.

trailingStopOffset.format: int32

trailingStopOffset.pattern: ^(?:-?[1-9][0-9]*|0)$

- trailingStopOffsetPercent (string · int32 · nullable; optional)

trailingStopOffsetPercent example: 50000000

trailingStopOffsetPercent.Type: string · int32 · nullable

trailingStopOffsetPercent.Trailing distance as a fraction of price, fp9 raw and strictly below `1000000000` (100%). Exactly one of `trailingStopOffset` / `trailingStopOffsetPercent` is required.

trailingStopOffsetPercent.format: int32

trailingStopOffsetPercent.pattern: ^(?:-?[1-9][0-9]*|0)$

- stopLimitPrice (string · int32 · nullable; optional)

stopLimitPrice example: 1000000000

stopLimitPrice.Type: string · int32 · nullable

stopLimitPrice.Limit price a `stop_limit` order is placed at once its trigger fires, fp9 raw. Required for that type; must be at or below the trigger price for `long` and at or above it for `short`.

stopLimitPrice.format: int32

stopLimitPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- sizeMode (string · enum; optional)

sizeMode example: quote

sizeMode.Type: string · enum

sizeMode.How the size of an increase order is expressed: `quote` (default) sizes it by `amount`, `base` sizes it by `baseSize` while `amount` stays the reserve. Increase orders only — a close order is always sized by `amount` in base asset units.

sizeMode.Allowed values: ["quote","base"]

- baseSize (string · int32 · nullable; optional)

baseSize example: 1000000000

baseSize.Type: string · int32 · nullable

baseSize.Order size in base asset units, fp9 raw. Required when `sizeMode` is `base` and rejected otherwise, and meaningful for increase orders only.

baseSize.format: int32

baseSize.pattern: ^(?:-?[1-9][0-9]*|0)$

Example



```json
{
  "accountId": "00000000-0000-4000-8000-000000000000",
  "marketId": "00000000-0000-4000-8000-000000000000",
  "type": "market",
  "direction": "long",
  "amount": "100000000000"
}
```

## Example · cURL

```bash
curl --request POST 'https://api.upscale.trade/orders' \
  --header 'Accept: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "accountId": "00000000-0000-4000-8000-000000000000",
  "marketId": "00000000-0000-4000-8000-000000000000",
  "type": "market",
  "direction": "long",
  "amount": "100000000000"
}'
```

## Example · JavaScript

```javascript
const response = await fetch("https://api.upscale.trade/orders", {
  method: "POST",
  headers: {
    "Accept": "application/json",
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: "{\n  \"accountId\": \"00000000-0000-4000-8000-000000000000\",\n  \"marketId\": \"00000000-0000-4000-8000-000000000000\",\n  \"type\": \"market\",\n  \"direction\": \"long\",\n  \"amount\": \"100000000000\"\n}",
});
console.log(response.status, await response.text());
```

## Example · Python

```python
import requests

response = requests.request(
    "POST",
    "https://api.upscale.trade/orders",
    headers={"Accept":"application/json","Authorization":"Bearer YOUR_API_KEY","Content-Type":"application/json"},
    data="{\n  \"accountId\": \"00000000-0000-4000-8000-000000000000\",\n  \"marketId\": \"00000000-0000-4000-8000-000000000000\",\n  \"type\": \"market\",\n  \"direction\": \"long\",\n  \"amount\": \"100000000000\"\n}",
    timeout=30,
)
print(response.status_code, response.text)
```

## Response 401

**401**  — Unauthorized

## Response 403

**403**  — The account belongs to another user (`account_access_denied`), or the request is authenticated with an API key while `api_trading` is disabled on the account (`api_trading_not_enabled`). Trading on the account is over in its current status (`challenge_closed`), or the account is locked by the managed capital limit (`funded_limit_trading_locked`). The market is paused (`market_paused`) or accepts closing orders only (`market_close_only`).

## Response 404

**404**  — No such account, market, or position.

## Response 409

**409**  — Another call with the same `x-idempotency-key` is still running (`idempotency_key_in_flight`). Retry once it finishes.

## Response 429

**429**  — Rate limit of the API key exceeded (`api_key_rate_limit_exceeded`). `Retry-After` says when to come back; the body carries the bucket (`read` / `write`), the window that tripped, its limit and `retryAt`.

## Response default · OrderResponse

**default** application/json — Response

Schema: OrderResponse

Type: object

Required fields: id, txId, trader, market, status, type, direction, triggerPrice, requestedTriggerPrice, stopPrice, limitPrice, stopTriggerPrice, takeTriggerPrice, trailingStopActivationPrice, trailingStopOffset, trailingStopOffsetPercent, leverage, index, positionId, parentOrderId, expiration, amount, indexPrice, settlementOraclePrice, createdAt, error, realizedPnl, rawRealizedPnl, profitAdjustmentApplied, executedAfterPause, sizeMode, baseSize, reservedAmount, errorCode, reason

Required field types: id (string · uuid; required), txId (string; required), trader (string · uuid; required), market (string · uuid; required), status (string · enum; required), type (string · enum; required), direction (string · enum; required), triggerPrice (string · int32; required), requestedTriggerPrice (string · int32 · nullable; required), stopPrice (string · int32; required), limitPrice (string · int32; required), stopTriggerPrice (string · int32; required), takeTriggerPrice (string · int32; required), trailingStopActivationPrice (string · int32; required), trailingStopOffset (string · int32; required), trailingStopOffsetPercent (string · int32; required), leverage (string · int32 · nullable; required), index (string; required), positionId (string[]; required), parentOrderId (string[]; required), expiration (string · date-time · nullable; required), amount (string · int32; required), indexPrice (string · int32 · nullable; required), settlementOraclePrice (string · int32; required), createdAt (string · date-time; required), error (string[]; required), realizedPnl (string · int32 · nullable; required), rawRealizedPnl (string · int32 · nullable; required), profitAdjustmentApplied (boolean; required), executedAfterPause (boolean; required), sizeMode (string · enum; required), baseSize (string · int32 · nullable; required), reservedAmount (string · int32 · nullable; required), errorCode (string[]; required), reason (string · enum · nullable; required)

- id (string · uuid; required)

id example: 00000000-0000-4000-8000-000000000000

id.Type: string · uuid

id.Order identifier.

id.format: uuid

id.pattern: ^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$

- txId (string; required)

txId example: string

txId.Type: string

txId.Order identifier. Kept for backward compatibility, always equal to `id`.

- trader (string · uuid; required)

trader example: 00000000-0000-4000-8000-000000000000

trader.Type: string · uuid

trader.Trader account the order belongs to.

trader.format: uuid

trader.pattern: ^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$

- market (string · uuid; required)

market example: 00000000-0000-4000-8000-000000000000

market.Type: string · uuid

market.Market the order is placed on.

market.format: uuid

market.pattern: ^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$

- status (string · enum; required)

status example: active

status.Type: string · enum

status.Lifecycle state: `active` while it waits, `executed` once filled, `canceled` when cancelled by the trader or the platform, `canceled_by_update` when replaced by an edit, `canceled_by_position` when the position it was attached to went away, `canceled_by_error` when execution failed — see `errorCode`.

status.Allowed values: ["active","canceled","canceled_by_update","canceled_by_error","canceled_by_position","executed"]

- type (string · enum; required)

type example: market

type.Type: string · enum

type.Order type. `liquidation` marks an order the engine raised itself.

type.Allowed values: ["market","limit","stop","trailing_stop","take","stop_limit","stop_market","liquidation"]

- direction (string · enum; required)

direction example: long

direction.Type: string · enum

direction.Order direction.

direction.Allowed values: ["long","short"]

- triggerPrice (string · int32; required)

triggerPrice example: 1000000000

triggerPrice.Type: string · int32

triggerPrice.Price at which the order fires, fp9 raw. `0` when the order carries no trigger.

triggerPrice.format: int32

triggerPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- requestedTriggerPrice (string · int32 · nullable; required)

requestedTriggerPrice example: 1000000000

requestedTriggerPrice.Type: string · int32 · nullable

requestedTriggerPrice.Trigger price as requested, before the engine pushed it out to the minimum stop distance, fp9 raw. Null when the requested price was kept as is.

requestedTriggerPrice.format: int32

requestedTriggerPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- stopPrice (string · int32; required)

stopPrice example: 1000000000

stopPrice.Type: string · int32

stopPrice.Trigger price of a `stop_market` / `stop_limit` order, fp9 raw; `0` for every other type.

stopPrice.format: int32

stopPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- limitPrice (string · int32; required)

limitPrice example: 1000000000

limitPrice.Type: string · int32

limitPrice.Price the order is placed at once triggered, fp9 raw: the stop-limit price, falling back to the trigger price.

limitPrice.format: int32

limitPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- stopTriggerPrice (string · int32; required)

stopTriggerPrice example: 1000000000

stopTriggerPrice.Type: string · int32

stopTriggerPrice.Stop-loss attached to the order, fp9 raw. `0` when none is attached.

stopTriggerPrice.format: int32

stopTriggerPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- takeTriggerPrice (string · int32; required)

takeTriggerPrice example: 1000000000

takeTriggerPrice.Type: string · int32

takeTriggerPrice.Take-profit attached to the order, fp9 raw. `0` when none is attached.

takeTriggerPrice.format: int32

takeTriggerPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- trailingStopActivationPrice (string · int32; required)

trailingStopActivationPrice example: 1000000000

trailingStopActivationPrice.Type: string · int32

trailingStopActivationPrice.Price at which a trailing stop starts trailing, fp9 raw. `0` when it trails from creation.

trailingStopActivationPrice.format: int32

trailingStopActivationPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- trailingStopOffset (string · int32; required)

trailingStopOffset example: 1000000000

trailingStopOffset.Type: string · int32

trailingStopOffset.Trailing distance as an absolute quote amount, fp9 raw. `0` when the distance is set as a percent.

trailingStopOffset.format: int32

trailingStopOffset.pattern: ^(?:-?[1-9][0-9]*|0)$

- trailingStopOffsetPercent (string · int32; required)

trailingStopOffsetPercent example: 1000000000

trailingStopOffsetPercent.Type: string · int32

trailingStopOffsetPercent.Trailing distance as a fraction of price, fp9 raw. `0` when the distance is absolute.

trailingStopOffsetPercent.format: int32

trailingStopOffsetPercent.pattern: ^(?:-?[1-9][0-9]*|0)$

- leverage (string · int32 · nullable; required)

leverage example: 1000000000

leverage.Type: string · int32 · nullable

leverage.Leverage of the order, fp9 raw. Null on close orders, which inherit the leverage of the position.

leverage.format: int32

leverage.pattern: ^(?:-?[1-9][0-9]*|0)$

- index (string; required)

index example: string

index.Type: string

index.Order identifier. Kept for backward compatibility, always equal to `id`.

- positionId (string[]; required)

positionId example: [
  "string"
]

positionId.Type: string[]

positionId.Position a close order is attached to. Null for orders that open or grow a position.

positionId.[]Type: string

- parentOrderId (string[]; required)

parentOrderId example: [
  "string"
]

parentOrderId.Type: string[]

parentOrderId.Order this one was spawned from: a stop or take created out of `stopTriggerPrice` / `takeTriggerPrice`, or the limit order a `stop_limit` turned into. Null when the order was submitted directly.

parentOrderId.[]Type: string

- expiration (string · date-time · nullable; required)

expiration example: 2026-05-01T12:30:00.000Z

expiration.Type: string · date-time · nullable

expiration.Always null. Kept for backward compatibility — orders do not expire on their own.

expiration.format: date-time

- amount (string · int32; required)

amount example: 1000000000

amount.Type: string · int32

amount.Size of the order, fp9 raw, in the unit its class uses: on an increase order a quote amount — the reserve while it waits, and what it actually spent once executed; on a close order (`stop`, `take`, `trailing_stop`) the base asset size it closes, as requested at creation.

amount.format: int32

amount.pattern: ^(?:-?[1-9][0-9]*|0)$

- indexPrice (string · int32 · nullable; required)

indexPrice example: 1000000000

indexPrice.Type: string · int32 · nullable

indexPrice.Index price the order executed at, fp9 raw. Null while the order has not executed.

indexPrice.format: int32

indexPrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- settlementOraclePrice (string · int32; required)

settlementOraclePrice example: 1000000000

settlementOraclePrice.Type: string · int32

settlementOraclePrice.Always `1000000000` (1.0). Kept for backward compatibility.

settlementOraclePrice.format: int32

settlementOraclePrice.pattern: ^(?:-?[1-9][0-9]*|0)$

- createdAt (string · date-time; required)

createdAt example: 2026-05-01T12:30:00.000Z

createdAt.Type: string · date-time

createdAt.When the order was accepted.

createdAt.format: date-time

- error (string[]; required)

error example: [
  "string"
]

error.Type: string[]

error.Always null. Kept for backward compatibility — use `errorCode`.

error.[]Type: string

- realizedPnl (string · int32 · nullable; required)

realizedPnl example: 1000000000

realizedPnl.Type: string · int32 · nullable

realizedPnl.Pnl realised by this order, fp9 raw. Set only on an executed close order; null while pending and on orders that open or grow a position.

realizedPnl.format: int32

realizedPnl.pattern: ^(?:-?[1-9][0-9]*|0)$

- rawRealizedPnl (string · int32 · nullable; required)

rawRealizedPnl example: 1000000000

rawRealizedPnl.Type: string · int32 · nullable

rawRealizedPnl.Realised pnl before the 60-second adjustment, fp9 raw. Differs from `realizedPnl` only when the adjustment fired.

rawRealizedPnl.format: int32

rawRealizedPnl.pattern: ^(?:-?[1-9][0-9]*|0)$

- profitAdjustmentApplied (boolean; required)

profitAdjustmentApplied example: true

profitAdjustmentApplied.Type: boolean

profitAdjustmentApplied.Whether the 60-second adjustment capped the profit of this order — inside a minute of an open or increase the position pnl cannot grow above what it was at that moment.

- executedAfterPause (boolean; required)

executedAfterPause example: true

executedAfterPause.Type: boolean

executedAfterPause.Whether the order executed after a market pause. Not set by the current engine — always `false`.

- sizeMode (string · enum; required)

sizeMode example: quote

sizeMode.Type: string · enum

sizeMode.How the size was expressed on creation: `quote` sizes the order by `amount`, `base` sizes it by `baseSize`.

sizeMode.Allowed values: ["quote","base"]

- baseSize (string · int32 · nullable; required)

baseSize example: 1000000000

baseSize.Type: string · int32 · nullable

baseSize.Order size in base asset units, fp9 raw. Null for `quote`-sized orders.

baseSize.format: int32

baseSize.pattern: ^(?:-?[1-9][0-9]*|0)$

- reservedAmount (string · int32 · nullable; required)

reservedAmount example: 1000000000

reservedAmount.Type: string · int32 · nullable

reservedAmount.Quote amount reserved when the order with sizeMode=base was created, fp9 raw. Stays at the original reserve after execution, while `amount` is rewritten to what was spent. Null for `quote`-sized orders, where `amount` is the reserve.

reservedAmount.format: int32

reservedAmount.pattern: ^(?:-?[1-9][0-9]*|0)$

- errorCode (string[]; required)

errorCode example: [
  "string"
]

errorCode.Type: string[]

errorCode.Why execution failed, set together with status `canceled_by_error` — for example `insufficient_reserve_at_execution`, `order_below_min_notional`, `order_exceeds_market_depth` or `slippage_tolerance`. Null otherwise.

errorCode.[]Type: string

- reason (string · enum · nullable; required)

reason example: force_close

reason.Type: string · enum · nullable

reason.Why the platform cancelled the order itself, for example `force_close` or `weekly_session_risk_close`. Null for trader-driven cancellations.

reason.Allowed values: ["force_close","stop_accounts_fail","stop_accounts_freeze","stop_accounts_promote","stop_accounts_manual","weekly_session_risk_close",null]

Example



```json
{
  "id": "00000000-0000-4000-8000-000000000000",
  "txId": "string",
  "trader": "00000000-0000-4000-8000-000000000000",
  "market": "00000000-0000-4000-8000-000000000000",
  "status": "active",
  "type": "market",
  "direction": "long",
  "triggerPrice": "1000000000",
  "requestedTriggerPrice": "1000000000",
  "stopPrice": "1000000000",
  "limitPrice": "1000000000",
  "stopTriggerPrice": "1000000000",
  "takeTriggerPrice": "1000000000",
  "trailingStopActivationPrice": "1000000000",
  "trailingStopOffset": "1000000000",
  "trailingStopOffsetPercent": "1000000000",
  "leverage": "1000000000",
  "index": "string",
  "positionId": [
    "string"
  ],
  "parentOrderId": [
    "string"
  ],
  "expiration": "2026-05-01T12:30:00.000Z",
  "amount": "1000000000",
  "indexPrice": "1000000000",
  "settlementOraclePrice": "1000000000",
  "createdAt": "2026-05-01T12:30:00.000Z",
  "error": [
    "string"
  ],
  "realizedPnl": "1000000000",
  "rawRealizedPnl": "1000000000",
  "profitAdjustmentApplied": true,
  "executedAfterPause": true,
  "sizeMode": "quote",
  "baseSize": "1000000000",
  "reservedAmount": "1000000000",
  "errorCode": [
    "string"
  ],
  "reason": "force_close"
}
```