List All Pairs

Retrieves a list of all available trading pairs on Binance exchange.

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 trading pair symbols (e.g., ["BTCUSDT", "ETHUSDT", "BNBUSDT", ...]).

How It Works

The List All Pairs node queries Binance's exchange information to retrieve all available trading pairs.

When executed, the node:

1. Retrieves the Binance client (from Client Id or creates one from credentials)
2. Queries Binance exchange information
3. Extracts all trading pair symbols
4. Returns an array of pair symbols

Requirements

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

Error Handling

The node will return specific errors in the following cases:

• ErrListAllPairs - Failed to retrieve exchange information from Binance
• ErrSetResult - Failed to set the output result

Usage Notes

• Returns all spot trading pairs available on Binance
• The list includes thousands of pairs
• Pairs are returned as symbol strings (e.g., "BTCUSDT")
• The list may change as Binance adds or removes pairs
• Useful for validating pair existence before trading

Example Output

[
  "BTCUSDT",
  "ETHUSDT",
  "BNBUSDT",
  "ADAUSDT",
  "DOGEUSDT",
  "XRPUSDT",
  "DOTUSDT",
  "UNIUSDT",
  "ETHBTC",
  "BNBBTC",
  ...
]

Example: Validate Trading Pair

Scenario: Check if a trading pair exists before placing an order

Inputs:

• Client Id: (from Connect node)

Output: Array of all trading pair symbols.

Usage:

[Connect]
    |
    v
[List All Pairs]
    |
    v
[Check if: "NEWCOINUSDT" in result]
    |
    +---> [Yes: Proceed with trade]
    +---> [No: Alert "Pair not available"]
    v
[Disconnect]

Example: Find All USDT Pairs

[Connect]
    |
    v
[List All Pairs]
    |
    v
[Filter: pairs ending with "USDT"]
    |
    v
[Log: "Found " + filtered_pairs.length + " USDT pairs"]
    |
    v
[For Each: pair in filtered_pairs]
    |
    v
[Process pair...]
    |
    v
[Disconnect]

Example: Find All Pairs for a Coin

[Input: coin = "BTC"]
    |
    v
[List All Pairs]
    |
    v
[Filter: pairs starting with coin or ending with coin]
    |
    v
[Display Pairs]
    |   BTCUSDT, BTCBUSD, ETHBTC, BNBBTC, etc.
    v
[User selects pair]

Example: Pair Discovery System

[Timer: Daily]
    |
    v
[Connect]
    |
    v
[List All Pairs]
    |
    v
[Store: current_pairs = result]
    |
    v
[Compare: with yesterday_pairs]
    |
    v
[Find: new_pairs = current_pairs - yesterday_pairs]
    |
    v
[If: new_pairs.length > 0]
    |
    v
[Alert: "New pairs added: " + new_pairs.join(", ")]
    |
    v
[Update: yesterday_pairs = current_pairs]
    |
    v
[Disconnect]

Filtering Pairs

By Quote Currency:

// Get all USDT pairs
const usdtPairs = allPairs.filter(pair => pair.endsWith('USDT'));

// Get all BTC pairs
const btcPairs = allPairs.filter(pair => pair.endsWith('BTC'));

// Get all BUSD pairs
const busdPairs = allPairs.filter(pair => pair.endsWith('BUSD'));

By Base Currency:

// Get all pairs containing BTC
const btcPairs = allPairs.filter(pair => pair.startsWith('BTC'));

// Get all pairs containing ETH
const ethPairs = allPairs.filter(pair => pair.startsWith('ETH'));

By Pattern:

// Get stablecoin pairs
const stablePairs = allPairs.filter(pair =>
  pair.includes('USDT') || pair.includes('BUSD') || pair.includes('USDC')
);

Common Quote Currencies

Most traded quote currencies on Binance:

• USDT - Tether (most common)
• BUSD - Binance USD
• BTC - Bitcoin
• ETH - Ethereum
• BNB - Binance Coin
• USDC - USD Coin
• EUR - Euro (limited pairs)

Use Cases

Pair Validation:

• Verify a pair exists before trading
• Check if new listings are available
• Validate user input for pair selection

Discovery:

• Find all pairs for a specific coin
• Discover new trading opportunities
• Monitor newly listed pairs

Automation:

• Build dynamic pair selectors
• Create multi-pair trading bots
• Monitor all markets simultaneously

Analytics:

• Track total number of pairs
• Analyze market structure
• Identify delisted pairs

Best Practices

• Cache the pair list to reduce API calls (pairs don't change frequently)
• Refresh the list daily or weekly to catch new listings
• Use case-insensitive comparison when validating pairs
• Filter pairs based on your trading strategy needs
• Combine with Get Price Change Info to analyze all pairs
• Consider only liquid pairs (high volume) for serious trading
• Validate pair format before using in other nodes

Pair Format

Binance trading pairs follow the format: BASEQUOTE

• Base asset: What you're buying/selling
• Quote asset: What you're using to pay/receive

Examples:

• BTCUSDT - Buy/sell BTC using USDT
• ETHBTC - Buy/sell ETH using BTC
• BNBBUSD - Buy/sell BNB using BUSD

Performance Considerations

• This endpoint returns all pairs (thousands)
• Response size can be large
• Consider caching the result
• Update cache periodically (e.g., daily)
• Don't call on every operation

Combining with Other Operations

List All Pairs
  → Filter by criteria
  → For each pair:
      → Get Price
      → Get Price Change Info
      → Analyze opportunity
      → Execute trade if criteria met

Common Patterns

Pair Existence Check:

List All Pairs
  → Check if target_pair in result
  → Proceed if exists, error if not

Multi-Pair Monitoring:

List All Pairs
  → Filter USDT pairs
  → For each pair:
      → Get Price
      → Get Price Change Info
      → Store data
  → Analyze all data

Dynamic Pair Selection:

List All Pairs
  → Filter by user criteria
  → Display options to user
  → User selects pair
  → Execute operation on selected pair