Trading

Submit, cancel, and manage trade orders.

Submit Order

Python

response = trade_order_api.submit_trade_order(
    cadenza_client.SubmitTradeOrderRequest(
        trading_account_id=trading_account_id,
        instrument_id="BINANCE:BTC/USDT",
        order_side=cadenza_client.OrderSide.BUY,
        order_type=cadenza_client.OrderType.LIMIT,
        quantity="0.001",
        limit_price="50000.00"
    )
)
order = response.data
print(f"Order submitted: {order.trade_order_id}")

TypeScript

const response = await tradeOrderApi.submitTradeOrder({
  tradingAccountId: tradingAccountId,
  instrumentId: 'BINANCE:BTC/USDT',
  orderSide: 'BUY',
  orderType: 'LIMIT',
  quantity: '0.001',
  limitPrice: '50000.00',
})

const order = response.data.data
console.log('Order submitted:', order.tradeOrderId)

Go

response, _, err := apiClient.TradeOrderAPI.SubmitTradeOrder(ctx).
    SubmitTradeOrderRequest(client.SubmitTradeOrderRequest{
        TradingAccountId: tradingAccountId,
        InstrumentId:     "BINANCE:BTC/USDT",
        OrderSide:        client.ORDERSIDE_BUY,
        OrderType:        client.ORDERTYPE_LIMIT,
        Quantity:         "0.001",
        LimitPrice:       client.PtrString("50000.00"),
    }).Execute()
if err != nil {
    panic(err)
}

order := response.Data
fmt.Printf("Order submitted: %s\n", *order.TradeOrderId)

Market Order

Submit a market order for immediate execution:

Python

response = trade_order_api.submit_trade_order(
    cadenza_client.SubmitTradeOrderRequest(
        trading_account_id=trading_account_id,
        instrument_id="BINANCE:BTC/USDT",
        order_side=cadenza_client.OrderSide.BUY,
        order_type=cadenza_client.OrderType.MARKET,
        quantity="0.001",
        await_closed=True  # Wait for order to fill
    )
)
order = response.data
print(f"Order filled at: {order.executed_price}")

TypeScript

const response = await tradeOrderApi.submitTradeOrder({
  tradingAccountId: tradingAccountId,
  instrumentId: 'BINANCE:BTC/USDT',
  orderSide: 'BUY',
  orderType: 'MARKET',
  quantity: '0.001',
  awaitClosed: true,  // Wait for order to fill
})

const order = response.data.data
console.log('Order filled at:', order.executedPrice)

Go

awaitClosed := true
response, _, err := apiClient.TradeOrderAPI.SubmitTradeOrder(ctx).
    SubmitTradeOrderRequest(client.SubmitTradeOrderRequest{
        TradingAccountId: tradingAccountId,
        InstrumentId:     "BINANCE:BTC/USDT",
        OrderSide:        client.ORDERSIDE_BUY,
        OrderType:        client.ORDERTYPE_MARKET,
        Quantity:         "0.001",
        AwaitClosed:      &awaitClosed,
    }).Execute()
if err != nil {
    panic(err)
}

order := response.Data
fmt.Printf("Order filled at: %s\n", *order.ExecutedPrice)

Cancel Order

Python

response = trade_order_api.cancel_trade_order(
    cadenza_client.CancelTradeOrderRequest(
        trade_order_id=order.trade_order_id
    )
)
print(f"Order cancelled: {response.data.status}")

TypeScript

const response = await tradeOrderApi.cancelTradeOrder({
  tradeOrderId: order.tradeOrderId,
})

console.log('Order cancelled:', response.data.data.status)

Go

response, _, err := apiClient.TradeOrderAPI.CancelTradeOrder(ctx).
    CancelTradeOrderRequest(client.CancelTradeOrderRequest{
        TradeOrderId: *order.TradeOrderId,
    }).Execute()
if err != nil {
    panic(err)
}

fmt.Printf("Order cancelled: %s\n", *response.Data.Status)

List Orders

Python

response = trade_order_api.list_trade_orders(
    trading_account_id=trading_account_id
)
orders = response.data

for order in orders:
    print(f"{order.trade_order_id}: {order.status}")

TypeScript

const response = await tradeOrderApi.listTradeOrders(
  undefined,          // tradeOrderId
  undefined,          // orderStatus
  tradingAccountId    // tradingAccountId
)

const orders = response.data.data
orders.forEach(order => {
  console.log(`${order.tradeOrderId}: ${order.status}`)
})

Go

response, _, err := apiClient.TradeOrderAPI.ListTradeOrders(ctx).
    TradingAccountId(tradingAccountId).
    Execute()
if err != nil {
    panic(err)
}

for _, order := range response.Data {
    fmt.Printf("%s: %s\n", *order.TradeOrderId, *order.Status)
}

Order Types

Type	Description
LIMIT	Execute at specified price or better
MARKET	Execute immediately at best available price
STOP_LIMIT	Limit order triggered when stop price is reached
STOP_MARKET	Market order triggered when stop price is reached

Order Sides

Side	Description
BUY	Buy the base asset
SELL	Sell the base asset

Time in Force

Value	Description
GTC	Good Till Cancelled (default)
IOC	Immediate Or Cancel
FOK	Fill Or Kill

Order Status

Status	Description
PENDING	Order submitted, awaiting exchange confirmation
OPEN	Order active on exchange
PARTIALLY_FILLED	Order partially executed
FILLED	Order fully executed
CANCELLED	Order cancelled
REJECTED	Order rejected by exchange
EXPIRED	Order expired

Real-time Order Updates

For real-time order status updates, subscribe to the tradingAccount:{id} channel. See the Quick Start for WebSocket setup.