Get Deposit Address

Retrieves the deposit address for a specific cryptocurrency on Gate.io. Essential for automating cryptocurrency deposits and building wallet management systems.

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 client identifier from the Connect node. Can be left empty if using direct credentials.
• Currency - The currency code to get deposit address for (e.g., USDT, BTC, ETH).

Options

• Api Key - Gate.io API key credential (optional if using Client Id from Connect node).
• Secret Key - Gate.io API secret key credential (optional if using Client Id from Connect node).

Output

• Result - A deposit address object containing:
  • currency - Currency code
  • address - Deposit address
  • multichain_addresses - Array of addresses for different networks (if applicable)
  • Each multichain address contains:
    • chain - Network/blockchain name (e.g., TRC20, ERC20, BEP20)
    • address - Deposit address for this network
    • payment_id - Payment ID/memo (if required)
    • payment_name - Payment field name (if applicable)
    • obtain_failed - Whether address generation failed

How It Works

The Get Deposit Address node executes the following steps:

1. Authenticates using either Client Id or direct credentials
2. Validates that Currency is not empty
3. Queries Gate.io Wallet API for deposit address
4. Returns deposit address information including multi-chain addresses if available

Requirements

• Either a valid Client Id from Connect node OR API credentials
• Valid currency code that is supported on Gate.io
• Wallet permissions on your API key
• The currency must support deposits

Error Handling

The node will return specific errors in the following cases:

• ErrInternal - Failed to retrieve input parameters
• ErrInvalidArg - Currency is empty
• ErrGetDepositAddress - Failed to retrieve deposit address (currency may not support deposits, or address generation failed)

Usage Notes

• Many cryptocurrencies support multiple networks (e.g., USDT on TRC20, ERC20, BEP20)
• Always verify the network before depositing (wrong network can result in lost funds)
• Some currencies require a payment ID/memo in addition to the address
• Deposit addresses are typically permanent but can change
• Some new currencies may not have addresses generated automatically
• This is read-only wallet information retrieval

Best Practices

• Always display the network name alongside the address
• Verify the network matches the sending wallet's network
• Include payment ID/memo if required for the currency
• Implement address validation before displaying to users
• Cache deposit addresses as they rarely change
• Double-check addresses before initiating deposits
• Consider generating QR codes for mobile-friendly deposits
• Warn users about network selection importance

Example Usage Scenarios

Get USDT Deposit Address

Inputs:
- Client Id: (from Connect node)
- Currency: USDT

Output:
{
  currency: "USDT",
  address: "TXyz...",
  multichain_addresses: [
    {
      chain: "TRC20",
      address: "TXyz123...",
      payment_id: "",
      payment_name: ""
    },
    {
      chain: "ERC20",
      address: "0xabc123...",
      payment_id: "",
      payment_name: ""
    },
    {
      chain: "BEP20",
      address: "0xdef456...",
      payment_id: "",
      payment_name: ""
    }
  ]
}

Get Bitcoin Deposit Address

Inputs:
- Client Id: (from Connect node)
- Currency: BTC

Output:
{
  currency: "BTC",
  address: "bc1q...",
  multichain_addresses: [
    {
      chain: "BTC",
      address: "bc1qxyz123...",
      payment_id: "",
      payment_name: ""
    }
  ]
}

With Direct Credentials

Inputs:
- Client Id: (empty)
- Currency: ETH

Options:
- Api Key: (your credential)
- Secret Key: (your credential)

Output: Deposit address for Ethereum

Example Flow: Display Deposit Options

[Connect]
    |
    +-> [Get Deposit Address: USDT]
    |
    +-> [Extract Multi-Chain Addresses]
          |
          +-> [For Each: network in multichain_addresses]
                |
                +-> [Display to User]
                      |
                      +-> Network: network.chain
                      +-> Address: network.address
                      +-> Warning: "Make sure to use the correct network!"
    |
[Disconnect]

Example Flow: Generate Deposit QR Code

[Connect]
    |
    +-> [Get Deposit Address: BTC]
    |
    +-> [Extract: btc_address = result.multichain_addresses[0].address]
    |
    +-> [Generate QR Code]
          |
          +-> Content: bitcoin:btc_address
          +-> Save to file
          |
[Display QR Code to User]
    |
[Disconnect]

Example Flow: Deposit Address Lookup System

[Connect]
    |
    +-> [Set: currencies = ["BTC", "ETH", "USDT", "TRX"]]
    |
    +-> [For Each: currency in currencies]
    |     |
    |     +-> [Get Deposit Address: currency]
    |     |
    |     +-> [Store in Database]
    |           |
    |           +-> Currency: currency
    |           +-> Addresses: result.multichain_addresses
    |           +-> Updated: current_timestamp
    |
    +-> [Log: Deposit addresses cached]
    |
    +-> [Disconnect]

