wallet/validateaddress

Instant Address Validation

Dwellir's TRON infrastructure provides sub-10ms address validation with format checking and encoding verification. Ensure address validity before processing transactions or queries.

Start validating addresses →

Validate a TRON address to check if it's properly formatted and valid on the network. Supports both Base58 and Hexadecimal address formats.

Use Cases

wallet/validateaddress is essential for:

• Input Validation - Verify user-provided addresses
• Transaction Safety - Validate recipient before sending
• Form Validation - Real-time address checking in UIs
• API Security - Validate addresses in API requests
• Data Integrity - Ensure address validity in databases

Parameters

Parameter	Type	Required	Description
address	string	Yes	TRON address to validate (Base58 or Hex)
visible	boolean	No	Format type - true for Base58, false for Hex (default: true)

Request Example

{
  "address": "TRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN",
  "visible": true
}

Response Fields

Field	Type	Description
result	boolean	Whether the address is valid
message	string	Validation result message

Implementation Examples

JavaScript

const TRON_API = 'https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY';

// Basic address validation
async function validateAddress(address) {
  const response = await fetch(`${TRON_API}/wallet/validateaddress`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      address: address,
      visible: true
    })
  });
  
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }
  
  return await response.json();
}

// Advanced address validator class
class TronAddressValidator {
  constructor(apiKey) {
    this.apiUrl = `https://api-tron-mainnet.n.dwellir.com/${apiKey}`;
    this.cache = new Map();
    this.cacheTimeout = 60000; // 1 minute cache
  }
  
  async validate(address, useCache = true) {
    // Check cache first
    if (useCache && this.cache.has(address)) {
      const cached = this.cache.get(address);
      if (Date.now() - cached.timestamp < this.cacheTimeout) {
        return cached.result;
      }
    }
    
    // Perform basic format check first
    const formatValid = this.checkFormat(address);
    if (!formatValid.valid) {
      return {
        result: false,
        message: formatValid.message,
        format: formatValid.format
      };
    }
    
    // Call API for full validation
    try {
      const response = await fetch(`${this.apiUrl}/wallet/validateaddress`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          address: address,
          visible: formatValid.format === 'base58'
        })
      });
      
      const result = await response.json();
      
      // Cache the result
      if (useCache) {
        this.cache.set(address, {
          result: result,
          timestamp: Date.now()
        });
      }
      
      return result;
    } catch (error) {
      console.error('Validation API error:', error);
      return {
        result: false,
        message: 'API validation failed',
        error: error.message
      };
    }
  }
  
  checkFormat(address) {
    // Base58 format check (starts with T, 34 characters)
    if (address.startsWith('T') && address.length === 34) {
      // Check for valid Base58 characters
      const base58Regex = /^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/;
      if (base58Regex.test(address)) {
        return { valid: true, format: 'base58' };
      }
      return { 
        valid: false, 
        format: 'base58',
        message: 'Invalid Base58 characters' 
      };
    }
    
    // Hex format check (41 prefix, 42 characters)
    if (address.startsWith('41') && address.length === 42) {
      const hexRegex = /^[0-9a-fA-F]+$/;
      if (hexRegex.test(address)) {
        return { valid: true, format: 'hex' };
      }
      return { 
        valid: false, 
        format: 'hex',
        message: 'Invalid hexadecimal characters' 
      };
    }
    
    return { 
      valid: false, 
      format: 'unknown',
      message: 'Invalid TRON address format' 
    };
  }
  
  async validateBatch(addresses) {
    const results = await Promise.allSettled(
      addresses.map(addr => this.validate(addr))
    );
    
    return results.map((result, index) => ({
      address: addresses[index],
      valid: result.status === 'fulfilled' && result.value.result,
      details: result.status === 'fulfilled' ? result.value : null,
      error: result.status === 'rejected' ? result.reason : null
    }));
  }
  
  // Convert between formats
  async convertFormat(address) {
    const validation = await this.validate(address);
    if (!validation.result) {
      return { error: 'Invalid address', validation };
    }
    
    const format = this.checkFormat(address);
    
    // Note: Actual conversion requires base58/hex encoding libraries
    // This is a placeholder for the conversion logic
    return {
      original: address,
      format: format.format,
      converted: format.format === 'base58' ? 
        this.toHex(address) : 
        this.toBase58(address)
    };
  }
  
  toHex(base58Address) {
    // Placeholder - actual implementation needs base58 decoder
    return '41' + '0'.repeat(40); 
  }
  
  toBase58(hexAddress) {
    // Placeholder - actual implementation needs base58 encoder
    return 'T' + 'x'.repeat(33);
  }
}

// Form validation helper
class FormValidator {
  constructor(apiKey) {
    this.validator = new TronAddressValidator(apiKey);
    this.debounceTimer = null;
  }
  
