API से TRON बैंडविड्थ कैसे खरीदें — बैंडविड्थ किराया (2026)

Alex Goldsmith
लेखक और शोधकर्ता
12 लेख
इसे Claude Code या Cursor में पेस्ट करें — एनर्जी और बैंडविड्थ खरीदें

Connect TronRental via its REST API and buy TRON resources — energy and/or bandwidth — for me.

इस प्रॉम्प्ट को कॉपी करें और Claude Code, Cursor या किसी भी AI टूल में पेस्ट करें। AI खुद अकाउंट रजिस्टर करता है, API की बनाता है, डिपॉज़िट पता दिखाता है, और REST API से एनर्जी या बैंडविड्थ खरीदता है — बिना मैन्युअल सेटअप।

स्थायी सेटअप: MCP सर्वर

1. कमांड कॉपी करें:

2. इसे अपने टर्मिनल में चलाएँ — Claude Code सर्वर को पहचान लेगा। (Cursor / Windsurf: npx -y @tronrental-com/mcp-server को mcp.json में जोड़ें।)

कनेक्ट होने पर असिस्टेंट को TronRental तक सीधी पहुँच मिलती है: यह अकाउंट रजिस्टर करता है, API की बनाता है, डिपॉज़िट पता दिखाता है, और एनर्जी या बैंडविड्थ खरीदता है — सब सादे टेक्स्ट से: «पते T... के लिए 350 बैंडविड्थ खरीदो»।

MCP के बारे में और जानें →

नीचे — उनके लिए जो विवरण समझना और एकीकरण मैन्युअल रूप से बनाना चाहते हैं।

बैंडविड्थ क्यों किराए पर लें?

हर TRON ट्रांज़ैक्शन बैंडविड्थ खर्च करता है। हर सक्रिय पते को रोज़ 600 मुफ़्त बैंडविड्थ मिलती है — लेकिन यह जल्दी खत्म हो जाती है:

  • रोज़ 600 मुफ़्त बैंडविड्थ = लगभग 1 USDT (TRC-20) ट्रांसफ़र — फिर खत्म
  • मुफ़्त बैंडविड्थ खत्म → नेटवर्क उसकी जगह प्रति ट्रांज़ैक्शन ~0.35 TRX जलाता है

API से बैंडविड्थ किराए पर लेना 350 यूनिट (एक ट्रांसफ़र) के लिए ~0.34 TRX है। एक पते से रोज़ कई ट्रांसफ़र करने वाली सेवाओं के लिए किराया सस्ता और अनुमानयोग्य है।

बैंडविड्थ सस्ता संसाधन है — लेकिन बड़े पैमाने पर (मास पेआउट, एक्सचेंज, बॉट) जलाया गया TRX जुड़ता जाता है। इसे ऊर्जा की तरह ही किराए पर लें।

आपको क्या चाहिए

  • tronrental.com पर खाता
  • API की (डैशबोर्ड → API → की बनाएँ)
  • आपके बैलेंस में TRX (डैशबोर्ड → डिपॉज़िट)
  • 5 मिनट

त्वरित शुरुआत: 3 चरणों में पहली खरीद

चरण 1 — कीमत जाँचें

curl https://api.tronrental.com/v1/bandwidth/prices
{
  "price_sun_1h": 400,
  "price_sun_1d": 630,
  "min_volume": 350,
  "max_volume": 100000,
  "fixed_fee_trx": "0.2"
}

price_sun_1h 1 घंटे के किराए के लिए प्रति बैंडविड्थ यूनिट कीमत है; price_sun_1d 1 दिन के लिए। min_volume / max_volume एक ऑर्डर की सीमा तय करते हैं, fixed_fee_trx ऊपर से जुड़ता है।

चरण 2 — बैंडविड्थ खरीदें

curl -X POST https://api.tronrental.com/v1/bandwidth/buy \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"target_address": "TRecipient...", "volume": 350, "duration": "1h"}'
{
  "id": 1842,
  "status": "pending",
  "volume": 350,
  "price_trx": "0.34",
  "target_address": "TRecipient..."
}

बैंडविड्थ target_address को सौंपी जाती है — यह आपका अपना पता हो सकता है या किसी और का। 350 यूनिट एक मानक USDT ट्रांसफ़र को कवर करती है।

चरण 3 — ऑर्डर की पुष्टि करें

curl https://api.tronrental.com/v1/orders/1842 \
  -H "X-API-Key: YOUR_API_KEY"
{
  "id": 1842,
  "status": "filled",
  "volume": 350,
  "txid": "a1b2c3..."
}

जब स्थिति "filled" हो जाए — बैंडविड्थ सौंप दी गई है। अब आप अपना ट्रांज़ैक्शन भेज सकते हैं।

Python में वही चीज़

import httpx

API_KEY = "your_api_key"
BASE = "https://api.tronrental.com/v1"
HEADERS = {"X-API-Key": API_KEY}

async def buy_bandwidth(target_address: str, amount: int = 350) -> dict:
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{BASE}/bandwidth/buy",
            headers=HEADERS,
            json={"target_address": target_address, "volume": amount, "duration": "1h"},
        )
        resp.raise_for_status()
        return resp.json()

JavaScript में वही चीज़

const API_KEY = "your_api_key";
const BASE = "https://api.tronrental.com/v1";

async function buyBandwidth(targetAddress, amount = 350) {
  const resp = await fetch(`${BASE}/bandwidth/buy`, {
    method: "POST",
    headers: {
      "X-API-Key": API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      target_address: targetAddress,
      volume: amount,
      duration: "1h",
    }),
  });
  if (!resp.ok) throw new Error(`API error: ${resp.status}`);
  return resp.json();
}

