მოითხოვს თუ არა TronEnergy API-ს ავთენტიფიკაციას?

API გასაღები ან რეგისტრაცია არ სჭირდება. თითოეული მოთხოვნა დადასტურდება ხელმოწერილი შეტყობინებით, რომელიც ადასტურებს, რომ თქვენ ხართ გადახდის მომწოდებელი. არ არის კრედენციალი, არ არის API გასაღები.

როგორ მუშაობს დელეგირების ნაკადი?

გაგზავნეთ TRX გადახდის მისამართზე. ხელმოწერეთ შეტყობინება {tx_hash}:{delegate_to}, რომ დაამტკიცოთ, რომ თქვენ ხართ მომწოდებელი. დარეკეთ POST /delegate tx_hash, delegate_to და ხელმოწერით. ენერგია ჩამოდის დაახლოებით 3 წამში.

Tron ენერგიის ქირაობის API მიმოხილვა: REST ენდპოინტები და ინტეგრაცია

ძირითადი URL: https://api.tronnrg.com ავტენტიფიკაცია: აუცილებელი არ არის. ყველა ენდპოინტი საჯაროა. ზღვარი: 20 მოთხოვნა/წამი IP-ზე გადახდის მისამართი: TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx (მხოლოდ API, არა ხელით ქირაობისთვის)

როგორ მუშაობს

სამი ნაბიჯი. API გასაღები არ სჭირდება, რეგისტრაცია არ სჭირდება, საფულის კავშირი არ სჭირდება. მფლობელობა დამტკიცებულია კრიპტოგრაფიულად.

TRX გაგზავნა — გადაიტანეთ 4 TRX (ან მეტი) გადახდის მისამართზე. 4 TRX = 65,000 ენერგია. 8 TRX = 130,000. წრფივი.
ხელმოწერა — ხელმოწერეთ შეტყობინება {tx_hash}:{delegate_to} იმ საფულეთი, რომელმაც TRX გაგზავნა. ეს ადასტურებს, რომ თქვენ ავტორიზაცია მისცეთ დელეგაციას.
მოხმარება — POST /delegate -ით tx_hash, delegate_to, და signature. ენერგია ~3 წამში ჩამოდის.

გადახდის მისამართი

TFqUiCu1JwLHHnBNeaaVKH7Csm4aA3YhZx

მხოლოდ API გადახდის მისამართი. ეს მისამართი არის პროგრამული ინტეგრაციისთვის API-ის მეშვეობით. არ გამოიყენოთ ხელით ენერგიის ქირაობისთვის. ხელით ქირაობის მისამართი განსხვავებულია და ხელმისაწვდომი -ზე.tronnrg.com.

გადაიტანეთ TRX ამ მისამართზე. თქვენი გადახდის ტრანзაქციის ჰეში არის თქვენი დელეგაციის გამოწვევის ტოკენი. თითოეული ჰეში მხოლოდ ერთხელ გამოიყენება.

გაგზავნილი TRX	დელეგირებული ენერგია	გამოყენების შემთხვევა
4 TRX	65,000	სტანდარტული USDT გადარიცხვა არსებულ საფულეზე (მინიმალური შეკვეთა)
8 TRX	130,000	USDT გადარიცხვა პირველი ბენეფიციარის რეციპიენტისთვის
16 TRX	260,000	ოთხი სტანდარტული გადარიცხვა ერთ შეკვეთაში
40 TRX	650,000	ათი სტანდარტული გადარიცხვა
100 TRX	1,625,000	~25 სტანდარტული გადარიცხვა — ხშირი პატარა პლატფორმებისთვის
1,000 TRX	16,250,000	მაქსიმალური შეკვეთა, ~250 სტანდარტული გადარიცხვა
ნებისმიერი რაოდენობა მათ შორის	`trx × 16,250`	სრულიად წრფივი. არცერთი ტიერი, პაკეტი ან ფასდიკლასი.

ფორმულა: energy = trxSent × 16,250. საზღვრები: მინ 4 TRX (65,000 ენერგია), მაქს 1,000 TRX (16,250,000 ენერგია). ორივე გამოიყენება API დონეზე — მინიმუმზე ქვემოთ რაოდენობები უარყოფილია below_minimum-თი და დაბრუნებული; მაქსიმუმზე მეტი რაოდენობები უარყოფილია დელეგაციამდე.

POST /delegate

POST/delegate

ენერგიის დელეგირება მოითხოვეთ. უკვე უნდა გამოგიგზავნეთ TRX გადახდის მისამართზე ჯაჭვში. გადააბარეთ ტრანზაქციის ჰეში, მიმღების მისამართი და ხელმოწერა, რომელიც ადასტურებს, რომ თქვენ ხართ გამგზავნი.

