POST /apiv2/time/status

Compruebe el estado completo de todas las direcciones TRON en el Modo Host de su cuenta.

Resumen

El punto final de Estado de Tiempo proporciona una visión completa de todas las direcciones administradas bajo su clave API en el Modo Host. Devuelve información detallada sobre las delegaciones de energía, los recuentos de ciclos, los modos actuales, el estado de facturación y las estadísticas de uso para cada dirección. Este punto final es esencial para monitorear su asignación de energía, realizar un seguimiento del consumo y administrar múltiples direcciones de manera eficiente.

URL del Punto Final

POST https://netts.io/apiv2/time/status

Autenticación

Este punto final utiliza autenticación mediante cuerpo JSON (no encabezados). Solo se requiere su clave API en el cuerpo de la solicitud para recuperar el estado de todas las direcciones asociadas.

Flujo de Autenticación

1. API Key Validation: System verifies the API key exists and is active
2. IP Whitelist Check: Request IP must match configured whitelist
3. Account Status Check: Verifies account is active and in good standing
4. Data Aggregation: Collects status for all addresses under the API key

Encabezados de la Petición

Header	Required	Description
Content-Type	Yes	application/json

Cuerpo de la solicitud

{
    "api_key": "your_api_key"
}

Parámetros

Parameter	Type	Required	Validation	Description
api_key	string	Yes	Must exist in system	Your API key for authentication

Validación de Parámetros

• api_key:

  • Must be a valid 32-character hexadecimal string
  • Must be associated with an active account
  • Account must not be suspended or restricted
  • Must have at least read permissions

• IP Address:

  • Your request IP must be in the whitelist associated with your API key
  • Maximum 5 IP addresses per API key
  • IPv4 and IPv6 supported

Ejemplos de Solicitudes

cURL

curl -X POST https://netts.io/apiv2/time/status \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_API_KEY_HERE"
  }'

Python

import requests
import json
from typing import Dict, List
from datetime import datetime

def get_host_mode_status(api_key: str) -> Dict:
    """
    Get comprehensive status of all addresses in Host Mode.
    
    Args:
        api_key: Your API authentication key
        
    Returns:
        API response dictionary with status for all addresses
    """
    url = "https://netts.io/apiv2/time/status"
    
    data = {
        "api_key": api_key
    }
    
    try:
        response = requests.post(url, json=data, verify=True, timeout=30)
        response.raise_for_status()
        
        result = response.json()
        
        if result['code'] == 0:
            print(f"✅ Status retrieved for {result['data']['total_addresses']} addresses")
            print(f"Account balance: {result['data']['account_balance']} TRX")
            print(f"Total energy delegated: {result['data']['total_energy_delegated']}")
            
            # Display each address status
            for addr in result['data']['addresses']:
                print(f"\n📍 Address: {addr['address']}")
                print(f"   Mode: {addr['mode']}")
                print(f"   Status: {addr['status']}")
                print(f"   Cycles: {addr['cycles_remaining']}")
                print(f"   Energy: {addr['current_energy']}")
                
                if addr['next_delegation_time']:
                    next_time = datetime.fromtimestamp(addr['next_delegation_time'])
                    print(f"   Next delegation: {next_time.strftime('%Y-%m-%d %H:%M:%S')}")
        else:
            print(f"❌ Error: {result['msg']}")
            
        return result
        
    except requests.exceptions.RequestException as e:
        print(f"❌ Request failed: {str(e)}")
        raise
    except json.JSONDecodeError as e:
        print(f"❌ Invalid JSON response: {str(e)}")
        raise

# Example usage with filtering
def display_active_addresses(api_key: str):
    """Display only active addresses with remaining cycles."""
    result = get_host_mode_status(api_key)
    
    if result['code'] == 0:
        active = [a for a in result['data']['addresses'] 
                  if a['status'] == 'active' and a['cycles_remaining'] > 0]
        
        print(f"\n🟢 Active Addresses: {len(active)}")
        for addr in active:
            print(f"  - {addr['address']}: {addr['cycles_remaining']} cycles")

