TronEnergy API kimlik doğrulaması gerektirir mi?

API anahtarı veya kaydolma gerekli değildir. Her isteği, gönderen olduğunuzu kanıtlayan bir mesajı imzalayarak kimlik doğrulaması yaparsınız. Kimlik bilgisi yok, API anahtarı yok.

Delegasyon akışı nasıl çalışır?

Ödeme adresine TRX gönderin. Gönderen olduğunuzu kanıtlamak için {tx_hash}:{delegate_to} mesajını imzalayın. POST /delegate'i tx_hash, delegate_to ve signature ile çağırın. Enerji ~3 saniyede ulaşır.

Ödeme sonrası delegasyon başarısız olursa ne olur?

TRX iadesi otomatik olarak sıraya alınır ve gönderen adresine blok zincirde geri gönderilir.

Tron Enerji Kiralama API Referansı: REST Uç Noktaları & Entegrasyon

Temel URL: https://api.tronnrg.com Kimlik doğrulama: Gerekli değil. Tüm uç noktalar açıktır. Oran limiti: IP başına saniyede 20 istek Ödeme adresi: TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx (Yalnızca API, manuel kiralamaları için değil)

Nasıl Çalışır?

Üç adım. API anahtarı yok, kaydolmaya gerek yok, cüzdan bağlantısı yok. Sahiplik kriptografik olarak kanıtlanır.

TRX Gönder — Ödeme adresine 4 TRX (veya daha fazla) gönderin. 4 TRX = 65.000 enerji. 8 TRX = 130.000. Doğrusal.
İmzala — Mesajı {tx_hash}:{delegate_to} TRX gönderen cüzdan kullanarak imzalayın. Bu, enerji delegasyonunu yetkilendirdiğinizi kanıtlar.
Talep Et — POST /delegate ile tx_hash, delegate_to ve signature. Enerji ~3 saniyede ulaşır.

Ödeme Adresi

TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx

Yalnızca API ödeme adresi. Bu adres API aracılığıyla programlı entegrasyonlar içindir. Manuel enerji kiralama için bu adresi kullanmayın. Manuel kiralama adresi farklıdır ve adresinde mevcuttur.tronnrg.com.

Bu adrese TRX gönderin. Ödemenizin işlem hash değeri, enerji delegasyonunu tetiklemek için kullanılan jetonunuzdur. Her hash yalnızca bir kez kullanılabilir.

Gönderilen TRX	Delegasyona Tabi Enerji	Kullanım Durumu
4 TRX	65,000	Mevcut bir cüzdana standart USDT transferi (minimum sipariş)
8 TRX	130,000	İlk kez alan kişiye USDT transferi
16 TRX	260,000	Tek siparişte dört standart transfer
40 TRX	650,000	On standart transfer
100 TRX	1,625,000	~25 standart transfer — küçük platformlar için yaygın
1,000 TRX	16,250,000	Maksimum sipariş, ~250 standart transfer
Arasında herhangi bir miktar	`trx × 16,250`	Tamamen doğrusal. Katman yok, paket yok, indirim yok.

Formül: energy = trxSent × 16,250. Sınırlar: minimum 4 TRX (65.000 enerji), maksimum 1.000 TRX (16.250.000 enerji). Her ikisi de API seviyesinde uygulanır — minimumdan düşük miktarlar below_minimum ile reddedilir ve geri ödenir; maksimumdan fazla miktarlar delegasyon öncesinde reddedilir.

POST /delegate

POST/delegate

Bir enerji delegasyonu talep edin. Zaten ödeme adresine zincir üzerinde TRX göndermiş olmanız gerekir. İşlem hash'ini, alıcı adresini ve gönderici olduğunuzu kanıtlayan bir imzayı geçin.

Parametre	Tür		Açıklama
tx_hash	string	gerekli	TRX ödemesinin 64 karakterlik hex hash'i
delegate_to	string	gerekli	Enerji alacak Tron adresi
signature	string	gerekli	tronWeb.trx.signMessageV2() of `tronWeb.trx.signMessageV2()`. Ödeme göndericisi olduğunuzu kanıtlar.

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

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

Alan	Tür	Açıklama
ref	string	TronNRG referans kimliği. Destek sorgulamaları için bunu kaydedin.
energy	number	Toplam delege edilen enerji
cost	number	Alınan TRX
status	string	Başarıda "delegated"
delegations	array	Zincir üzerinde delegasyon işlem hash'leri. Her `tx` doğrulanabilir TronScan üzerinde. Bu sizin makbuzunuzdur.

GET /health

GET/health

İzleme ve çalışma süresi araçları için canlılık kontrolü. 200 OK döndürür API süreci çalışırken. Yukarı akış düğümlerini veya sağlayıcılarını kontrol etmez.

Yanıt 200

{ "status": "ok" }

Hata Kodları

Her hata yanıtının error (kararlı, makine tarafından okunabilir) ve message (insan tarafından okunabilir) vardır. Kodunuzda her zaman error kontrol edin.

Kod	HTTP	Anlamı
`invalid_tx_hash`	400	64 karakterlik hex dizesi değil
`invalid_address`	400	Geçerli bir Tron adresi değil
`missing_signature`	400	İmza sağlanmadı
`invalid_signature`	401	İmza doğrulanamadı
`signature_mismatch`	403	İmza atıcı adresi ödeme göndericisi ile eşleşmiyor
`hash_already_used`	409	İşlem hash'i zaten talep edildi
`payment_verification_failed`	404 / 400	Ödemenin zincir üzerinde doğrulanması başarısız oldu. Spesifik nedeni öğrenmek için `message` alanını okuyun: işlem henüz bulunamadı (404, birkaç saniye içinde yeniden deneyin), yanlış alıcı, TRX transferi değil veya 4 TRX minimum altında.
`delegation_failed`	400 / 500	Sağlayıcı enerji teslim edemedi. Ödeme doğrulandıktan sonra hata oluştuysa, geri ödeme otomatik olarak sıraya alınır. Bu durumda `refund` nesnesini kontrol edin.
`rate_limited`	429	Bu IP'den saniyede çok fazla istek gönderildi. Sınır 20/sn.
`server_error`	500	Beklenmeyen iç hata. Birkaç saniye içinde yeniden deneyin.

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

İadeler

Ödemeniz doğrulandıktan sonra delegasyon başarısız olursa, TRX iadesi otomatik olarak sıraya alınır ve gönderen adrese blok zincirde geri gönderilir. Hata yanıtında iade nesnesini arayın.

İade ile hata
{
  "error": "delegation_failed",
  "message": "Energy delegation failed. Your payment will be refunded.",
  "ref": "nrg_d_43",
  "refund": {
    "type": "queued",
    "to": "TSenderAddress",
    "amount": 4
  }
}

Tam Örnek

Tam uçtan uca akış: TRX gönderin, imzalayın, yeniden deneme ile talep edin. Kopyalayın ve çalıştırın.

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