  async validateInput(inputElement, feedbackElement) {
    const address = inputElement.value.trim();
    
    // Clear previous timer
    clearTimeout(this.debounceTimer);
    
    // Quick format check
    const formatCheck = this.validator.checkFormat(address);
    
    if (!address) {
      this.updateFeedback(feedbackElement, 'empty', 'Enter a TRON address');
      return false;
    }
    
    if (!formatCheck.valid) {
      this.updateFeedback(feedbackElement, 'invalid', formatCheck.message);
      return false;
    }
    
    // Show validating state
    this.updateFeedback(feedbackElement, 'validating', 'Validating address...');
    
    // Debounce API call
    this.debounceTimer = setTimeout(async () => {
      try {
        const result = await this.validator.validate(address);
        
        if (result.result) {
          this.updateFeedback(feedbackElement, 'valid', 'Valid TRON address');
          return true;
        } else {
          this.updateFeedback(feedbackElement, 'invalid', result.message);
          return false;
        }
      } catch (error) {
        this.updateFeedback(feedbackElement, 'error', 'Validation failed');
        return false;
      }
    }, 500);
  }
  
  updateFeedback(element, status, message) {
    element.textContent = message;
    element.className = `feedback feedback-${status}`;
  }
}

// Usage examples
(async () => {
  const validator = new TronAddressValidator('YOUR_API_KEY');
  
  try {
    // Validate single address
    const result = await validator.validate('TRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN');
    console.log('Address valid:', result.result);
    
    // Validate batch of addresses
    const addresses = [
      'TRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN',
      'InvalidAddress123',
      'TJmmqjb1DK9TTZbQXzRQ2AuA94z4gKAPFh'
    ];
    
    const batchResults = await validator.validateBatch(addresses);
    batchResults.forEach(result => {
      console.log(`${result.address}: ${result.valid ? 'Valid' : 'Invalid'}`);
    });
    
    // Form validation example
    const formValidator = new FormValidator('YOUR_API_KEY');
    const input = document.getElementById('addressInput');
    const feedback = document.getElementById('feedback');
    
    input?.addEventListener('input', () => {
      formValidator.validateInput(input, feedback);
    });
    
  } catch (error) {
    console.error('Validation error:', error);
  }
})();

Python

import requests
import re
from typing import Dict, List, Optional, Tuple
from time import time
from threading import Lock

class TronAddressValidator:
    def __init__(self, api_key: str):
        self.base_url = f"https://api-tron-mainnet.n.dwellir.com/{api_key}"
        self.headers = {'Content-Type': 'application/json'}
        self.cache = {}
        self.cache_timeout = 60  # seconds
        self.cache_lock = Lock()
    
    def validate_address(
        self, 
        address: str, 
        visible: bool = True,
        use_cache: bool = True
    ) -> Dict:
        """
        Validate a TRON address via API
        """
        # Check cache first
        if use_cache:
            cached = self._get_cached(address)
            if cached:
                return cached
        
        # Perform format validation first
        format_check = self.check_format(address)
        if not format_check['valid']:
            return {
                'result': False,
                'message': format_check['message'],
                'format': format_check['format']
            }
        
        # API validation
        url = f"{self.base_url}/wallet/validateaddress"
        payload = {
            "address": address,
            "visible": visible
        }
        
        try:
            response = requests.post(url, headers=self.headers, json=payload)
            response.raise_for_status()
            result = response.json()
            
            # Cache the result
            if use_cache:
                self._cache_result(address, result)
            
            return result
            
        except requests.RequestException as e:
            return {
                'result': False,
                'message': f'API validation failed: {str(e)}',
                'error': str(e)
            }
    
    def check_format(self, address: str) -> Dict:
        """
        Check address format without API call
        """
        # Base58 format (starts with T, 34 characters)
        if address.startswith('T') and len(address) == 34:
            # Valid Base58 characters
            base58_chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
            if all(c in base58_chars for c in address):
                return {'valid': True, 'format': 'base58'}
            return {
                'valid': False,
                'format': 'base58',
                'message': 'Invalid Base58 characters'
            }
        
        # Hex format (starts with 41, 42 characters)
        if address.startswith('41') and len(address) == 42:
            if re.match(r'^[0-9a-fA-F]+$', address):
                return {'valid': True, 'format': 'hex'}
            return {
                'valid': False,
                'format': 'hex',
                'message': 'Invalid hexadecimal characters'
            }
        
        return {
            'valid': False,
            'format': 'unknown',
            'message': 'Invalid TRON address format'
        }
    
    def validate_batch(self, addresses: List[str]) -> List[Dict]:
        """
        Validate multiple addresses
        """
        results = []
        
        for address in addresses:
            result = self.validate_address(address)
            results.append({
                'address': address,
                'valid': result.get('result', False),
                'message': result.get('message', ''),
                'format': self.check_format(address)['format']
            })
        
        return results
    
    def _get_cached(self, address: str) -> Optional[Dict]:
        """
        Get cached validation result
        """
        with self.cache_lock:
            if address in self.cache:
                cached_time, result = self.cache[address]
                if time() - cached_time < self.cache_timeout:
                    return result
                else:
                    del self.cache[address]
        return None
    
    def _cache_result(self, address: str, result: Dict):
        """
        Cache validation result
        """
        with self.cache_lock:
            self.cache[address] = (time(), result)
    
    def clear_cache(self):
        """
        Clear validation cache
        """
        with self.cache_lock:
            self.cache.clear()
    
    def is_valid_checksum(self, address: str) -> bool:
        """
        Additional checksum validation (simplified)
        Note: Full implementation requires base58 decoding
        """
        format_check = self.check_format(address)
        if not format_check['valid']:
            return False
        
        # For demonstration - actual checksum validation
        # would require proper base58/hex decoding
        return format_check['valid']

