Skip to main content

List Withdraws

Retrieves recent withdrawal history for your Binance account, showing outgoing cryptocurrency transfers.

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).
  • Limit - Maximum number of withdrawal records to retrieve (default: 5 if not specified or ≤ 0).

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 withdrawal record objects showing transaction details, status, and fees.

How It Works​

The List Withdraws node queries Binance for your recent withdrawal transactions.

When executed, the node:

  1. Retrieves the Binance client (from Client Id or creates one from credentials)
  2. Validates the Limit input
  3. Queries Binance's withdrawal history service
  4. Returns an array of withdrawal records

Requirements​

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

Error Handling​

The node will return specific errors in the following cases:

  • ErrInternal - Failed to retrieve input values
  • ErrListWithdraws - Failed to retrieve withdrawal history from Binance
  • ErrSetResult - Failed to set the output result

Usage Notes​

  • Returns recent withdrawal transactions
  • Includes withdrawals of all cryptocurrencies
  • Shows withdrawal status (processing, completed, failed, rejected)
  • Includes both manual and API-initiated withdrawals
  • Withdrawal fees are shown separately
  • Failed or rejected withdrawals are also included

Withdrawal Record Structure​

Each withdrawal object typically includes:

{
  "id": "abc123def456",
  "amount": "0.5",
  "transactionFee": "0.0005",
  "coin": "BTC",
  "status": 6,
  "address": "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
  "addressTag": "",
  "txId": "0x1234567890abcdef...",
  "applyTime": 1640000000000,
  "network": "BTC",
  "transferType": 0,
  "info": "",
  "confirmNo": 2,
  "walletType": 0,
  "txKey": ""
}

Withdrawal Fields​

Transaction Details:

  • id - Unique withdrawal ID
  • txId - Blockchain transaction hash (empty if not yet broadcasted)
  • coin - Cryptocurrency symbol
  • network - Blockchain network used
  • amount - Withdrawal amount (excluding fee)
  • transactionFee - Network fee charged

Address Information:

  • address - Destination address
  • addressTag - Memo/tag if applicable (e.g., for XRP, XLM)

Status:

  • status - Withdrawal status code:
    • 0 = Email Sent
    • 1 = Cancelled
    • 2 = Awaiting Approval
    • 3 = Rejected
    • 4 = Processing
    • 5 = Failure
    • 6 = Completed

Confirmations:

  • confirmNo - Number of network confirmations

Timestamps:

  • applyTime - When withdrawal was requested (milliseconds)

Additional Info:

  • info - Additional information or error message
  • transferType - Internal transfer type
  • walletType - Wallet type (0 = spot)

Example: List Recent Withdrawals​

Scenario: Check the last 10 withdrawals from your account

Inputs:

  • Client Id: (from Connect node)
  • Limit: 10

Output: Array of up to 10 recent withdrawal records.

Example: Monitor Pending Withdrawals​

[Timer: Every 5 minutes]
    |
    v
[Connect]
    |
    v
[List Withdraws]
    |   Limit: 20
    v
[Filter: withdrawals where status in [2, 4]]  // Pending or Processing
    |
    v
[For Each: pending withdrawal]
    |
    v
[Log: withdrawal.coin + " withdrawal pending"]
[Log: "  Amount: " + withdrawal.amount]
[Log: "  Address: " + withdrawal.address]
[Log: "  Status: " + getStatusName(withdrawal.status)]
    |
    v
[If: status == 4 AND txId exists]
    |
    v
[Log: "  TxID: " + withdrawal.txId]
[Log: "  Confirmations: " + withdrawal.confirmNo]
    |
    v
[Disconnect]

Example: Withdrawal Notification System​

[Timer: Every 3 minutes]
    |
    v
[Connect]
    |
    v
[List Withdraws: Limit 10]
    |
    v
[Compare: with last_check_withdrawals]
    |
    v
[Find: status_changed = withdrawals with status updates]
    |
    v
[For Each: withdrawal in status_changed]
    |
    v
[Send Notification]
    |   Title: withdrawal.coin + " Withdrawal Update"
    |   Message: getStatusName(withdrawal.status)
    |   Amount: withdrawal.amount
    |   Fee: withdrawal.transactionFee
    |   TxID: withdrawal.txId (if exists)
    v
[Update: last_check_withdrawals]
    |
    v
[Disconnect]

Example: Calculate Total Withdrawal Fees​

[Connect]
    |
    v
[List Withdraws: Limit 50]
    |
    v
[Group By: coin]
    |
    v
[For Each: coin, withdrawals]
    |
    v
[Sum: total_amount = sum of amounts]
[Sum: total_fees = sum of transactionFees]
    |
    v
[Display Report]
    |   Coin: coin
    |   Total Withdrawn: total_amount
    |   Total Fees Paid: total_fees
    |   Avg Fee: total_fees / withdrawals.length
    v
[Disconnect]

Withdrawal Status Codes​

  • 0 (Email Sent) - Email confirmation sent
  • 1 (Cancelled) - Withdrawal cancelled by user
  • 2 (Awaiting Approval) - Waiting for approval
  • 3 (Rejected) - Withdrawal rejected
  • 4 (Processing) - Being processed
  • 5 (Failure) - Withdrawal failed
  • 6 (Completed) - Successfully completed

Status Lifecycle​

Request Withdrawal
  ↓
