¿Requiere autenticación la API de TronEnergy?

No se requiere clave de API ni registro. Se autentica cada solicitud firmando un mensaje que prueba que usted es el remitente del pago. Sin credenciales, sin claves de API.

¿Cómo funciona el flujo de delegación?

Envíe TRX a la dirección de pago. Firme el mensaje {tx_hash}:{delegate_to} para demostrar que es el remitente. Llame a POST /delegate con tx_hash, delegate_to y signature. La energía llega en ~3 segundos.

Referencia de API de Alquiler de Energía Tron: Endpoints REST e Integración

Q: ¿Qué sucede si la delegación falla después del pago?

Un reembolso en TRX se encola automáticamente y se envía de vuelta a la dirección del remitente en la cadena.

URL base: https://api.tronnrg.com Autenticación: Ninguna requerida. Todos los endpoints son públicos. Límite de velocidad: 20 solicitudes/segundo por IP Dirección de pago: TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx (Solo API, no para alquileres manuales)

Cómo Funciona

Tres pasos. Sin clave API, sin registro, sin conexión de billetera. La propiedad se verifica criptográficamente.

Enviar TRX — Envía 4 TRX (o más) a la dirección de pago. 4 TRX = 65,000 energía. 8 TRX = 130,000. Lineal.
Firmar — Firma el mensaje {tx_hash}:{delegate_to} usando la billetera que envió los TRX. Esto demuestra que autorizaste la delegación.
Reclamar — POST /delegate con tx_hash, delegate_to, y signature. La energía llega en ~3 segundos.

Dirección de Pago

TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx

Dirección de pago de API solamente. Esta dirección es para integraciones programáticas a través de la API. No la uses para alquileres de energía manuales. La dirección de alquiler manual es diferente y está disponible en .tronnrg.com.

Envía TRX a esta dirección. El hash de transacción de tu pago es tu token para activar la delegación. Cada hash solo se puede usar una vez.

TRX Enviados	Energía Delegada	Caso de Uso
4 TRX	65,000	Transferencia USDT estándar a una billetera existente (pedido mínimo)
8 TRX	130,000	Transferencia USDT a un destinatario por primera vez
16 TRX	260,000	Cuatro transferencias estándar en un pedido
40 TRX	650,000	Diez transferencias estándar
100 TRX	1,625,000	~25 transferencias estándar — común para plataformas pequeñas
1,000 TRX	16,250,000	Pedido máximo, ~250 transferencias estándar
Cualquier cantidad entre estos valores	`trx × 16,250`	Totalmente lineal. Sin niveles, sin paquetes, sin descuentos.

Fórmula: energy = trxSent × 16,250. Límites: mín 4 TRX (65,000 energía), máx 1,000 TRX (16,250,000 energía). Ambos se aplican a nivel de API — los montos por debajo del mínimo se rechazan con below_minimum y se reembolsan; los montos por encima del máximo se rechazan antes de la delegación.

POST /delegate

POST/delegate

Solicita una delegación de energía. Debes haber enviado TRX a la dirección de pago en-chain. Proporciona el hash de la transacción, la dirección del destinatario y una firma que demuestre que eres el remitente.

Parámetro	Tipo		Descripción
tx_hash	string	requerido	Hash hexadecimal de 64 caracteres del pago en TRX
delegate_to	string	requerido	Dirección Tron que recibirá la energía
signature	string	requerido	tronWeb.trx.signMessageV2() de `tronWeb.trx.signMessageV2()`. Demuestra que eres el remitente del pago.

curl -X POST https://api.tronnrg.com/delegate \
  -H "Content-Type: application/json" \
  -d '{"tx_hash":"TX_HASH","delegate_to":"TWallet","signature":"SIG"}'

const result = await fetch('https://api.tronnrg.com/delegate', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    tx_hash: 'YOUR_TX_HASH',
    delegate_to: 'TWalletAddress',
    signature: 'YOUR_SIGNATURE',
  }),
}).then(r => r.json());

if (result.error) {
  console.error(result.error, result.message);
} else {
  console.log('Delegated:', result.energy, 'energy');
  console.log('Ref:', result.ref);
}

import requests

response = requests.post('https://api.tronnrg.com/delegate', json={
    'tx_hash': 'YOUR_TX_HASH',
    'delegate_to': 'TWalletAddress',
    'signature': 'YOUR_SIGNATURE',
})
result = response.json()

if 'error' in result:
    print(f"Error: {result['error']} - {result['message']}")
else:
    print(f"Delegated: {result['energy']} energy")
print(f"Delegation tx: {result['delegations'][0]['tx']}")
print(f"Ref: {result['ref']}")

$ch = curl_init('https://api.tronnrg.com/delegate');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
    CURLOPT_POSTFIELDS => json_encode([
        'tx_hash' => 'YOUR_TX_HASH',
        'delegate_to' => 'TWalletAddress',
        'signature' => 'YOUR_SIGNATURE',
    ]),
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

if (isset($result['error'])) {
    echo "Error: " . $result['message'];
} else {
    echo "Delegated: " . $result['energy'] . " energy";
}