class AddressValidationService:
    """
    High-level validation service with additional features
    """
    def __init__(self, api_key: str):
        self.validator = TronAddressValidator(api_key)
        self.stats = {
            'total_validated': 0,
            'valid_count': 0,
            'invalid_count': 0
        }
    
    def validate_with_stats(self, address: str) -> Dict:
        """
        Validate and track statistics
        """
        result = self.validator.validate_address(address)
        
        self.stats['total_validated'] += 1
        if result.get('result'):
            self.stats['valid_count'] += 1
        else:
            self.stats['invalid_count'] += 1
        
        return result
    
    def validate_and_suggest(self, address: str) -> Dict:
        """
        Validate and provide suggestions for invalid addresses
        """
        result = self.validator.validate_address(address)
        
        if not result.get('result'):
            format_check = self.validator.check_format(address)
            
            suggestions = []
            if format_check['format'] == 'unknown':
                if len(address) == 34 and not address.startswith('T'):
                    suggestions.append('TRON addresses should start with "T"')
                elif len(address) == 42 and not address.startswith('41'):
                    suggestions.append('Hex addresses should start with "41"')
                else:
                    suggestions.append('Check address length (34 for Base58, 42 for Hex)')
            
            result['suggestions'] = suggestions
        
        return result
    
    def get_statistics(self) -> Dict:
        """
        Get validation statistics
        """
        total = self.stats['total_validated']
        if total == 0:
            return self.stats
        
        return {
            **self.stats,
            'valid_percentage': (self.stats['valid_count'] / total) * 100,
            'invalid_percentage': (self.stats['invalid_count'] / total) * 100
        }

# Usage examples
if __name__ == "__main__":
    validator = TronAddressValidator('YOUR_API_KEY')
    service = AddressValidationService('YOUR_API_KEY')
    
    try:
        # Single address validation
        result = validator.validate_address('TRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN')
        print(f"Address valid: {result.get('result')}")
        
        # Format checking
        format_check = validator.check_format('TRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN')
        print(f"Format: {format_check['format']}, Valid: {format_check['valid']}")
        
        # Batch validation
        addresses = [
            'TRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN',
            'InvalidAddress',
            '41E552F6487585C2B58BC2C9BB4492BC1F17132CD0',
            'TJmmqjb1DK9TTZbQXzRQ2AuA94z4gKAPFh'
        ]
        
        batch_results = validator.validate_batch(addresses)
        for result in batch_results:
            status = "✓" if result['valid'] else "✗"
            print(f"{status} {result['address'][:10]}... : {result['format']}")
        
        # Validation with suggestions
        invalid_result = service.validate_and_suggest('XRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN')
        if not invalid_result.get('result'):
            print("Invalid address. Suggestions:")
            for suggestion in invalid_result.get('suggestions', []):
                print(f"  - {suggestion}")
        
        # Get statistics
        stats = service.get_statistics()
        print(f"\nValidation Statistics:")
        print(f"  Total: {stats['total_validated']}")
        print(f"  Valid: {stats['valid_count']} ({stats.get('valid_percentage', 0):.1f}%)")
        print(f"  Invalid: {stats['invalid_count']} ({stats.get('invalid_percentage', 0):.1f}%)")
        
    except Exception as e:
        print(f"Error: {e}")

cURL

# Validate Base58 address
curl -X POST "https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/validateaddress" \
  -H "Content-Type: application/json" \
  -d '{
    "address": "TRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN",
    "visible": true
  }'