if __name__ == "__main__":
    API_KEY = "YOUR_API_KEY_HERE"
    
    # Get full status
    result = get_host_mode_status(API_KEY)
    
    # Show only active addresses
    display_active_addresses(API_KEY)

Node.js

const axios = require('axios');

/**
 * Get comprehensive status of all addresses in Host Mode
 * @param {string} apiKey - Your API authentication key
 * @returns {Promise<Object>} API response with status data
 */
async function getHostModeStatus(apiKey) {
    const url = 'https://netts.io/apiv2/time/status';
    
    const data = {
        api_key: apiKey
    };
    
    try {
        const response = await axios.post(url, data, {
            headers: {
                'Content-Type': 'application/json'
            },
            timeout: 30000
        });
        
        const result = response.data;
        
        if (result.code === 0) {
            console.log(`✅ Status retrieved for ${result.data.total_addresses} addresses`);
            console.log(`Account balance: ${result.data.account_balance} TRX`);
            console.log(`Total energy delegated: ${result.data.total_energy_delegated}`);
            
            // Display each address status
            result.data.addresses.forEach(addr => {
                console.log(`\n📍 Address: ${addr.address}`);
                console.log(`   Mode: ${addr.mode}`);
                console.log(`   Status: ${addr.status}`);
                console.log(`   Cycles: ${addr.cycles_remaining}`);
                console.log(`   Energy: ${addr.current_energy}`);
                
                if (addr.next_delegation_time) {
                    const nextTime = new Date(addr.next_delegation_time * 1000);
                    console.log(`   Next delegation: ${nextTime.toLocaleString()}`);
                }
            });
        } else {
            console.error(`❌ Error: ${result.msg}`);
        }
        
        return result;
        
    } catch (error) {
        if (error.response) {
            console.error(`❌ API Error: ${error.response.status} - ${error.response.data?.msg || error.message}`);
        } else if (error.request) {
            console.error('❌ No response from server');
        } else {
            console.error(`❌ Request failed: ${error.message}`);
        }
        throw error;
    }
}

/**
 * Get summary statistics from status data
 * @param {Object} statusData - Status response data
 * @returns {Object} Summary statistics
 */
function getStatusSummary(statusData) {
    if (!statusData || !statusData.addresses) return null;
    
    const summary = {
        totalAddresses: statusData.total_addresses,
        activeAddresses: 0,
        pausedAddresses: 0,
        infinityModeAddresses: 0,
        totalCycles: 0,
        totalEnergyAllocated: 0
    };
    
    statusData.addresses.forEach(addr => {
        if (addr.status === 'active') summary.activeAddresses++;
        if (addr.status === 'paused') summary.pausedAddresses++;
        if (addr.mode === 'infinity') summary.infinityModeAddresses++;
        summary.totalCycles += addr.cycles_remaining || 0;
        summary.totalEnergyAllocated += addr.current_energy || 0;
    });
    
    return summary;
}

// Example usage
(async () => {
    const API_KEY = 'YOUR_API_KEY_HERE';
    
    try {
        const result = await getHostModeStatus(API_KEY);
        
        if (result.code === 0) {
            const summary = getStatusSummary(result.data);
            console.log('\n📊 Summary Statistics:');
            console.log(summary);
        }
    } catch (error) {
        console.error('Failed to get status:', error.message);
    }
})();

PHP

<?php

/**
 * Get comprehensive status of all addresses in Host Mode
 * 
 * @param string $apiKey Your API authentication key
 * @return array API response with status data
 */
