A API TronEnergy requer autenticação?

Nenhuma chave de API ou cadastro necessário. Você autentica cada requisição assinando uma mensagem que prova que você é o remetente do pagamento. Sem credenciais, sem chaves de API.

Como funciona o fluxo de delegação?

Envie TRX para o endereço de pagamento. Assine a mensagem {tx_hash}:{delegate_to} para provar que você é o remetente. Chame POST /delegate com tx_hash, delegate_to e signature. A energia chega em ~3 segundos.

Referência da API de Aluguel de Tron Energy: Endpoints REST e Integração

Q: O que acontece se a delegação falhar após o pagamento?

Um reembolso em TRX é automaticamente colocado na fila e devolvido para o endereço do remetente na blockchain.

URL Base: https://api.tronnrg.com Autenticação: Nenhuma necessária. Todos os endpoints são públicos. Limite de taxa: 20 requisições/segundo por IP Endereço de pagamento: TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx (Apenas API, não para aluguéis manuais)

Como Funciona

Três passos. Sem chave de API, sem cadastro, sem conexão de carteira. A propriedade é comprovada criptograficamente.

Envie TRX — Envie 4 TRX (ou mais) para o endereço de pagamento. 4 TRX = 65.000 energia. 8 TRX = 130.000. Linear.
Assine — Assine a mensagem {tx_hash}:{delegate_to} usando a carteira que enviou o TRX. Isso prova que você autorizou a delegação.
Reivindique — POST /delegate com tx_hash, delegate_to, e signature. A energia chega em ~3 segundos.

Endereço de Pagamento

TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx

Endereço de pagamento da API apenas. Este endereço é para integrações programáticas via API. Não use para aluguel manual de energia. O endereço para aluguel manual é diferente e está disponível em .tronnrg.com.

Envie TRX para este endereço. O hash da transação do seu pagamento é seu token para disparar a delegação. Cada hash pode ser usado apenas uma vez.

TRX Enviado	Energia Delegada	Caso de Uso
4 TRX	65,000	Transferência padrão de USDT para carteira existente (pedido mínimo)
8 TRX	130,000	Transferência de USDT para destinatário pela primeira vez
16 TRX	260,000	Quatro transferências padrão em um pedido
40 TRX	650,000	Dez transferências padrão
100 TRX	1,625,000	~25 transferências padrão — comum para pequenas plataformas
1,000 TRX	16,250,000	Pedido máximo, ~250 transferências padrão
Qualquer valor entre esses	`trx × 16,250`	Totalmente linear. Sem faixas, sem pacotes, sem descontos.

Fórmula: energy = trxSent × 16,250. Limites: mínimo 4 TRX (65.000 energia), máximo 1.000 TRX (16.250.000 energia). Ambos são aplicados no nível da API — valores abaixo do mínimo são rejeitados com below_minimum e reembolsados; valores acima do máximo são rejeitados antes da delegação.

POST /delegate

POST/delegate

Solicite uma delegação de energia. Você já deve ter enviado TRX para o endereço de pagamento on-chain. Passe o hash da transação, o endereço do destinatário e uma assinatura provando que você é o remetente.

Parâmetro	Tipo		Descrição
tx_hash	string	obrigatório	Hash hexadecimal de 64 caracteres do pagamento em TRX
delegate_to	string	obrigatório	Endereço Tron para receber a energia
signature	string	obrigatório	tronWeb.trx.signMessageV2() de `tronWeb.trx.signMessageV2()`. Prova que você é o remetente do pagamento.

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

Resposta 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	Descrição
ref	string	ID de referência TronNRG. Registre isso para consultas de suporte.
energy	number	Energia total delegada
cost	number	TRX cobrado
status	string	"delegated" em caso de sucesso
delegations	array	Hashes de transações de delegação on-chain. Cada `tx` é verificável em TronScan. Este é seu comprovante.

GET /health

GET/health

Verificação de disponibilidade para ferramentas de monitoramento e uptime. Retorna 200 OK quando o processo da API está ativo. Não verifica nós ou provedores upstream.

Resposta 200

{ "status": "ok" }

Códigos de Erro

Toda resposta de erro tem error (estável, legível por máquina) e message (legível por humanos). Sempre alterne em error no seu código.

Código	HTTP	Significado
`invalid_tx_hash`	400	Não é uma string hexadecimal de 64 caracteres
`invalid_address`	400	Não é um endereço Tron válido
`missing_signature`	400	Nenhuma assinatura fornecida
`invalid_signature`	401	A assinatura não pôde ser verificada
`signature_mismatch`	403	O endereço do signatário não corresponde ao remetente do pagamento
`hash_already_used`	409	Hash da transação já foi reivindicado
`payment_verification_failed`	404 / 400	A verificação on-chain do pagamento falhou. Leia o campo `message` para a causa específica: transação ainda não encontrada (404, tente novamente em alguns segundos), destinatário incorreto, não é uma transferência TRX, ou abaixo do mínimo de 4 TRX.
`delegation_failed`	400 / 500	O provedor não conseguiu entregar energia. Se a falha ocorreu após a verificação do pagamento, um reembolso é enfileirado automaticamente. Verifique o objeto `refund` quando isso acontecer.
`rate_limited`	429	Muitas requisições por segundo deste IP. O limite é 20/seg.
`server_error`	500	Erro interno inesperado. Tente novamente em alguns 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

Se a delegação falhar após seu pagamento ser verificado, um reembolso em TRX é automaticamente colocado na fila e devolvido para o endereço do remetente na blockchain. Procure pelo objeto de reembolso na resposta de erro.

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

Exemplo Completo

Fluxo completo de ponta a ponta: enviar TRX, assinar, reclamar com retry. Copie e execute.

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