L'API TronEnergy nécessite-t-elle une authentification ?

Aucune clé API ni inscription requise. Vous authentifiez chaque requête en signant un message qui prouve que vous êtes l'expéditeur du paiement. Pas de credentials, pas de clés API.

Comment fonctionne le flux de délégation ?

Envoyez TRX à l'adresse de paiement. Signez le message {tx_hash}:{delegate_to} pour prouver que vous êtes l'expéditeur. Appelez POST /delegate avec tx_hash, delegate_to et signature. L'énergie arrive en ~3 secondes.

Référence API de Location d'Energy Tron : Endpoints REST et Intégration

Q: Que se passe-t-il si la délégation échoue après le paiement ?

Un remboursement en TRX est automatiquement mis en file d'attente et renvoyé à l'adresse d'envoi on-chain.

URL de base : https://api.tronnrg.com Authentification : Aucune requise. Tous les endpoints sont publics. Limite de débit : 20 requêtes/seconde par IP Adresse de paiement : TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx (API uniquement, pas pour les locations manuelles)

Comment ça marche

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

Envoyez TRX — Envoyez 4 TRX (ou plus) à l'adresse de paiement. 4 TRX = 65 000 énergie. 8 TRX = 130 000. Linéaire.
Signez — Signez le message {tx_hash}:{delegate_to} avec le portefeuille qui a envoyé les TRX. Cela prouve que vous avez autorisé la délégation.
Réclamez — POST /delegate avec tx_hash, delegate_to, et signature. L'énergie 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 de location manuelle est différente et disponible sur .tronnrg.com.

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

TRX Envoyés	Énergie Déléguée	Cas d'Usage
4 TRX	65,000	Transfert USDT standard vers un portefeuille existant (commande minimale)
8 TRX	130,000	Transfert USDT vers un destinataire pour la première fois
16 TRX	260,000	Quatre transferts standards en une seule commande
40 TRX	650,000	Dix transferts standards
100 TRX	1,625,000	~25 transferts standards — courant pour les petites plateformes
1,000 TRX	16,250,000	Commande maximale, ~250 transferts standards
N'importe quel montant entre les deux	`trx × 16,250`	Entièrement linéaire. Pas de paliers, pas de forfaits, pas de remises.

Formule : energy = trxSent × 16,250. Limites : min 4 TRX (65 000 énergie), max 1 000 TRX (16 250 000 énergie). Les deux sont appliquées au niveau de l'API — les montants en dessous du minimum sont rejetés avec below_minimum et remboursés ; les montants au-dessus du maximum sont rejetés avant la délégation.

POST /delegate

POST/delegate

Réclamez une délégation d'énergie. Vous devez avoir déjà envoyé des TRX à l'adresse de paiement on-chain. Transmettez le hash de la transaction, l'adresse du destinataire et une signature prouvant que vous êtes l'expéditeur.

Paramètre	Type		Description
tx_hash	string	obligatoire	Hash hexadécimal 64 caractères du paiement en TRX
delegate_to	string	obligatoire	Adresse Tron pour recevoir l'énergie
signature	string	obligatoire	tronWeb.trx.signMessageV2() de `tronWeb.trx.signMessageV2()`. 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	Type	Description
ref	string	Identifiant de référence TronNRG. Conservez-le pour les demandes d'assistance.
energy	number	Énergie totale déléguée
cost	number	TRX facturés
status	string	« delegated » en cas de succès
delegations	array	Hashes de transactions de délégation on-chain. Chaque `tx` est vérifiable sur TronScan. Ceci est votre reçu.

GET /health

GET/health

Vérification de disponibilité pour les outils de monitoring et de supervision. Retourne 200 OK lorsque le processus API est opérationnel. Ne vérifie pas les nœuds ou fournisseurs amont.

Réponse 200

{ "status": "ok" }

Codes d'erreur

Chaque réponse d'erreur contient error (stable, lisible par machine) et message (lisible par l'homme). Basculez toujours sur error dans votre code.

Code	HTTP	Signification
`invalid_tx_hash`	400	Pas une chaîne hexadécimale de 64 caractères
`invalid_address`	400	Pas une adresse Tron valide
`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 à l'expéditeur du paiement
`hash_already_used`	409	Le hash de transaction a déjà été réclamé
`payment_verification_failed`	404 / 400	La vérification on-chain du paiement a échoué. Consultez le champ `message` pour connaître la cause spécifique : transaction non trouvée (404, réessayez dans quelques secondes), mauvais destinataire, non un transfert TRX, ou inférieur au minimum de 4 TRX.
`delegation_failed`	400 / 500	Le fournisseur n'a pas pu livrer l'énergie. Si l'échec s'est produit après vérification du paiement, un remboursement est automatiquement mis en file d'attente. Consultez l'objet `refund` lorsque cela se produit.
`rate_limited`	429	Trop de requêtes par seconde depuis cette IP. Limite : 20/sec.
`server_error`	500	Erreur interne inattendue. Réessayez 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 d'énergie échoue après vérification de votre paiement, un remboursement en TRX est automatiquement mis en file d'attente et renvoyé à l'adresse d'envoi on-chain. Consultez l'objet remboursement dans la réponse d'erreur.

Erreur avec 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 : envoyez TRX, signez, réclamez avec nouvelle tentative. Copiez et exécutez.

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