function getHostModeStatus($apiKey) {
    $url = 'https://netts.io/apiv2/time/status';
    
    $data = [
        'api_key' => $apiKey
    ];
    
    $options = [
        'http' => [
            'header' => "Content-Type: application/json\r\n",
            'method' => 'POST',
            'content' => json_encode($data),
            'timeout' => 30
        ]
    ];
    
    $context = stream_context_create($options);
    $response = @file_get_contents($url, false, $context);
    
    if ($response === false) {
        $error = error_get_last();
        throw new RuntimeException('Request failed: ' . $error['message']);
    }
    
    $result = json_decode($response, true);
    
    if ($result['code'] == 0) {
        echo "✅ Status retrieved for {$result['data']['total_addresses']} addresses\n";
        echo "Account balance: {$result['data']['account_balance']} TRX\n";
        echo "Total energy delegated: {$result['data']['total_energy_delegated']}\n\n";
        
        // Display each address status
        foreach ($result['data']['addresses'] as $addr) {
            echo "📍 Address: {$addr['address']}\n";
            echo "   Mode: {$addr['mode']}\n";
            echo "   Status: {$addr['status']}\n";
            echo "   Cycles: {$addr['cycles_remaining']}\n";
            echo "   Energy: {$addr['current_energy']}\n";
            
            if ($addr['next_delegation_time']) {
                $nextTime = date('Y-m-d H:i:s', $addr['next_delegation_time']);
                echo "   Next delegation: $nextTime\n";
            }
            echo "\n";
        }
    } else {
        echo "❌ Error: {$result['msg']}\n";
    }
    
    return $result;
}

/**
 * Filter addresses by status
 * 
 * @param array $addresses List of addresses from status response
 * @param string $status Status to filter by ('active', 'paused', 'stopped')
 * @return array Filtered addresses
 */
function filterAddressesByStatus($addresses, $status) {
    return array_filter($addresses, function($addr) use ($status) {
        return $addr['status'] === $status;
    });
}

/**
 * Calculate total cycles across all addresses
 * 
 * @param array $addresses List of addresses from status response
 * @return int Total cycles
 */
function calculateTotalCycles($addresses) {
    $total = 0;
    foreach ($addresses as $addr) {
        $total += $addr['cycles_remaining'] ?? 0;
    }
    return $total;
}

// Example usage
$API_KEY = 'YOUR_API_KEY_HERE';

try {
    $result = getHostModeStatus($API_KEY);
    
    if ($result['code'] == 0) {
        // Get active addresses
        $activeAddresses = filterAddressesByStatus($result['data']['addresses'], 'active');
        echo "Active addresses: " . count($activeAddresses) . "\n";
        
        // Calculate total cycles
        $totalCycles = calculateTotalCycles($result['data']['addresses']);
        echo "Total cycles remaining: $totalCycles\n";
    }
} catch (Exception $e) {
    echo "Failed to get status: " . $e->getMessage() . "\n";
}
?>

Ruby

require 'net/http'
require 'json'
require 'uri'

class HostModeStatus
  API_URL = 'https://netts.io/apiv2/time/status'
  
  def initialize(api_key)
    @api_key = api_key
  end
  
  # Get comprehensive status of all addresses in Host Mode
  def get_status
    uri = URI.parse(API_URL)
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.read_timeout = 30
    
    request = Net::HTTP::Post.new(uri.path)
    request['Content-Type'] = 'application/json'
    request.body = { api_key: @api_key }.to_json
    
    begin
      response = http.request(request)
      result = JSON.parse(response.body)
      
      if result['code'] == 0
        puts "✅ Status retrieved for #{result['data']['total_addresses']} addresses"
        puts "Account balance: #{result['data']['account_balance']} TRX"
        puts "Total energy delegated: #{result['data']['total_energy_delegated']}"
        
        display_addresses(result['data']['addresses'])
      else
        puts "❌ Error: #{result['msg']}"
      end
      
      result
    rescue => e
      puts "❌ Request failed: #{e.message}"
      raise
    end
  end
  
  private
  
  # Display address details
  def display_addresses(addresses)
    addresses.each do |addr|
      puts "\n📍 Address: #{addr['address']}"
      puts "   Mode: #{addr['mode']}"
      puts "   Status: #{addr['status']}"
      puts "   Cycles: #{addr['cycles_remaining']}"
      puts "   Energy: #{addr['current_energy']}"
      
      if addr['next_delegation_time']
        next_time = Time.at(addr['next_delegation_time'])
        puts "   Next delegation: #{next_time.strftime('%Y-%m-%d %H:%M:%S')}"
      end
    end
  end
  
  # Get addresses that need attention
  def get_addresses_needing_attention(addresses)
    addresses.select do |addr|
      addr['cycles_remaining'] < 5 || addr['status'] == 'error'
    end
  end
  
  # Calculate statistics
  def calculate_statistics(addresses)
    stats = {
      total: addresses.length,
      active: 0,
      paused: 0,
      infinity: 0,
      total_cycles: 0,
      total_energy: 0
    }
    
    addresses.each do |addr|
      stats[:active] += 1 if addr['status'] == 'active'
      stats[:paused] += 1 if addr['status'] == 'paused'
      stats[:infinity] += 1 if addr['mode'] == 'infinity'
      stats[:total_cycles] += addr['cycles_remaining'] || 0
      stats[:total_energy] += addr['current_energy'] || 0
    end
    
    stats
  end