var client = new HttpClient();
var content = new StringContent(
    JsonSerializer.Serialize(new {
        tx_hash = "YOUR_TX_HASH",
        delegate_to = "TWalletAddress",
        signature = "YOUR_SIGNATURE"
    }),
    Encoding.UTF8, "application/json"
);

var response = await client.PostAsync("https://api.tronnrg.com/delegate", content);
var json = await response.Content.ReadAsStringAsync();
var result = JsonSerializer.Deserialize<JsonElement>(json);

if (result.TryGetProperty("error", out var err))
    Console.WriteLine($"Error: {err}");
else
    Console.WriteLine($"Delegated: {result.GetProperty("energy")} energy");

Respuesta 200
{
  "ref": "nrg_d_42",
  "delegate_to": "TWalletAddress",
  "energy": 65000,
  "cost": 4,
  "status": "delegated",
  "delegations": [
    { "tx": "a1b2c3d4e5f6...your delegation tx hash", "energy": 65000 }
  ]
}

Campo	Tipo	Descripción
ref	string	ID de referencia de TronNRG. Guárdalo para consultas de soporte.
energy	number	Energía total delegada
cost	number	TRX cobrados
status	string	"delegated" en caso de éxito
delegations	array	Hashes de transacciones de delegación en-chain. Cada `tx` es verificable en TronScan. Este es tu comprobante.

GET /health

GET/health

Verificación de disponibilidad para herramientas de monitoreo y uptime. Devuelve 200 OK cuando el proceso API está activo. No verifica nodos proveedores ni upstream.

Respuesta 200

{ "status": "ok" }

Códigos de Error

Cada respuesta de error tiene error (estable, legible por máquina) y message (legible por humanos). Siempre verifica error en tu código.

Código	HTTP	Significado
`invalid_tx_hash`	400	No es una cadena hexadecimal de 64 caracteres
`invalid_address`	400	No es una dirección Tron válida
`missing_signature`	400	No se proporcionó firma
`invalid_signature`	401	No se pudo verificar la firma
`signature_mismatch`	403	La dirección del firmante no coincide con el remitente del pago
`hash_already_used`	409	El hash de la transacción ya ha sido reclamado
`payment_verification_failed`	404 / 400	La verificación en-chain del pago falló. Lee el campo `message` para conocer la causa específica: transacción no encontrada aún (404, reintentar en unos segundos), destinatario incorrecto, no es una transferencia de TRX, o está por debajo del mínimo de 4 TRX.
`delegation_failed`	400 / 500	El proveedor no pudo entregar energía. Si la falla ocurrió después de verificar el pago, se cola automáticamente un reembolso. Consulta el objeto `refund` cuando esto suceda.
`rate_limited`	429	Demasiadas solicitudes por segundo desde esta IP. El límite es 20/seg.
`server_error`	500	Error interno inesperado. Reintentar en unos segundos.

const result = await fetch('https://api.tronnrg.com/delegate', { ... })
  .then(r => r.json());

if (result.error) {
  switch (result.error) {
    case 'payment_verification_failed':
      // Most common cause: tx not yet indexed. Wait 3s and retry.
      // Read result.message for the specific cause.
      break;
    case 'hash_already_used':
      // Already claimed. Don't retry.
      break;
    case 'signature_mismatch':
      // Signer != payment sender. Sign with the same key that sent TRX.
      break;
    case 'delegation_failed':
      // Refund queued automatically if payment was verified.
      if (result.refund) console.log('Refund queued:', result.refund);
      break;
  }
}

result = requests.post('https://api.tronnrg.com/delegate', json=data).json()

if 'error' in result:
    if result['error'] == 'payment_verification_failed':
        # Most common cause: tx not yet indexed. Wait 3s and retry.
        pass
    elif result['error'] == 'hash_already_used':
        # Already claimed. Don't retry.
        pass
    elif result['error'] == 'signature_mismatch':
        # Signer != payment sender. Sign with the same key.
        pass
    elif result['error'] == 'delegation_failed':
        # Refund queued automatically if payment was verified.
        pass

if (isset($result['error'])) {
    switch ($result['error']) {
        case 'payment_verification_failed':
            // Most common cause: tx not yet indexed. Wait 3s and retry.
            break;
        case 'hash_already_used':
            // Already claimed. Don't retry.
            break;
        case 'signature_mismatch':
            // Signer != payment sender. Sign with the same key.
            break;
        case 'delegation_failed':
            // Refund queued automatically if payment was verified.
            break;
    }
}

Reembolsos

Si la delegación falla después de que se verifique su pago, un reembolso en TRX se encola automáticamente y se envía de vuelta a la dirección del remitente en la cadena. Busque el objeto de reembolso en la respuesta de error.

Error con reembolso
{
  "error": "delegation_failed",
  "message": "Energy delegation failed. Your payment will be refunded.",
  "ref": "nrg_d_43",
  "refund": {
    "type": "queued",
    "to": "TSenderAddress",
    "amount": 4
  }
}

Ejemplo Completo

