Get Order

Current status of a live order.

curl --request GET \
  --url https://api.darknyx.example.com/orders/{order_id} \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.darknyx.example.com/orders/{order_id}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.darknyx.example.com/orders/{order_id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.darknyx.example.com/orders/{order_id}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.darknyx.example.com/orders/{order_id}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "order_id": "<string>",
  "symbol": "<string>",
  "side": "bid",
  "order_type": "limit",
  "status": "empty",
  "amount": 123,
  "filled_quantity": 123,
  "price_limit": 123,
  "expiry_slot": 123,
  "arrival_slot": 123
}

{
  "code": 1102,
  "message": "trading_key_signature does not verify against the canonical body"
}

{
  "code": 1102,
  "message": "trading_key_signature does not verify against the canonical body"
}

{
  "code": 1102,
  "message": "trading_key_signature does not verify against the canonical body"
}

TL;DRGET /orders/{order_id} returns the current state of one order owned by the authenticated API account: its status, filled quantity, and remaining size. For live updates without polling, subscribe to the Orders Channel instead.

Auth: Authorization: Bearer <token>.

Path parameters

Parameter	Type	Description
`order_id`	string	The 16-byte order id (hex).

Example

curl -s "$GATEWAY/orders/$ORDER_ID" \
  -H "Authorization: Bearer $TOKEN" | jq .

Response

{
  "order_id": "aa00000000000000000000000000000001",
  "symbol": "SOL-USDC",
  "side": "bid",
  "order_type": "limit",
  "status": "pending",
  "amount": 10000000,
  "filled_quantity": 0,
  "price_limit": 150000000,
  "expiry_slot": 309490000,
  "arrival_slot": 309482113
}

Field reference

Field	Type	Description
`order_id`	string	The order id.
`symbol`	string	The isolated market book this order belongs to.
`side`	string	`"bid"` or `"ask"`.
`order_type`	string	`"limit"`, `"ioc"`, or `"fok"`.
`status`	string	Usually `pending` or `pending_settlement` for a live tracked order. Terminal lifecycle is delivered on the orders stream and may already have aged out of this read.
`amount`	integer	The order’s original size, in base units.
`filled_quantity`	integer	How much has filled so far.
`price_limit`	integer	The worst acceptable price (quote units per base).
`expiry_slot`	integer	The slot the order auto-expires at.
`arrival_slot`	integer	The slot the engine stamped on arrival.

Streaming alternative

Polling GET /orders/{order_id} is fine for a one-off check or to reconcile after a missed event. For a trading client that needs to react to fills, subscribe to the Orders Channel: the engine pushes a lifecycle event (partial fill, full fill, expiry) the moment an order’s state changes, without a request per check.

Errors

Condition	Status
Malformed `order_id` hex	`400`
Missing or invalid bearer token	`401`
No owned order with that id is currently tracked	`404`

An order owned by another account returns the same 404 code and body as an unknown id. This prevents callers from probing whether another account has a particular order.

Terminal orders age outThe book tracks resting and recently-terminal orders. A long-since-filled, expired, or cancelled order may no longer be queryable here; recover fill details from your seed plus finalized chain (see Fills Channel).

Authorizations

Authorization

string

header

required

Short-lived (≤ 1h) bearer token from POST /auth/token.

Expiry is EXACT — there is no grace period past expires_in, on REST or on the streaming transport. Refresh on a margin.

A structurally valid, unexpired token is still refused when it has been revoked (401), when the operator has invalidated the tokens the account was holding (401), or when the account is suspended (403). Suspension also blocks issuing a new one, so re-authenticating does not clear it.

Path Parameters

order_id

string

required

Response

Order detail.

The GET /orders/{order_id} status body.

order_id

string

required

16-byte order id, hex (the one supplied at placement).

symbol

string

required

Canonical instrument symbol selecting the isolated market book.

side

enum<string>

required

Available options:

bid,

ask

order_type

enum<string>

required

Available options:

limit,

ioc,

fok

status

enum<string>

required

pending (resting), pending_settlement (reserved while the TEE reconciles Tx D), expired, cancelled, or empty (slot reclaimed). Definitive failures leave the order lookup surface and emit terminal settlement_failed on the authenticated orders channel with a reason and lock expiry slot.

Available options:

empty,

pending,

pending_settlement,

expired,

cancelled

amount

integer<uint64>

required

Original order size, base units.

filled_quantity

integer<uint64>

required

Cumulative filled quantity.

price_limit

integer<uint64>

required

expiry_slot

integer<uint64>

required

arrival_slot

integer<uint64>

required

Slot stamped on arrival; frozen for the order's life.

⌘I

Current status of a live order.

curl --request GET \
  --url https://api.darknyx.example.com/orders/{order_id} \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.darknyx.example.com/orders/{order_id}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.darknyx.example.com/orders/{order_id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.darknyx.example.com/orders/{order_id}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.darknyx.example.com/orders/{order_id}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "order_id": "<string>",
  "symbol": "<string>",
  "side": "bid",
  "order_type": "limit",
  "status": "empty",
  "amount": 123,
  "filled_quantity": 123,
  "price_limit": 123,
  "expiry_slot": 123,
  "arrival_slot": 123
}

{
  "code": 1102,
  "message": "trading_key_signature does not verify against the canonical body"
}

{
  "code": 1102,
  "message": "trading_key_signature does not verify against the canonical body"
}

{
  "code": 1102,
  "message": "trading_key_signature does not verify against the canonical body"
}

Getting Started

System

Account

Instruments

Orders

Settlement

Tree

WebSocket

Path parameters

Example

Response

Field reference

Streaming alternative

Errors

Authorizations

Path Parameters

Response

​Path parameters

​Example

​Response

​Field reference

​Streaming alternative

​Errors

Authorizations

Path Parameters

Response

Path parameters

Example

Response

Field reference

Streaming alternative

Errors