end

# Example usage
api_key = 'YOUR_API_KEY_HERE'
status_checker = HostModeStatus.new(api_key)

begin
  result = status_checker.get_status
  
  if result['code'] == 0
    stats = status_checker.calculate_statistics(result['data']['addresses'])
    puts "\n📊 Statistics:"
    puts stats
  end
rescue => e
  puts "Failed: #{e.message}"
end

Respuesta

Respuesta exitosa (200 OK)

{
    "code": 0,
    "msg": "Status retrieved successfully",
    "data": {
        "total_addresses": 3,
        "account_balance": 500.50,
        "total_energy_delegated": 393000,
        "total_cycles_remaining": 45,
        "account_status": "active",
        "api_key_status": "active",
        "addresses": [
            {
                "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
                "mode": "standard",
                "status": "active",
                "cycles_remaining": 15,
                "cycles_used": 10,
                "current_energy": 131000,
                "energy_usage_24h": 95000,
                "delegation_active": true,
                "next_delegation_time": 1699615200,
                "last_delegation_time": 1699528800,
                "added_at": 1699442400,
                "last_activity": 1699528000,
                "transaction_count_24h": 42,
                "average_energy_per_tx": 2261,
                "delegation_history": [
                    {
                        "timestamp": 1699528800,
                        "energy": 131000,
                        "tx_hash": "abc123..."
                    }
                ]
            },
            {
                "address": "TYn8Y3khEsLJW2ChVWFMSMeRDow6KcbMTF",
                "mode": "infinity",
                "status": "active",
                "cycles_remaining": -1,
                "cycles_used": 0,
                "current_energy": 131000,
                "energy_usage_24h": 120000,
                "delegation_active": true,
                "next_delegation_time": 1699615200,
                "last_delegation_time": 1699528800,
                "infinity_start_date": 1699200000,
                "daily_cost": 30,
                "next_billing_date": 1699615200,
                "added_at": 1699200000,
                "last_activity": 1699528500,
                "transaction_count_24h": 156,
                "average_energy_per_tx": 769
            },
            {
                "address": "TZn9Y4khEsLJW3ChVWFMSMeRDow7KcbNUG",
                "mode": "standard",
                "status": "paused",
                "cycles_remaining": 30,
                "cycles_used": 5,
                "current_energy": 0,
                "energy_usage_24h": 0,
                "delegation_active": false,
                "next_delegation_time": null,
                "last_delegation_time": 1699356000,
                "paused_at": 1699442400,
                "pause_reason": "user_requested",
                "added_at": 1699100000,
                "last_activity": 1699442400,
                "transaction_count_24h": 0,
                "average_energy_per_tx": 0
            }
        ],
        "summary": {
            "active_addresses": 2,
            "paused_addresses": 1,
            "stopped_addresses": 0,
            "infinity_mode_addresses": 1,
            "standard_mode_addresses": 2,
            "addresses_low_cycles": 0,
            "addresses_no_cycles": 0,
            "total_energy_capacity": 393000,
            "total_energy_used_24h": 215000,
            "energy_utilization_rate": 54.7
        },
        "billing": {
            "current_period_charges": 45.00,
            "pending_charges": 0,
            "last_payment_date": 1699442400,
            "next_billing_date": 1699615200,
            "payment_method": "account_balance",
            "auto_recharge_enabled": true,
            "auto_recharge_threshold": 100,
            "auto_recharge_amount": 500
        },
        "limits": {
            "max_addresses": 100,
            "max_cycles_per_address": 10000,
            "max_daily_spend": 1000,
            "current_daily_spend": 45.00
        }
    }
}

