Skip to main content

List My Orders

Retrieves all currently open orders for your Binance account across all trading pairs.

Common Properties​

  • Name - The custom name of the node.
  • Color - The custom color of the node.
  • Delay Before (sec) - Waits in seconds before executing the node.
  • Delay After (sec) - Waits in seconds after executing node.
  • Continue On Error - Automation will continue regardless of any error. The default value is false.
info

If the ContinueOnError property is true, no error is caught when the project is executed, even if a Catch node is used.

Inputs​

  • Client Id - The unique identifier from the Connect node (optional if using direct credentials).

Options​

  • Api Key - (Optional) Binance API key credential. Use if not providing Client Id.
  • Secret Key - (Optional) Binance API secret key credential. Use if not providing Client Id.

Output​

  • Result - An array of order objects containing details of all open orders.

How It Works​

The List My Orders node queries Binance for all active (open) orders on your account.

When executed, the node:

  1. Retrieves the Binance client (from Client Id or creates one from credentials)
  2. Queries Binance for all open orders
  3. Returns an array of order objects

Requirements​

  • Either a Client Id from Connect node OR API credentials in options
  • Appropriate API permissions (reading and spot trading enabled)

Error Handling​

The node will return specific errors in the following cases:

  • ErrListOrders - Failed to retrieve orders from Binance

Usage Notes​

  • Returns only open (unfilled) orders
  • Includes limit, market, and stop orders
  • Orders from all trading pairs are included
  • Partially filled orders are included
  • Completed or canceled orders are not included
  • Useful for order management and portfolio monitoring

Order Response Structure​

Each order object in the result array includes:

{
  "symbol": "BTCUSDT",
  "orderId": 123456789,
  "orderListId": -1,
  "clientOrderId": "web_abc123",
  "price": "50000.00",
  "origQty": "0.001",
  "executedQty": "0.0005",
  "cummulativeQuoteQty": "25.00",
  "status": "PARTIALLY_FILLED",
  "timeInForce": "GTC",
  "type": "LIMIT",
  "side": "BUY",
  "stopPrice": "0.00",
  "icebergQty": "0.00",
  "time": 1640000000000,
  "updateTime": 1640000100000,
  "isWorking": true,
  "origQuoteOrderQty": "0.00"
}

Order Fields​

Identification:

  • symbol - Trading pair (e.g., BTCUSDT)
  • orderId - Unique order ID
  • clientOrderId - Client-specified order ID

Order Details:

  • type - LIMIT, MARKET, STOP_LOSS_LIMIT, etc.
  • side - BUY or SELL
  • status - NEW, PARTIALLY_FILLED, etc.
  • timeInForce - GTC (Good Till Cancel), IOC, FOK

Prices and Quantities:

  • price - Limit price
  • origQty - Original order quantity
  • executedQty - Filled quantity
  • cummulativeQuoteQty - Total quote asset spent/received

Timestamps:

  • time - Order creation time (milliseconds)
  • updateTime - Last update time (milliseconds)

Example: List All Open Orders​

Scenario: Get all your currently active orders

Inputs:

  • Client Id: (from Connect node)

Output: Array of all open order objects.

Example: Cancel All Open Orders​

[Connect]
    |
    v
[List My Orders]
    |
    v
[For Each: order in result]
    |
    v
[Cancel Order]
    |   Order ID: order.orderId
    |   Currency Pair: order.symbol
    v
[Log: "Canceled order " + order.orderId]
    |
    v
[Next Order]
    |
    v
[Disconnect]

Example: Monitor Order Fills​

[Timer: Every 30 seconds]
    |
    v
[Connect]
    |
    v
[List My Orders]
    |
    v
[For Each: order in result]
    |
    v
[If: order.status == "PARTIALLY_FILLED"]
    |
    v
[Calculate: fill_percent = (order.executedQty / order.origQty) * 100]
    |
    v
[Log: order.symbol + " order " + fill_percent + "% filled"]
    |
    v
[Disconnect]

Example: Old Order Cleanup​

[Connect]
    |
    v
[List My Orders]
    |
    v
[Get: current_time = Date.now()]
    |
    v
[For Each: order in result]
    |
    v
[Calculate: age_hours = (current_time - order.time) / (1000 * 3600)]
    |
    v
[If: age_hours > 24]
    |
    v
[Cancel Order]
    |   Order ID: order.orderId
    |   Currency Pair: order.symbol
    v