# Validate Hex address
curl -X POST "https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/validateaddress" \
  -H "Content-Type: application/json" \
  -d '{
    "address": "41E552F6487585C2B58BC2C9BB4492BC1F17132CD0",
    "visible": false
  }'

# Validate invalid address
curl -X POST "https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/validateaddress" \
  -H "Content-Type: application/json" \
  -d '{
    "address": "InvalidAddress123",
    "visible": true
  }'

# Validate and parse result with jq
curl -s -X POST "https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/validateaddress" \
  -H "Content-Type: application/json" \
  -d '{
    "address": "TRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN",
    "visible": true
  }' | jq '{
    is_valid: .result,
    validation_message: .message
  }'

# Batch validation script
#!/bin/bash
API_KEY="YOUR_API_KEY"
ADDRESSES=(
  "TRX6Q82wMqWNbCCmJPLz9mR8AZwqvUU2pN"
  "TJmmqjb1DK9TTZbQXzRQ2AuA94z4gKAPFh"
  "InvalidAddress"
)

for addr in "${ADDRESSES[@]}"; do
  echo "Validating: $addr"
  curl -s -X POST "https://api-tron-mainnet.n.dwellir.com/$API_KEY/wallet/validateaddress" \
    -H "Content-Type: application/json" \
    -d "{\"address\": \"$addr\", \"visible\": true}" | \
    jq -r 'if .result then "✓ Valid" else "✗ Invalid: " + .message end'
  echo ""
done

Response Examples

Valid Address Response

{
  "result": true,
  "message": "Valid address"
}

Invalid Address Response

{
  "result": false,
  "message": "Invalid address format"
}

Malformed Address Response

{
  "result": false,
  "message": "Illegal address"
}

Common Use Cases

1. Form Input Validation

function setupAddressValidation() {
  const input = document.getElementById('addressInput');
  const submitBtn = document.getElementById('submitBtn');
  const feedback = document.getElementById('feedback');
  
  let isValid = false;
  
  input.addEventListener('input', async (e) => {
    const address = e.target.value.trim();
    
    if (!address) {
      feedback.textContent = '';
      submitBtn.disabled = true;
      return;
    }
    
    // Quick format check
    if (!address.startsWith('T') || address.length !== 34) {
      feedback.textContent = '❌ Invalid format';
      feedback.className = 'error';
      submitBtn.disabled = true;
      return;
    }
    
    // API validation
    try {
      const result = await validateAddress(address);
      
      if (result.result) {
        feedback.textContent = '✓ Valid address';
        feedback.className = 'success';
        isValid = true;
      } else {
        feedback.textContent = '❌ ' + result.message;
        feedback.className = 'error';
        isValid = false;
      }
      
      submitBtn.disabled = !isValid;
    } catch (error) {
      feedback.textContent = '⚠️ Validation error';
      feedback.className = 'warning';
      submitBtn.disabled = true;
    }
  });
}

2. Transaction Pre-validation

async function sendTransaction(toAddress, amount) {
  // Validate address before sending
  const validation = await validateAddress(toAddress);
  
  if (!validation.result) {
    throw new Error(`Invalid recipient address: ${validation.message}`);
  }
  
  // Proceed with transaction
  return createTransaction(toAddress, amount);
}

3. Bulk Address Import

async function importAddresses(addressList) {
  const results = {
    valid: [],
    invalid: []
  };
  
  for (const address of addressList) {
    const validation = await validateAddress(address);
    
    if (validation.result) {
      results.valid.push(address);
    } else {
      results.invalid.push({
        address,
        reason: validation.message
      });
    }
  }
  
  return results;
}

Error Handling

Error Type	Description	Solution
Format Error	Invalid address format	Check Base58/Hex format
Length Error	Wrong address length	Verify 34 (Base58) or 42 (Hex) chars
Character Error	Invalid characters	Ensure valid Base58/Hex chars
Network Error	API connection failed	Implement retry logic

function validateWithFallback(address) {
  // Local format validation first
  const formatCheck = checkAddressFormat(address);
  
  if (!formatCheck.valid) {
    return {
      result: false,
      message: formatCheck.message,
      source: 'local'
    };
  }
  
  // API validation with fallback
  return validateAddress(address)
    .catch(error => ({
      result: null,
      message: 'Could not verify with network',
      source: 'error',
      formatValid: true
    }));
}

Best Practices

1. Cache Results - Cache validation results for 60 seconds
2. Format Check First - Validate format locally before API call
3. Debounce Input - Debounce validation on user input
4. Batch Validation - Validate multiple addresses in parallel
5. Error Handling - Gracefully handle validation failures

Related Methods

• wallet/getaccount - Get account information
• wallet/getaccountbalance - Get account balance

---

Need help? Contact support or visit our TRON documentation.