Campos de Respuesta

Field	Type	Description
code	integer	Status code (0 for success, -1 for error)
msg	string	Human-readable status message
data	object	Response data object
data.total_addresses	integer	Total number of addresses in Host Mode
data.account_balance	number	Current account balance in TRX
data.total_energy_delegated	integer	Total energy currently delegated across all addresses
data.total_cycles_remaining	integer	Sum of all remaining cycles (excluding infinity mode)
data.account_status	string	Account status ("active", "suspended", "limited")
data.api_key_status	string	API key status ("active", "expired", "revoked")
data.addresses	array	Array of address objects with detailed status
data.summary	object	Summary statistics across all addresses
data.billing	object	Billing information and payment details
data.limits	object	Account limits and current usage

Campos del Objeto Dirección

Field	Type	Description
address	string	TRON address
mode	string	Current mode ("standard", "infinity")
status	string	Current status ("active", "paused", "stopped", "error")
cycles_remaining	integer	Number of cycles remaining (-1 for infinity mode)
cycles_used	integer	Number of cycles consumed
current_energy	integer	Currently delegated energy amount
energy_usage_24h	integer	Energy consumed in last 24 hours
delegation_active	boolean	Whether delegation is currently active
next_delegation_time	integer|null	Unix timestamp for next delegation
last_delegation_time	integer|null	Unix timestamp of last delegation
added_at	integer	Unix timestamp when added to Host Mode
last_activity	integer	Unix timestamp of last activity
transaction_count_24h	integer	Number of transactions in last 24 hours
average_energy_per_tx	number	Average energy per transaction
delegation_history	array	Recent delegation history (last 5)

Campos Adicionales para el Modo Infinito

Field	Type	Description
infinity_start_date	integer	Unix timestamp when infinity mode started
daily_cost	number	Daily cost in TRX for infinity mode
next_billing_date	integer	Unix timestamp for next billing

Campos Adicionales para Estado Pausado

Field	Type	Description
paused_at	integer	Unix timestamp when paused
pause_reason	string	Reason for pause ("user_requested", "insufficient_balance", "error")

Respuestas de Error

Error de Autenticación (401)

{
    "code": -1,
    "msg": "Invalid API key",
    "data": null
}

Causes:

• Invalid or expired API key
• API key not found in system
• Account suspended or terminated

Resolution:

• Verify API key is correct
• Check account status in dashboard
• Contact support if key should be valid

No se encontraron direcciones (404)

{
    "code": -1,
    "msg": "No addresses found in Host Mode",
    "data": {
        "suggestion": "Use /time/add to add addresses to Host Mode",
        "api_key": "248f***4a"
    }
}

Causes:

• No addresses added to Host Mode yet
• All addresses have been deleted
• Wrong API key being used

Resolution:

• Add addresses using /time/add endpoint
• Verify using correct API key
• Check if addresses were deleted

IP no incluida en la lista blanca (403)

{
    "code": -1,
    "msg": "IP address not whitelisted",
    "data": {
        "ip": "192.168.1.100",
        "suggestion": "Add this IP to whitelist in dashboard"
    }
}

Causes:

