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.

Referensi API | TronEnergy Docs

URL dasar: https://api.tronnrg.com Otorisasi: Tidak diperlukan. Semua endpoint bersifat publik. Batasan laju: 20 permintaan/detik per IP Alamat pembayaran: TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx (Hanya API , tidak untuk penyewaan manual)

Cara Kerjanya

Tiga langkah. Tanpa kunci API , tanpa pendaftaran, tanpa koneksi dompet. Kepemilikan dibuktikan secara kriptografis.

Kirim TRX — Kirim 4 TRX (atau lebih) ke alamat pembayaran. 4 TRX = 65.000 energi. 8 TRX = 130.000. Linier.
Tanda — Tandatangani pesan {tx_hash}:{delegate_to} menggunakan dompet yang mengirimkan TRX . Ini membuktikan bahwa Anda telah mengotorisasi delegasi tersebut.
Mengeklaim — POST /delegate dengan tx_hash, delegate_to, Dan signatureEnergy tiba dalam waktu sekitar 3 detik.

Alamat Pembayaran

TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx

Hanya alamat pembayaran API . Alamat ini digunakan untuk integrasi terprogram melalui API . Jangan gunakan alamat ini untuk penyewaan energi manual. Alamat penyewaan manual berbeda dan tersedia di .tronnrg.com.

Kirim TRX ke alamat ini. Hash transaksi pembayaran Anda adalah token Anda untuk memicu delegasi. Setiap hash hanya dapat digunakan sekali.

TRX Terkirim	Energy yang Didelegasikan	Kasus Penggunaan
4 TRX	65,000	Transfer USDT standar ke dompet yang sudah ada (pesanan minimum)
8 TRX	130,000	Transfer USDT ke penerima pertama kali
16 TRX	260,000	Empat transfer standar dalam satu pesanan
40 TRX	650,000	Sepuluh transfer standar
100 TRX	1,625,000	~25 transfer standar — umum untuk platform kecil
1,000 TRX	16,250,000	Jumlah pesanan maksimum, ~250 transfer standar
Jumlah berapa pun di antara	`trx × 16,250`	Sepenuhnya linear. Tanpa tingkatan, tanpa paket, tanpa diskon.

Rumus: energy = trxSent × 16,250. Batas: Minimal 4 TRX (65.000 energi), maksimal 1.000 TRX (16.250.000 energi). Keduanya diberlakukan di tingkat API — jumlah di bawah minimum ditolak dengan below_minimum dan dikembalikan; jumlah di atas maksimum ditolak sebelum delegasi. Selalu baca nilai langsung dari GET /supply sebelum mengkodekannya secara langsung di produksi — lihat di bawah.

GET /supply

GET/supply

Dapatkan informasi harga dan alamat pembayaran. Ini adalah titik akhir informasi — energi selalu tersedia, Anda tidak perlu memeriksa sebelum mengirim pembayaran.

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

Respons 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

Klaim delegasi energi. Anda harus sudah mengirim TRX ke alamat pembayaran di blockchain. Berikan hash transaksi, alamat penerima, dan tanda tangan yang membuktikan bahwa Anda adalah pengirimnya.

Parameter	Jenis		Keterangan
tx_hash	string	diperlukan	Hash heksadesimal 64 karakter dari pembayaran TRX
delegate_to	string	diperlukan	Alamat Tron untuk menerima energi
signature	string	diperlukan	tronWeb.trx.signMessageV2() dari `tronWeb.trx.signMessageV2()`. Membuktikan bahwa Anda adalah pengirim pembayaran.

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

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

Bidang	Jenis	Keterangan
ref	string	ID referensi TronNRG . Catat ini untuk pertanyaan dukungan.
energy	number	Total energi yang didelegasikan
cost	number	TRX terisi daya
status	string	"didelegasikan" pada keberhasilan
delegations	array	Hash transaksi delegasi on-chain. Setiap `tx` dapat diverifikasi pada TronScanIni adalah tanda terima Anda.

GET /health

GET/health

Pemeriksaan keaktifan untuk alat pemantauan dan waktu aktif. Pengembalian 200 OK Saat proses API aktif. Tidak memeriksa node atau penyedia hulu.

Respons 200

{ "status": "ok" }

Kode Kesalahan

Setiap respons kesalahan memiliki error (stabil, dapat dibaca mesin) dan message (dapat dibaca manusia). Selalu nyalakan error dalam kode Anda.

Kode	HTTP	Arti
`invalid_tx_hash`	400	Bukan string heksadesimal 64 karakter
`invalid_address`	400	Bukan alamat Tron yang valid
`missing_signature`	400	Tidak ada tanda tangan yang diberikan
`invalid_signature`	401	Tanda tangan tidak dapat diverifikasi.
`signature_mismatch`	403	Alamat penandatangan tidak sesuai dengan alamat pengirim pembayaran.
`hash_already_used`	409	Hash transaksi sudah diklaim.
`payment_verification_failed`	404 / 400	Verifikasi pembayaran on-chain gagal. Baca selengkapnya `message` Kolom untuk penyebab spesifik: transaksi belum ditemukan (404, coba lagi dalam beberapa detik), penerima salah, bukan transfer TRX , atau di bawah minimum 4 TRX .
`delegation_failed`	400 / 500	Penyedia tidak dapat mengirimkan energi. Jika kegagalan terjadi setelah pembayaran diverifikasi, pengembalian dana akan secara otomatis diproses. Periksa `refund` objek ketika ini terjadi.
`rate_limited`	429	Terlalu banyak permintaan per detik dari IP ini. Batasnya adalah 20 permintaan per detik.
`server_error`	500	Terjadi kesalahan internal yang tidak terduga. Coba lagi dalam beberapa detik.

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;
    }
}

Pengembalian dana

Jika delegasi gagal setelah pembayaran Anda diverifikasi, pengembalian dana TRX akan secara otomatis dimasukkan ke dalam antrian dan dikirim kembali ke alamat pengirim di blockchain. Cari objek pengembalian dana dalam respons kesalahan.

Terjadi kesalahan saat pengembalian dana.
{
  "error": "delegation_failed",
  "message": "Energy delegation failed. Your payment will be refunded.",
  "ref": "nrg_d_43",
  "refund": {
    "type": "queued",
    "to": "TSenderAddress",
    "amount": 4
  }
}

Contoh Lengkap

Alur lengkap dari awal hingga akhir: kirim TRX , tanda tangani, klaim dengan percobaan ulang. Salin dan jalankan.

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