Does the TronEnergy API require authentication?

No API key or sign-up required. You authenticate each request by signing a message that proves you are the payment sender. No credentials, no API keys.

How does the delegation flow work?

Send TRX to the payment address. Sign the message {tx_hash}:{delegate_to} to prove you are the sender. Call POST /delegate with tx_hash, delegate_to, and signature. Energy arrives in ~3 seconds.

What happens if delegation fails after payment?

A TRX refund is automatically queued and sent back to the sender address on-chain.

Referencia API | TronEnergy Docs

URL base: https://api.tronnrg.com Autorización: No se requiere nada. Todos los puntos finales 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 a la billetera. La propiedad se demuestra criptográficamente.

Enviar TRX — Envía 4 TRX (o más) a la dirección de pago. 4 TRX = 65.000 de energía. 8 TRX = 130.000. Lineal.
Firmar — Firma el mensaje {tx_hash}:{delegate_to} Utilizando la billetera que envió los TRX . Esto demuestra que usted autorizó la delegación.
Afirmar — POST /delegate con tx_hash, delegate_to, y signatureEnergy llega en aproximadamente 3 segundos.

Dirección de pago

TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx

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

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

TRX enviado	Energy delegada	Caso de uso
4 TRX	65,000	Transferencia estándar USDT 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 solo pedido.
40 TRX	650,000	Diez transferencias estándar
100 TRX	1,625,000	~25 transferencias estándar: algo común en plataformas pequeñas.
1,000 TRX	16,250,000	Pedido máximo: ~250 transferencias estándar
Cualquier cantidad intermedia	`trx × 16,250`	Totalmente lineal. Sin niveles, sin paquetes, sin descuentos.

Fórmula: energy = trxSent × 16,250. Límites: Mínimo 4 TRX (65 000 de energía), máximo 1000 TRX (16 250 000 de energía). Ambos límites se aplican a nivel API : las cantidades inferiores al mínimo se rechazan con `belower_minimum` y se reembolsan; las cantidades superiores al máximo se rechazan antes de la delegación. Lea siempre los valores en tiempo real de `GET /supply` antes de codificarlos en producción (véase más abajo).

GET /supply

GET/supply

Obtén información sobre precios y la dirección de pago. Este es un punto de acceso informativo; la energía siempre está disponible, no necesitas verificarla antes de realizar el pago.

curl https://api.tronnrg.com/supply

const supply = await fetch('https://api.tronnrg.com/supply')
  .then(r => r.json());

// Energy is always available. Use supply.pay_to for the payment address.
console.log('Pay to:', supply.pay_to);

import requests

supply = requests.get('https://api.tronnrg.com/supply').json()

# Energy is always available. Use supply['pay_to'] for the payment address.
print(supply['pay_to'])

$supply = json_decode(
    file_get_contents('https://api.tronnrg.com/supply'),
    true
);

// if less than you require, wait and retry
// Energy is always available. Use $supply['pay_to'] for the payment address.
echo $supply['pay_to'];

var client = new HttpClient();
var json = await client.GetStringAsync("https://api.tronnrg.com/supply");
var supply = JsonSerializer.Deserialize<JsonElement>(json);

// Energy is always available. Use pay_to for the payment address.
var payTo = supply.GetProperty("pay_to").GetString();

Response 200
{
  "available": true,
  "energy_per_trx": 16250,
  "min_order_trx": 4,
  "max_order_trx": 1000,
  "pay_to": "TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx",
  "examples": {
    "standard":   { "trx": 4, "energy": 65000,  "note": "Existing USDT wallet" },
    "new_wallet": { "trx": 8, "energy": 130000, "note": "First-time USDT recipient" }
  }
}

POST /delegate

POST/delegate

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

Parameter	Type		Description
tx_hash	string	required	Hash hexadecimal de 64 caracteres del pago TRX
delegate_to	string	required	Dirección Tron para recibir la energía
signature	string	required	Sign `{tx_hash}:{delegate_to}` using `tronWeb.trx.signMessageV2()`. Proves you are the payment sender.

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");

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

Field	Type	Description
ref	string	ID de referencia TronNRG . Registre esto para consultas de soporte.
energy	number	Energía total delegada
cost	number	TRX cargado
status	string	"delegado" en función del éxito
delegations	array	On-chain delegation transaction hashes. Each `tx` is verifiable on TronScan. This is your receipt.

GET /health

GET/health

Liveness check for monitoring and uptime tools. Returns 200 OK when the API process is up. Does not check upstream nodes or providers.

Response 200

{ "status": "ok" }

Códigos de error

Every error response has error (stable, machine-readable) and message (human-readable). Always switch on error.

Code	HTTP	Meaning
`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ó ninguna firma
`invalid_signature`	401	No se pudo verificar la firma.
`signature_mismatch`	403	La dirección del firmante no coincide con la del remitente del pago.
`hash_already_used`	409	El hash de la transacción ya ha sido reclamado.
`payment_verification_failed`	404 / 400	On-chain verification of the payment failed. Read the `message` field for the specific cause: tx not found yet (404, retry in a few seconds), wrong recipient, not a TRX transfer, or below the 4 TRX minimum.
`delegation_failed`	400 / 500	Provider could not deliver energy. If the failure happened after the payment was verified, an automatic refund is queued. The error response includes a `refund` object when this happens.
`rate_limited`	429	Se están recibiendo demasiadas solicitudes por segundo desde esta IP. El límite es de 20/seg.
`server_error`	500	Error interno inesperado. Inténtalo de nuevo 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;
    }
}

Refunds

Si la delegación falla tras la verificación del pago, se genera automáticamente un reembolso TRX que se envía a la dirección del remitente en la cadena de bloques. Busque el objeto de reembolso en la respuesta de error.

Error with refund
{
  "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: enviar TRX , firmar, reclamar con reintento. Copiar y ejecutar.

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