• Request IP not in API key whitelist
• IP address changed since configuration
• Using proxy or VPN

Resolution:

• Add IP to whitelist in dashboard
• Verify not using proxy/VPN
• Contact support to update whitelist

Cuenta suspendida (403)

{
    "code": -1,
    "msg": "Account suspended",
    "data": {
        "reason": "payment_failure",
        "suspended_at": 1699442400,
        "contact": "[email protected]"
    }
}

Causes:

• Failed payments
• Terms of service violation
• Suspicious activity detected

Resolution:

• Resolve payment issues
• Contact support for reinstatement
• Review account activity

Límites de Tasa

Period	Limit	Description
1 minute	60 requests	Higher limit for status checks
1 hour	1000 requests	Maximum 1000 requests per hour
1 day	10000 requests	Maximum 10000 requests per day

Encabezados de Límite de Tasa

X-RateLimit-Limit-Minute: 60
X-RateLimit-Remaining-Minute: 59
X-RateLimit-Reset-Minute: 1699528860

X-RateLimit-Limit-Hour: 1000
X-RateLimit-Remaining-Hour: 998
X-RateLimit-Reset-Hour: 1699532400

X-RateLimit-Limit-Day: 10000
X-RateLimit-Remaining-Day: 9995
X-RateLimit-Reset-Day: 1699574400

Respuesta de Límite de Tasa Excedido (429)

{
    "code": -1,
    "msg": "API rate limit exceeded",
    "data": {
        "retry_after": 45,
        "limit": "60 per minute",
        "reset_at": 1699528860
    }
}

Comprender los Datos de Estado

Modos de Dirección

1. Modo Estándar

   • Fixed number of cycles
   • Manual cycle purchases
   • Cycles consumed sequentially
   • Shown as mode: "standard"

2. Modo Infinito

   • Unlimited cycles
   • Daily billing
   • Auto-renewal
   • Shown as mode: "infinity"
   • cycles_remaining: -1 indicates unlimited

Valores de Estado de Dirección

Status	Description	Can Receive Energy	Action Required
active	Normal operation	Yes	None
paused	Temporarily stopped	No	Use /time/infinitystart to resume
stopped	Permanently stopped	No	Use /time/add to restart
error	Problem detected	Maybe	Check error details
pending	Activation in progress	Soon	Wait for activation
expired	All cycles consumed	No	Purchase more cycles

Estados de Energía

1. Delegated Energy (current_energy)

   • Amount currently delegated to address
   • Usually 131,000 when active
   • 0 when paused or stopped

2. Energy Usage (energy_usage_24h)

   • Actual consumption in last 24 hours
   • Helps optimize cycle purchases
   • Used for utilization calculations

3. Energy Efficiency (average_energy_per_tx)

   • Average energy per transaction
   • Lower is more efficient
   • Helps identify optimization opportunities

Información del Ciclo

• cycles_remaining: Unused cycles in queue
• cycles_used: Historical count of consumed cycles
• -1: Indicates infinity mode (unlimited)
• 0: No cycles, needs purchase or infinity mode

Estadísticas resumidas

Métricas Clave

1. Tasa de Utilización

   utilization_rate = (total_energy_used_24h / total_energy_capacity) × 100

   • Shows efficiency of energy allocation
   • High rate (>80%) suggests need for more energy
   • Low rate (<30%) suggests over-provisioning

2. Salud de la Dirección

   • Healthy: Active with sufficient cycles
   • Warning: <5 cycles remaining
   • Critical: 0 cycles or error status

3. Análisis de Costos

   • Daily spend rate
   • Cost per transaction
   • Infinity vs standard mode comparison

Recomendaciones de Monitoreo

Metric	Good	Warning	Critical
Cycles Remaining	>10	5-10	<5
Utilization Rate	50-80%	30-50% or 80-90%	<30% or >90%
Failed Transactions	0	1-5 per day	>5 per day
Account Balance	>30 days cost	7-30 days	<7 days

