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.

Référence API | TronEnergy Docs

URL de base : https://api.tronnrg.com Auth. Aucune exigence particulière. Tous les points de terminaison sont publics. Limite de débit : 20 requêtes/seconde par adresse IP Adresse de paiement : TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx ( API uniquement, ne convient pas aux locations manuelles)

Comment ça marche

Trois étapes. Aucune clé API , aucune inscription, aucune connexion à un portefeuille. La propriété est prouvée cryptographiquement.

Envoyer TRX Envoyez 4 TRX (ou plus) à l'adresse de paiement. 4 TRX = 65 000 unités d'énergie. 8 TRX = 130 000 unités. Linéaire.
Signe — Signez le message {tx_hash}:{delegate_to} Utilisez le portefeuille qui a envoyé les TRX . Cela prouve que vous avez autorisé la délégation.
Réclamer — POST /delegate avec tx_hash, delegate_to, et signatureEnergy arrive en ~3 secondes.

Adresse de paiement

TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx

Adresse de paiement API uniquement. Cette adresse est réservée aux intégrations programmatiques via l' API . Ne l'utilisez pas pour les locations d'énergie manuelles. L'adresse pour les locations manuelles est différente et disponible sur .tronnrg.com.

Envoyez TRX à cette adresse. Le hachage de votre transaction est votre jeton pour déclencher la délégation. Chaque hachage ne peut être utilisé qu'une seule fois.

TRX envoyé	Energy déléguée	Cas d'utilisation
4 TRX	65,000	Transfert USDT standard vers un portefeuille existant (commande minimale)
8 TRX	130,000	Transfert USDT à un nouveau bénéficiaire
16 TRX	260,000	Quatre transferts standard dans une seule commande
40 TRX	650,000	Dix transferts standard
100 TRX	1,625,000	~25 transferts standard — courant pour les petites plateformes
1,000 TRX	16,250,000	Commande maximale, environ 250 transferts standard
N'importe quel montant entre	`trx × 16,250`	Entièrement linéaire. Sans paliers, sans forfaits, sans réductions.

Formule: energy = trxSent × 16,250. Bornes: Minimum 4 TRX (65 000 unités d'énergie), maximum 1 000 TRX (16 250 000 unités d'énergie). Ces limites sont appliquées au niveau de API : les montants inférieurs au minimum sont rejetés avec l'erreur « below_minimum » et remboursés ; les montants supérieurs au maximum sont rejetés avant la délégation. Consultez toujours les valeurs en temps réel via la requête GET /supply avant de les intégrer directement en production (voir ci-dessous).

GET /supply

GET/supply

Obtenez les tarifs et l'adresse de paiement. Ce point d'accès est purement informatif ; l'énergie est toujours disponible, vous n'avez pas besoin de vérifier avant d'effectuer le paiement.

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

Réponse 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

Réclamez une délégation d'énergie. Vous devez avoir préalablement envoyé TRX à l'adresse de paiement sur la blockchain. Fournissez le hachage de la transaction, l'adresse du destinataire et une signature prouvant que vous êtes l'expéditeur.

Paramètre	Taper		Description
tx_hash	string	requis	Hachage hexadécimal de 64 caractères du paiement TRX
delegate_to	string	requis	Adresse Tron pour recevoir l'énergie
signature	string	requis	tronWeb.trx.signMessageV2() de `tronWeb.trx.signMessageV2()`Cela prouve que vous êtes l'expéditeur du paiement.

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

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

Champ	Taper	Description
ref	string	Identifiant de référence TronNRG . Veuillez le consigner pour toute demande d'assistance.
energy	number	Énergie totale déléguée
cost	number	TRX chargé
status	string	« délégué » sur le succès
delegations	array	Hachages des transactions de délégation sur la chaîne. Chaque `tx` est vérifiable sur TronScanVoici votre reçu.

GET /health

GET/health

Vérification de la disponibilité des outils de surveillance et de garantie de disponibilité. Retours 200 OK Lorsque le processus API est opérationnel. Ne vérifie pas les nœuds ou fournisseurs en amont.

Réponse 200

{ "status": "ok" }

Codes d'erreur

Chaque réponse d'erreur a error (stable, lisible par machine) et message (lisible par l'homme). Toujours allumer error dans votre code.

Code	HTTP	Signification
`invalid_tx_hash`	400	Il ne s'agit pas d'une chaîne hexadécimale de 64 caractères.
`invalid_address`	400	Adresse Tron invalide
`missing_signature`	400	Aucune signature fournie
`invalid_signature`	401	La signature n'a pas pu être vérifiée.
`signature_mismatch`	403	L'adresse du signataire ne correspond pas à celle de l'expéditeur du paiement.
`hash_already_used`	409	Le hachage de la transaction a déjà été utilisé.
`payment_verification_failed`	404 / 400	La vérification du paiement sur la blockchain a échoué. Veuillez lire la suite. `message` champ pour la cause spécifique : tx introuvable (404, réessayer dans quelques secondes), destinataire incorrect, pas un transfert TRX ou inférieur au minimum de 4 TRX .
`delegation_failed`	400 / 500	Le fournisseur n'a pas pu fournir d'énergie. Si l'incident s'est produit après la vérification du paiement, un remboursement est automatiquement mis en attente. Consultez le site web du fournisseur. `refund` objet lorsque cela se produit.
`rate_limited`	429	Trop de requêtes par seconde provenant de cette adresse IP. La limite est de 20/sec.
`server_error`	500	Erreur interne inattendue. Veuillez réessayer dans quelques secondes.

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

Remboursements

Si la délégation échoue après la vérification de votre paiement, un remboursement TRX est automatiquement mis en file d'attente et renvoyé à l'adresse de l'expéditeur sur la blockchain. Vous trouverez l'objet de remboursement dans la réponse d'erreur.

Erreur lors du remboursement
{
  "error": "delegation_failed",
  "message": "Energy delegation failed. Your payment will be refunded.",
  "ref": "nrg_d_43",
  "refund": {
    "type": "queued",
    "to": "TSenderAddress",
    "amount": 4
  }
}

Exemple complet

Flux complet de bout en bout : envoi TRX , signature, réclamation avec nouvelle tentative. Copier et exécuter.

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

Comment ça marche

Adresse de paiement

GET /supply

POST /delegate

GET /health

Codes d&#39;erreur

Remboursements

Exemple complet

Codes d'erreur