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:
- Retrieves the Binance client (from Client Id or creates one from credentials)
- Queries Binance for all open orders
- 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]