Usando Datos de Estado

Casos de Uso Común

1. Panel de Monitoreo

   # Poll status every 5 minutes
   import time
   
   while True:
       status = get_host_mode_status(API_KEY)
       update_dashboard(status)
       check_alerts(status)
       time.sleep(300)

2. Alerta de Ciclo Bajo

   // Check for addresses with low cycles
   const lowCycleAddresses = result.data.addresses.filter(
       addr => addr.cycles_remaining > 0 && addr.cycles_remaining < 5
   );
   
   if (lowCycleAddresses.length > 0) {
       sendAlert('Low cycles detected', lowCycleAddresses);
   }

3. Optimización de Costos

   # Compare standard vs infinity mode costs
   def analyze_cost_efficiency(status_data):
       for addr in status_data['addresses']:
           if addr['mode'] == 'standard':
               daily_cycles = addr['energy_usage_24h'] / 131000
               standard_cost = daily_cycles * 3.0  # Price per cycle
               infinity_cost = 30.0  # Daily infinity rate
               
               if standard_cost > infinity_cost:
                   print(f"{addr['address']} would save with infinity mode")

4. Compra Automatizada de Ciclo

   // Auto-purchase cycles when low
   async function maintainCycles(minCycles = 10) {
       const status = await getHostModeStatus(API_KEY);
       
       for (const addr of status.data.addresses) {
           if (addr.cycles_remaining < minCycles && addr.mode === 'standard') {
               await orderCycles(API_KEY, addr.address, 50);
               console.log(`Ordered 50 cycles for ${addr.address}`);
           }
       }
   }

Información de Facturación

Comprendiendo los Datos de Facturación

1. Cargos del Período Actual

   • Accumulated charges in current billing period
   • Includes cycle purchases and infinity mode fees
   • Resets at billing cycle end

2. Métodos de Pago

   • account_balance: Using prepaid balance
   • card: Credit/debit card on file
   • crypto: Cryptocurrency payments
   • invoice: Enterprise invoicing

3. Recarga automática

   • Automatically tops up balance when low
   • Configurable threshold and amount
   • Prevents service interruption

Ciclos de Facturación

Billing Type	Period	Charge Time	Invoice
Cycle Purchase	Immediate	At purchase	Yes
Infinity Daily	24 hours	Midnight UTC	Daily
Infinity Weekly	7 days	Sunday UTC	Weekly
Infinity Monthly	30 days	1st of month	Monthly

Detalles técnicos

Almacenamiento en caché de respuestas

• Status data cached for 30 seconds
• Real-time delegation status always fresh
• Historical data updated every 5 minutes
• Force refresh available via header

Agregación de Datos

El punto final de estado agrega datos de múltiples fuentes:

1. Database: Address configuration, cycles, history
2. Blockchain: Current delegations, energy levels
3. Cache: Recent transactions, usage statistics
4. Billing System: Charges, payments, balances

Consideraciones de Rendimiento

• Response time: 200-500ms typical
• Large accounts (>50 addresses): 500-1000ms
• Maximum addresses returned: 1000
• Pagination available for large accounts

Consideraciones de Seguridad

Privacidad de datos

• Only shows addresses owned by API key
• No cross-account data exposure
• Sensitive data (full API key) redacted
• Transaction hashes truncated

Control de Acceso

1. Acceso de solo lectura

   • Status endpoint is read-only
   • Cannot modify addresses or settings
   • Safe for monitoring systems

2. Restricciones de IP

   • Enforced even for read operations
   • Prevents unauthorized access
   • Logs all access attempts

3. Limitación de Tasa

   • Higher limits for status checks
   • Prevents abuse and scanning
   • Per-API-key enforcement

Puntos Finales Relacionados

• POST /apiv2/time/add - Add new addresses to Host Mode
• "POST /apiv2/time/order" - Purchase cycles for addresses
• POST /apiv2/time/infinitystart - Enable infinity mode
• "POST /apiv2/time/stop" - Pause energy delegations
• POST /apiv2/time/delete - Remove addresses from Host Mode