Example Flow: User Deposit Instructions

[User selects: currency = "USDT", network = "TRC20"]
    |
[Connect]
    |
    +-> [Get Deposit Address: USDT]
    |
    +-> [Find: address for TRC20]
          |
          +-> selected_address = multichain_addresses.find(a => a.chain === "TRC20")
          |
[Display Instructions]
    |
    +-> Currency: USDT
    +-> Network: TRC20 (TRON)
    +-> Address: selected_address.address
    +-> Warning: "Only send USDT via TRC20 network to this address"
    +-> Warning: "Sending via other networks will result in loss of funds"
    |
[Disconnect]

Understanding Multi-Chain Addresses

Many cryptocurrencies exist on multiple blockchains:

USDT Networks

• TRC20 (TRON): Fast, low fees, popular
• ERC20 (Ethereum): Widely supported, higher fees
• BEP20 (Binance Smart Chain): Fast, low fees
• Polygon: Low fees, growing support

Important Network Selection

CRITICAL: The network must match on both sending and receiving sides!

Correct:
  Send from TRC20 wallet -> TRC20 deposit address ✓

Incorrect:
  Send from ERC20 wallet -> TRC20 deposit address ✗ (FUNDS LOST!)

Handling Payment IDs/Memos

Some currencies require additional payment identifiers:

const address = result.multichain_addresses[0];

if (address.payment_id) {
  console.log("IMPORTANT: Include payment ID when depositing");
  console.log(`Address: ${address.address}`);
  console.log(`${address.payment_name}: ${address.payment_id}`);
} else {
  console.log(`Address: ${address.address}`);
  console.log("No payment ID required");
}

Example: Network Selector Interface

[Get Deposit Address: USDT]
    |
[Build Network Selection]
    |
    +-> Available Networks:
          |
          +-> For each: network in multichain_addresses
                |
                +-> Option: {
                      label: network.chain,
                      value: network.address,
                      description: getNetworkDescription(network.chain)
                    }
          |
[User selects network]
    |
[Display]
    |
    +-> Selected Network: selected.chain
    +-> Deposit Address: selected.address
    +-> Generate QR Code
    +-> Show network-specific warnings

Network Descriptions Helper

function getNetworkDescription(chain) {
  const descriptions = {
    "TRC20": "TRON network - Fast & low fees (recommended)",
    "ERC20": "Ethereum network - Widely supported, higher fees",
    "BEP20": "Binance Smart Chain - Fast & low fees",
    "BTC": "Bitcoin network - Secure, slower confirmations",
    "ETH": "Ethereum network - Native ETH",
    // Add more as needed
  };
  return descriptions[chain] || chain;
}

Example: Deposit Address Validation

[Get Deposit Address: currency]
    |
[Validate Result]
    |
    +-> [If: multichain_addresses is empty]
    |     |
    |     +-> [Error: No deposit address available]
    |     +-> [Check: Currency supports deposits]
    |
    +-> [If: obtain_failed = true]
    |     |
    |     +-> [Error: Address generation failed]
    |     +-> [Retry or contact support]
    |
    +-> [Else: Success]
          |
          +-> [Proceed with displaying addresses]

Safety Warnings to Display

Always show these warnings to users:

1. Network Match: "Ensure the sending network matches the deposit network"
2. Address Verification: "Double-check the address before sending"
3. Minimum Deposit: "Check minimum deposit amount requirements"
4. Confirmations: "Deposits require network confirmations before crediting"
5. Test Transaction: "Consider sending a small test amount first"

Example: Complete Deposit Interface

[Connect]
    |
    +-> [Get Deposit Address: selected_currency]
    |
    +-> [Build Deposit UI]
          |
          +-> Currency: selected_currency
          |
          +-> Network Selection:
          |     |
          |     +-> [Radio buttons for each network]
          |
          +-> For selected network:
          |     |
          |     +-> Address: (with copy button)
          |     +-> QR Code: (scannable)
          |     +-> Payment ID: (if required)
          |
          +-> Warnings:
          |     |
          |     +-> Network mismatch warning
          |     +-> Minimum deposit amount
          |     +-> Confirmation time estimate
          |
          +-> Status:
                |
                +-> Monitor blockchain for incoming transaction
                +-> Update when confirmations received
    |
[Disconnect]

Related Nodes

• Connect - Establishes the client session needed for this node
• Get Balance - Check balance after deposit is confirmed