[Alert: "Canceled old order: " + order.symbol]
    |
    v
[Disconnect]

Example: Portfolio Summary​

[Connect]
    |
    v
[List My Orders]
    |
    v
[Group By: symbol]
    |
    v
[For Each: symbol, orders]
    |
    v
[Sum Buy Orders]
[Sum Sell Orders]
    |
    v
[Display Summary]
    |   Symbol: symbol
    |   Buy Orders: count, total quantity
    |   Sell Orders: count, total quantity
    v
[Disconnect]

Order Status Values​

  • NEW - Order accepted, not filled
  • PARTIALLY_FILLED - Order partially executed
  • FILLED - Order completely executed (shouldn't appear in this list)
  • CANCELED - Order canceled (shouldn't appear in this list)
  • PENDING_CANCEL - Cancellation in progress
  • REJECTED - Order rejected (shouldn't appear in this list)

Use Cases​

Order Management:

  • View all active orders
  • Cancel specific or all orders
  • Monitor order status
  • Clean up old orders

Portfolio Monitoring:

  • Track locked funds in orders
  • See exposure across pairs
  • Monitor order distribution

Risk Management:

  • Cancel all orders in emergency
  • Remove outdated orders
  • Adjust orders based on market conditions

Trading Automation:

  • Check for existing orders before placing new ones
  • Cancel and replace orders
  • Implement order timeout logic

Reporting:

  • Generate order reports
  • Track trading activity
  • Audit open positions

Analyzing Open Orders​

// Count orders by type
const buyOrders = orders.filter(o => o.side === 'BUY');
const sellOrders = orders.filter(o => o.side === 'SELL');

// Find partially filled orders
const partialFills = orders.filter(o => o.status === 'PARTIALLY_FILLED');

// Calculate total locked value
const totalLocked = orders.reduce((sum, order) => {
  const remaining = parseFloat(order.origQty) - parseFloat(order.executedQty);
  return sum + (remaining * parseFloat(order.price));
}, 0);

// Group by symbol
const bySymbol = orders.reduce((acc, order) => {
  acc[order.symbol] = acc[order.symbol] || [];
  acc[order.symbol].push(order);
  return acc;
}, {});

Best Practices​

  • Check open orders before placing new ones to avoid over-exposure
  • Regularly review and cancel outdated orders
  • Monitor partially filled orders for execution progress
  • Implement automated cleanup for very old orders
  • Use order age to identify forgotten or stuck orders
  • Group orders by symbol for better portfolio visibility
  • Calculate locked funds to understand available capital
  • Set up alerts for partially filled orders
  • Cancel all orders before making major strategy changes

Common Patterns​

Order Existence Check:

List My Orders
Filter for specific symbol
If exists: Skip or cancel
Else: Place new order

Emergency Stop:

List My Orders
For each order:
  Cancel Order
Alert: All orders canceled

Partial Fill Monitor:

List My Orders
Find partially filled
Calculate fill percentage
Alert if stuck (old + low fill %)

Clean Slate:

List My Orders
Cancel all orders
Wait for confirmations
Proceed with new strategy

Performance Considerations​

  • This endpoint returns all open orders across all pairs
  • Can return large amounts of data if you have many orders
  • Consider filtering results locally by symbol if needed
  • Cache results briefly if checking multiple times
  • Don't poll too frequently - use reasonable intervals (30-60 seconds)

Order Lifecycle​

Place Order
  → NEW status
  → Shows in List My Orders

Order Fills
  → PARTIALLY_FILLED
  → Still in List My Orders

Order Completes
  → FILLED
  → Removed from List My Orders

Order Canceled
  → CANCELED
  → Removed from List My Orders

Combining with Other Nodes​

List My Orders
  → For each order:
      → Get Order (detailed status)
      → Get Price (current market price)
      → Decide: keep, cancel, or modify
      → Execute action

Risk Management Example​

[Market Volatility Alert]
    |
    v
[Connect]
    |
    v
[List My Orders]
    |
    v
[If: orders.length > 0]
    |
    v
[For Each: order]
    |
    v
[Get Price: order.symbol]
    |
    v
[Calculate: price_diff = abs(current_price - order.price) / order.price]
    |
    v
[If: price_diff > 0.05]  // 5% price move
    |
    v
[Cancel Order: outdated price]
    |
    v
[Disconnect]