პარამეტრი	ტიპი		აღწერა
tx_hash	string	აუცილებელი	TRX გადახდის 64-სიმბოლოიანი hex ჰეში
delegate_to	string	აუცილებელი	Tron მისამართი ენერგიის მისაღებად
signature	string	აუცილებელი	tronWeb.trx.signMessageV2() დან `tronWeb.trx.signMessageV2()`. ადასტურებს, რომ თქვენ ხართ გადახდის გამგზავნი.

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

პასუხი 200
{
  "ref": "nrg_d_42",
  "delegate_to": "TWalletAddress",
  "energy": 65000,
  "cost": 4,
  "status": "delegated",
  "delegations": [
    { "tx": "a1b2c3d4e5f6...your delegation tx hash", "energy": 65000 }
  ]
}

ველი	ტიპი	აღწერა
ref	string	TronNRG რეფერენციის ID. ჩაწერეთ ეს ტექნიკური დახმარების მოთხოვნებისთვის.
energy	number	სულ დელეგირებული ენერგია
cost	number	დაკომისიოთი TRX
status	string	"delegated" წარმატების შემთხვევაში
delegations	array	ჯაჭვში დელეგირების ტრანზაქციის ჰეშები. თითოეული `tx` გადამოწმებადია TronScan-ზე. ეს თქვენი ქვითელი ა.

GET /health

GET/health

სიცოცხლის შემოწმება მონიტორინგისა და დრო დაკავშირებული ხელსაწყოებისთვის. დაბრუნდება 200 OK როდესაც API პროცესი მუშაობს. არ ამოწმებს ზევით მდებარე კვანძებს ან პროვაიდერებს.

პასუხი 200

{ "status": "ok" }

შეცდომის კოდები

ყველა შეცდომის პასუხს აქვს error (სტაბილური, მანქანის-წაკითხვადი) და message (ადამიანის-წაკითხვადი). ყოველთვის გადაერთეთ error თქვენს კოდში.

კოდი	HTTP	მნიშვნელობა
`invalid_tx_hash`	400	არ არის 64-სიმბოლოიანი hex სტრიქონი
`invalid_address`	400	არ არის ვალიდური Tron მისამართი
`missing_signature`	400	ხელმოწერა არ არის მოწოდებული
`invalid_signature`	401	ხელმოწერა ვერ დადასტურდა
`signature_mismatch`	403	ხელმომწერის მისამართი არ ემთხვევა გადახდის გამგზავნს
`hash_already_used`	409	ტრანზაქციის ჰეში უკვე მოითხოვა
`payment_verification_failed`	404 / 400	გადახდის ჯაჭვში დადასტურება ვერ მოხერხდა. წაიკითხეთ `message` ველი კონკრეტული მიზეზისთვის: tx ჯერ არ იპოვა (404, ხელახლა სცადეთ რამდენიმე წამში), არასწორი მიმღები, არ არის TRX გადარიცხვა, ან 4 TRX მინიმუმის ქვეშ.
`delegation_failed`	400 / 500	პროვაიდერმა ვერ მოიტანა ენერგია. თუ წარუმატებელი ჩემი ხდება გადახდის დადასტურების შემდეგ, თავდასხმა ავტომატურად რიგში დგება. შეამოწმეთ `refund` ობიექტი როდესაც ეს ხდება.
`rate_limited`	429	ამ IP-დან ძალიან ბევრი მოთხოვნა წამში. ლიმიტი 20/წმ.
`server_error`	500	მოულოდნელი შიდა შეცდომა. ცადეთ რამდენიმე წამში.

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

დაბრუნებები

თუ დელეგირება ვერ ხერხდება თქვენი გადახდის დადასტურების შემდეგ, TRX დაბრუნება ავტომატურად რიგში დგება და ღირებულების მომწოდებელ მისამართზე იგზავნება. მოიძიეთ დაბრუნების ობიექტი ცდომილების პასუხში.

შეცდომა დაბრუნებით
{
  "error": "delegation_failed",
  "message": "Energy delegation failed. Your payment will be refunded.",
  "ref": "nrg_d_43",
  "refund": {
    "type": "queued",
    "to": "TSenderAddress",
    "amount": 4
  }
}

სრული მაგალითი

სრული ბოლოდან ბოლომდე ნაკადი: TRX-ის გაგზავნა, ხელმოწერა, მოთხოვნა ხელახლა ცდით. დააკოპირეთ და გაუშვით.

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