कितनी बैंडविड्थ खरीदें?

परिदृश्यबैंडविड्थक्यों
एक USDT ट्रांसफ़र350मानक TRC-20 ट्रांसफ़र का आकार
एक पते से कई ट्रांसफ़र350 × Nमुफ़्त 600/दिन सिर्फ़ पहले ट्रांसफ़र को कवर करती है

पता नहीं कितनी मुफ़्त बैंडविड्थ बची है? खरीदने से पहले जाँचें:

curl "https://api.tronrental.com/v1/tools/address-info?address=TRecipient..."
{
  "bandwidth_used": 0,
  "bandwidth_limit": 600,
  "is_activated": true
}

सीमाएँ: प्रति ऑर्डर न्यूनतम 350 बैंडविड्थ, अधिकतम 100,000। अवधि: "1h" और "1d"।

ऊर्जा किराए पर लेना

बैंडविड्थ ट्रांज़ैक्शन को कवर करती है, लेकिन USDT (TRC-20) ट्रांसफ़र को ऊर्जा भी चाहिए — और असली लागत वहीं है। ऊर्जा के बिना नेटवर्क प्रति ट्रांसफ़र 6.43–13.28 TRX जलाता है।

अगर आप USDT भेजते हैं, तो लगभग हमेशा ऊर्जा भी चाहिए। इसे किराए पर लेना 6.43 TRX जलाने के बजाय 65K के लिए ~1.80 TRX है।

खरीद

curl -X POST https://api.tronrental.com/v1/energy/buy \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"target_address": "TRecipient...", "volume": 65000, "duration": "1h"}'

65,000 ऊर्जा = 1 USDT ट्रांसफ़र (प्राप्तकर्ता के पास पहले से USDT है), 131,000 अगर प्राप्तकर्ता के पास कभी USDT नहीं रहा। विवरण के लिए समर्पित ऊर्जा API गाइड देखें।

पूरा उदाहरण: बैंडविड्थ खरीदें → ट्रांज़ैक्शन भेजें

वास्तविक पैटर्न — भेजने वाले पते के लिए बैंडविड्थ खरीदें, सौंपने का इंतज़ार करें, फिर ट्रांज़ैक्शन भेजें:

import asyncio
import httpx

API_KEY = "your_api_key"
BASE = "https://api.tronrental.com/v1"
HEADERS = {"X-API-Key": API_KEY}


async def buy_bandwidth_and_wait(target: str, amount: int = 350) -> str:
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{BASE}/bandwidth/buy",
            headers=HEADERS,
            json={"target_address": target, "volume": amount, "duration": "1h"},
        )
        data = resp.json()

        if resp.status_code == 400:
            raise Exception(f"Purchase failed: {data.get('detail', data)}")
        resp.raise_for_status()

        order_id = data["id"]

        for _ in range(10):
            await asyncio.sleep(3)
            check = await client.get(f"{BASE}/orders/{order_id}", headers=HEADERS)
            order = check.json()
            if order["status"] == "filled":
                return order["txid"]

        raise TimeoutError(f"Order {order_id} not filled after 30s")


async def send_usdt_with_resources(sender: str, recipient: str, amount_usdt: float):
    bw_tx = await buy_bandwidth_and_wait(sender, amount=350)
    print(f"Bandwidth delegated: {bw_tx}")
    # ... your USDT transfer logic here (tronpy, tronweb, etc.)

त्रुटि प्रबंधन

HTTP स्थितिमतलबक्या करें
400गलत अनुरोध (अमान्य पता, अपर्याप्त बैलेंस)त्रुटि संदेश पढ़ें, ठीक करें और पुनः प्रयास करें
429रेट लिमिट पार (100 req/min)प्रतीक्षा करें और backoff के साथ पुनः प्रयास करें
5xxसर्वर त्रुटिएक्सपोनेंशियल backoff के साथ पुनः प्रयास करें

अक्सर पूछे जाने वाले प्रश्न

बैंडविड्थ कितनी तेज़ी से सौंपी जाती है?

आमतौर पर 3–5 सेकंड। बैंडविड्थ अगले ब्लॉक में on-chain सौंपी जाती है।

क्या मुझे बैंडविड्थ खरीदनी भी चाहिए? क्या यह मुफ़्त नहीं है?

हर पते को रोज़ 600 मुफ़्त बैंडविड्थ मिलती है — लगभग 1 USDT ट्रांसफ़र के लिए काफ़ी। अगर आप एक पते से रोज़ इससे ज़्यादा ट्रांसफ़र करते हैं, तो नेटवर्क बैंडविड्थ के लिए TRX जलाता है, और किराया सस्ता पड़ता है।

USDT ट्रांसफ़र के लिए बैंडविड्थ चाहिए या ऊर्जा?

दोनों। बैंडविड्थ ट्रांज़ैक्शन रिकॉर्ड (~350 यूनिट) को कवर करती है; ऊर्जा स्मार्ट कॉन्ट्रैक्ट निष्पादन (65,000 यूनिट) को। ऊर्जा महँगी है — ज़्यादातर लोग दोनों किराए पर लेते हैं।

क्या मैं किसी और के पते के लिए बैंडविड्थ खरीद सकता हूँ?

हाँ। target_address में कोई भी मान्य TRON पता डालें। इसका मालिक होना ज़रूरी नहीं।

पूरा दस्तावेज़ कहाँ है?

docs.tronrental.com — सभी एंडपॉइंट, अनुरोध/प्रतिक्रिया स्कीमा, webhook सेटअप, और बहुत कुछ।

साझा करें:

क्या यह उपयोगी था?