Mejores Prácticas

Estrategia de Monitoreo

1. Consulta Regular

   • Check status every 5-15 minutes
   • More frequent during high activity
   • Less frequent during off-hours

2. Umbrales de Alerta

   • Low cycles: <5 remaining
   • Low balance: <7 days of costs
   • High utilization: >90%
   • Errors: Any error status

3. Retención de Datos

   • Store status snapshots hourly
   • Keep daily summaries for 30 days
   • Archive monthly reports

Patrones de Integración

1. Integración del Panel

   // Update dashboard with real-time data
   setInterval(async () => {
       const status = await getHostModeStatus(API_KEY);
       updateDashboard(status);
       checkAlerts(status);
   }, 300000); // Every 5 minutes

2. Disparadores Webhook

   # Trigger webhooks based on status
   def check_status_triggers(status_data):
       for addr in status_data['addresses']:
           if addr['cycles_remaining'] < 5:
               trigger_webhook('low_cycles', addr)
           if addr['status'] == 'error':
               trigger_webhook('address_error', addr)

3. Gestión Automatizada

   # Automated address management
   def manage_addresses(status_data):
       for addr in status_data['addresses']:
           # Auto-purchase cycles
           if addr['cycles_remaining'] < 10:
               order_cycles(addr['address'], 50)
           
           # Switch to infinity for high usage
           if addr['energy_usage_24h'] > 300000:
               enable_infinity_mode(addr['address'])

Solución de problemas

Problemas Comunes

Lista de Direcciones Vacía

Problema: El estado no devuelve direcciones a pesar de haberlas añadido

Solutions:

• Verify correct API key is being used
• Check if addresses were deleted
• Ensure addresses were successfully added
• Wait 1-2 minutes after adding for propagation

Datos Obsoletos

Problema: Los datos de estado parecen obsoletos

Solutions:

• Check last_activity timestamps
• Verify blockchain connectivity
• Force cache refresh with header
• Contact support if persists

Campos Faltantes

Problema: Algunos campos esperados son nulos o están ausentes

Solutions:

• Check if address is in correct mode
• Some fields only appear for specific statuses
• Infinity mode has different fields than standard
• Review field documentation

Valores de Energía Incorrectos

Problema: Los valores de Energía no coinciden con las expectativas

Solutions:

• Energy updates may have 1-2 minute delay
• Check blockchain for confirmation
• Verify delegation transaction completed
• Consider network congestion

Problemas de Rendimiento

Tiempos de Respuesta Lentos

Síntomas: El punto final de estado tarda >2 segundos

Solutions:

• Check number of addresses (pagination for >100)
• Verify network connectivity
• Consider caching responses client-side
• Use summary endpoint for overview

Problemas de Límite de Tasa

Síntomas: Alcanzar los límites de velocidad con frecuencia

Solutions:

• Reduce polling frequency
• Implement exponential backoff
• Cache responses appropriately
• Consider webhook notifications instead

Notas

• Real-Time Data: Energy and delegation status are real-time from blockchain
• Historical Data: Transaction counts and usage stats update every 5 minutes
• Billing Data: Payment and charge information updates immediately
• No Filtering: All addresses returned; filter client-side if needed
• Timezone: All timestamps in Unix format (UTC)
• Precision: Energy amounts in base units (1 TRX = 1,000,000 SUN)
• Infinity Mode: Shows as -1 cycles (unlimited)
• Pagination: Available for accounts with >1000 addresses
• Webhooks: Consider webhooks for real-time updates instead of polling
• Caching: Implement client-side caching to reduce API calls
• Batch Operations: Status check is more efficient than individual address queries
• Mobile Apps: Higher rate limits available for verified mobile applications
• Enterprise: Custom endpoints available for enterprise accounts
• SLA: 99.9% uptime guarantee for status endpoint
• Monitoring: Built-in monitoring and alerting for enterprise accounts