Flujo completo de extremo a extremo: envía TRX, firma, reclama con reintentos. Copia y ejecuta.

const API  = 'https://api.tronnrg.com';
const ADDR = 'TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx';

async function rentEnergy(delegateTo, trxAmount = 4) {
  // 1. Send TRX to the payment address
  const payment = await tronWeb.trx.sendTransaction(ADDR, trxAmount * 1e6);

  // 2. Sign: proves you are the sender
  const message = `${payment.txid}:${delegateTo}`;
  const signature = await tronWeb.trx.signMessageV2(message);

  // 3. Claim delegation (retry if tx not indexed yet)
  let result;
  for (let i = 0; i < 3; i++) {
    result = await fetch(`${API}/delegate`, {
      method:  'POST',
      headers: { 'Content-Type': 'application/json' },
      body:    JSON.stringify({
        tx_hash:     payment.txid,
        delegate_to: delegateTo,
        signature,
      }),
    }).then(r => r.json());

    if (!result.error) break;
    if (result.error !== 'payment_verification_failed') throw new Error(result.message);
    await new Promise(r => setTimeout(r, 3000));
  }

  if (result.error) throw new Error(result.message);
  return result;
}

// Usage — send any amount between 4 and 1,000 TRX
const result = await rentEnergy('TWalletThatNeedsEnergy', 4);  // 4 TRX → 65k energy
// rentEnergy(addr, 8)    // → 130,000 energy (new-wallet transfer)
// rentEnergy(addr, 40)   // → 650,000 energy (10 transfers)
// rentEnergy(addr, 1000) // → 16,250,000 energy (max)
console.log(result.energy);              // trxAmount × 16,250
console.log(result.delegations[0].tx);  // on-chain tx hash
console.log(result.ref);                 // "nrg_d_42"

import requests
import time

API  = 'https://api.tronnrg.com'
ADDR = 'TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx'

def rent_energy(delegate_to, trx_amount=4):
    # 1. Send TRX to ADDR (via your Tron library)
    tx_hash = send_trx(ADDR, trx_amount)  # your TRX send function

    # 2. Sign: proves you are the sender
    message = f'{tx_hash}:{delegate_to}'
    signature = tron.trx.sign_message_v2(message)

    # 3. Claim delegation (retry if tx not indexed yet)
    for attempt in range(3):
        result = requests.post(f'{API}/delegate', json={
            'tx_hash':     tx_hash,
            'delegate_to': delegate_to,
            'signature':   signature,
        }).json()

        if 'error' not in result:
            return result
        if result['error'] != 'payment_verification_failed':
            raise Exception(result['message'])
        time.sleep(3)

    raise Exception('Transaction not found after retries')

# Usage
result = rent_energy('TWalletThatNeedsEnergy', 4)
print(f"Delegated: {result['energy']} energy")
print(f"Delegation tx: {result['delegations'][0]['tx']}")
print(f"Ref: {result['ref']}")

<?php
$api  = 'https://api.tronnrg.com';
$addr = 'TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx';

function rentEnergy($api, $txHash, $delegateTo, $signature) {
    // 1. Send TRX to $addr (via iexbase/tron-api)
    // $payment = $tron->sendTrx($addr, 4);
    // $txHash = $payment['txid'];

    // 3. Claim delegation (retry if tx not indexed yet)
    for ($i = 0; $i < 3; $i++) {
        $ch = curl_init("${api}/delegate");
        curl_setopt_array($ch, [
            CURLOPT_POST           => true,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
            CURLOPT_POSTFIELDS     => json_encode([
                'tx_hash'     => $txHash,
                'delegate_to' => $delegateTo,
                'signature'   => $signature,
            ]),
        ]);
        $result = json_decode(curl_exec($ch), true);
        curl_close($ch);

        if (!isset($result['error'])) return $result;
        if ($result['error'] !== 'payment_verification_failed')
            throw new Exception($result['message']);
        sleep(3);
    }
    throw new Exception('Transaction not found after retries');
}

// Usage
$result = rentEnergy($api, $txHash, 'TWalletThatNeedsEnergy');
echo "Delegated: " . $result['energy'] . " energy\n";
echo "Delegation tx: " . $result['delegations'][0]['tx'] . "\n";
echo "Ref: " . $result['ref'] . "\n";

# 1. Send TRX to TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx
#    Pricing is linear at 16,250 energy per TRX.
#    Min 4 TRX (65,000 energy), max 1,000 TRX (16.25M energy).
#    (use your wallet or tronweb CLI)

# 2. Sign the message {tx_hash}:{delegate_to} (proves you are the sender)
#    (use tronWeb.trx.signMessageV2 in your code)

# 3. Claim delegation with tx hash + signature
curl -X POST https://api.tronnrg.com/delegate \
  -H "Content-Type: application/json" \
  -d '{
    "tx_hash":     "YOUR_PAYMENT_TX_HASH",
    "delegate_to": "TWalletThatNeedsEnergy",
    "signature":   "YOUR_SIGNATURE"
  }'

# Response includes delegations[].tx — the on-chain hash you can verify on TronScan