Email Sent (0) → Confirm Email
  ↓
Awaiting Approval (2)
  ↓
Processing (4) → TxID generated
  ↓
Completed (6) → Funds sent

Alternative paths:
  → Cancelled (1) by user
  → Rejected (3) by Binance
  → Failure (5) technical issue

Use Cases​

Withdrawal Tracking:

  • Monitor outgoing funds
  • Track withdrawal completion
  • Verify successful transfers

Automation:

  • Auto-notify on withdrawal status changes
  • Track automated withdrawal batches
  • Monitor withdrawal processing times

Accounting:

  • Record outgoing transactions
  • Calculate total fees paid
  • Generate withdrawal reports

Customer Service:

  • Verify withdrawal claims
  • Check withdrawal status
  • Investigate failed withdrawals

Security:

  • Monitor unauthorized withdrawals
  • Track suspicious activity
  • Audit withdrawal history

Fee Analysis:

  • Compare fees across networks
  • Optimize withdrawal timing
  • Track fee expenses

Analyzing Withdrawals​

// Group by status
const byStatus = withdrawals.reduce((acc, w) => {
  const statusName = getStatusName(w.status);
  acc[statusName] = acc[statusName] || [];
  acc[statusName].push(w);
  return acc;
}, {});

// Calculate total fees by coin
const feesByCoin = {};
withdrawals.forEach(w => {
  feesByCoin[w.coin] = (feesByCoin[w.coin] || 0) +
    parseFloat(w.transactionFee);
});

// Find large withdrawals
const largeWithdrawals = withdrawals.filter(w =>
  parseFloat(w.amount) > 1000  // Adjust threshold
);

// Find failed/rejected
const failed = withdrawals.filter(w =>
  [3, 5].includes(w.status)
);

Status Helper Function​

function getStatusName(status) {
  const statuses = {
    0: 'Email Sent',
    1: 'Cancelled',
    2: 'Awaiting Approval',
    3: 'Rejected',
    4: 'Processing',
    5: 'Failure',
    6: 'Completed'
  };
  return statuses[status] || 'Unknown';
}

Best Practices​

  • Poll withdrawals periodically to track status changes
  • Store withdrawal IDs to avoid processing duplicates
  • Check status before considering withdrawal complete
  • Verify txId exists before tracking on blockchain
  • Investigate info field for failed/rejected withdrawals
  • Keep records of all withdrawal transaction IDs
  • Calculate net amounts (amount - transactionFee)
  • Monitor for stuck withdrawals (processing too long)
  • Set up alerts for failed or rejected withdrawals

Common Patterns​

Status Monitoring:

Store: previous_withdrawal_statuses
List Withdraws
Compare: current vs previous statuses
Find: status changes
Process: notifications for changes
Update: previous_withdrawal_statuses

Completion Verification:

Input: withdrawal_id
List Withdraws
Find: withdrawal by id
Check: status == 6 (completed)
Verify: txId exists
Return: completion status

Failed Withdrawal Investigation:

List Withdraws
Filter: status in [3, 5] (rejected, failed)
For each failed:
  Log: withdrawal details
  Log: info field (error reason)
  Alert: admin for review

For completed withdrawals (with txId), construct explorer URLs:

Bitcoin (BTC):

https://blockchain.com/btc/tx/{txId}

Ethereum (ETH):

https://etherscan.io/tx/{txId}

BSC (BEP20):

https://bscscan.com/tx/{txId}

Tron (TRC20):

https://tronscan.org/#/transaction/{txId}

Understanding Fees​

Withdrawal fees vary by:

  • Cryptocurrency - Different coins have different fees
  • Network - Same coin, different network = different fee
  • Network Congestion - Some exchanges adjust fees dynamically
  • Binance Discounts - BNB holders may get fee discounts

Typical Withdrawal Times​

After status changes to Processing (4):

  • Bitcoin: 30-60 minutes
  • Ethereum: 10-30 minutes
  • BSC: 5-10 minutes
  • Tron: 3-5 minutes
  • Times vary based on network congestion

Important Considerations​

  • Withdrawals may require email confirmation
  • Large withdrawals may trigger additional verification
  • Some withdrawals may require manual approval
  • Network congestion affects processing times
  • Failed withdrawals are refunded to your balance
  • Withdrawal limits apply (daily, per transaction)
  • Some coins may have temporary withdrawal suspension
  • Always verify destination address and network

Security Tips​

  • Enable withdrawal whitelist if available
  • Use email/SMS confirmations for withdrawals
  • Monitor withdrawal history regularly
  • Set up alerts for all withdrawals
  • Verify addresses before withdrawing
  • Double-check network selection
  • Keep records of all transaction IDs
  • Report suspicious withdrawals immediately

Troubleshooting Failed Withdrawals​

Common reasons for failures:

  • Address Invalid - Wrong format or checksum
  • Network Mismatch - Wrong network selected
  • Insufficient Balance - Not enough funds after fees
  • Below Minimum - Amount below minimum withdrawal
  • Above Maximum - Amount exceeds limit
  • Suspended - Withdrawals temporarily disabled
  • Security Hold - Account security restrictions

Check the info field for specific error details.

Withdrawal Fee Optimization​

[Get Coin Detail: USDT]
  → Check all network fees
  → Select cheapest network
  → Verify destination supports network
  → Execute withdrawal