POST /apiv2/bandwidth

एक निश्चित अवधि (5 मिनट या 1 घंटा) के लिए TRON Bandwidth किराए पर लें और इसे प्राप्तकर्ता के पते पर डेलिगेट करें।

⚠️ एक्सेस स्तर (Access tiers)।
प्रत्यायित (Accredited) खाते पूल आकार और अधिकतम सीमाओं के भीतर कई समवर्ती ऑर्डरों (concurrent orders) के साथ कोई भी राशि (5000 तक) किराए पर ले सकते हैं। प्रत्यायन (Accreditation) Netts support द्वारा प्रदान किया जाता है।
प्रत्यायन के बिना आप एक बार में 400 यूनिट किराए पर ले सकते हैं — अगला ऑर्डर केवल पिछला किराया समाप्त होने के बाद ही दिया जा सकता है। 400 के अलावा अन्य राशियों के अनुरोध, या पहला ऑर्डर सक्रिय रहने के दौरान दूसरा ऑर्डर अस्वीकार कर दिया जाता है।

एंडपॉइंट URL

POST https://netts.io/apiv2/bandwidth

अनुरोध हेडर (Request Headers)

हेडर	आवश्यक	विवरण
Content-Type	हाँ	application/json
X-API-KEY	हाँ	Netts डैशबोर्ड से आपकी API कुंजी
X-Real-IP	हाँ	आपकी श्वेतसूची (whitelist) से IP पता
X-Idempotency-Key	नहीं	बिना दोहरा ऑर्डर किए सुरक्षित रूप से पुनः प्रयास करने के लिए वैकल्पिक क्लाइंट-जनरेटेड कुंजी (base64)। यदि छोड़ दिया जाता है, तो सर्वर स्वचालित रूप से एक कुंजी जनरेट करता है

अनुरोध बॉडी (Request Body)

json

{
    "amount": 1500,
    "receiveAddress": "TXXxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "period": "5m"
}

पैरामीटर

पैरामीटर	प्रकार	आवश्यक	विवरण
amount	पूर्णांक	हाँ	किराए पर लेने के लिए Bandwidth यूनिट (न्यूनतम: 400, अधिकतम: 5000)
receiveAddress	स्ट्रिंग	हाँ	TRON पता जो Bandwidth प्राप्त करेगा (`T…`, 34 वर्ण, base58)
period	स्ट्रिंग	हाँ	किराये की अवधि: `"5m"` (5 मिनट) या `"1h"` (1 घंटा)
trx_send	बूलियन	नहीं	गारंटीकृत लेनदेन: यदि कोई Bandwidth उपलब्ध नहीं है, तो पते पर TRX भेजें ताकि लेनदेन फिर भी पूरा हो जाए। केवल तभी काम करता है जब `amount = 400` (अन्यथा अनदेखा कर दिया जाता है)। डिफ़ॉल्ट `false`
check	बूलियन	नहीं	यदि `true` है और प्राप्तकर्ता के पास पहले से ही 400 से अधिक Bandwidth है, तो ऑर्डर डेलिगेट नहीं किया जाता है और कोई धनराशि नहीं काटी जाती है (स्थिति `enough`)। डिफ़ॉल्ट `false`
test	बूलियन	नहीं	ड्राई रन (Dry run)। यदि `true` है, तो संपूर्ण ऑर्डर प्रवाह सिम्युलेट किया जाता है — प्रतिक्रिया आपको वह परिणाम बताती है जो घटित होगा और वह मूल्य जो लिया जाएगा — बिना किसी ऑन-चेन कार्रवाई और बिना शुल्क लिए। डिफ़ॉल्ट `false`

उदाहरण अनुरोध

नीचे दिए गए उदाहरण X-Idempotency-Key भी बनाते और भेजते हैं ताकि गलती से दोबारा अनुरोध भेजने पर दूसरा ऑर्डर न बन जाए। पूर्ण नियमों के लिए Idempotency देखें।

cURL

bash

API_KEY="your_api_key"
ADDR="TXXxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
AMOUNT=1500
PERIOD="5m"
NONCE=$(( $(date +%s) / 2 ))   # stable for retries within a 2s window; or your own order UUID

# X-Idempotency-Key = base64( HMAC-SHA256( API_KEY, "addr:amount:period:nonce" ) )
IDEMP=$(printf '%s' "${ADDR}:${AMOUNT}:${PERIOD}:${NONCE}" \
  | openssl dgst -sha256 -hmac "$API_KEY" -binary | base64)

curl -X POST https://netts.io/apiv2/bandwidth \
  -H "Content-Type: application/json" \
  -H "X-API-KEY: $API_KEY" \
  -H "X-Real-IP: your_whitelisted_ip" \
  -H "X-Idempotency-Key: $IDEMP" \
  -d "{\"amount\": $AMOUNT, \"receiveAddress\": \"$ADDR\", \"period\": \"$PERIOD\"}"

Python

python

import time, hmac, hashlib, base64, requests

API_KEY = "your_api_key"
url = "https://netts.io/apiv2/bandwidth"
payload = {
    "amount": 1500,
    "receiveAddress": "TXXxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "period": "5m",
}

# X-Idempotency-Key = base64( HMAC-SHA256( API_KEY, "addr:amount:period:nonce" ) )
# Generate ONCE per order and resend the same value on every retry.
nonce = str(int(time.time() // 2))   # 2s bucket; or your own order UUID
message = f"{payload['receiveAddress']}:{payload['amount']}:{payload['period']}:{nonce}"
idem_key = base64.b64encode(
    hmac.new(API_KEY.encode(), message.encode(), hashlib.sha256).digest()
).decode()

headers = {
    "Content-Type": "application/json",
    "X-API-KEY": API_KEY,
    "X-Real-IP": "your_whitelisted_ip",
    "X-Idempotency-Key": idem_key,
}

response = requests.post(url, headers=headers, json=payload)
data = response.json()
detail = data.get("detail", {})

if response.status_code == 200 and detail.get("status") == "completed":
    d = detail["data"]
    print(f"Order ID: {d['orderId']}")
    print(f"Hashes:   {d['hash']}")          # array of delegation tx hashes
    print(f"Bandwidth: {d['bandwidth']} for {d['period']}")
    print(f"Cost:     {d['paidTRX']} TRX")
else:
    print(f"Code: {detail.get('code')} | {detail.get('msg', detail)}")

सेवा पैकेज (handler_bandwidth/doc/client_example/) के साथ एक पूर्ण क्लाइंट उदाहरण (Python + cURL) प्रदान किया गया है।

प्रतिक्रिया (Response)

सफलता — Bandwidth डेलिगेट की गई (200 OK)

json

{
    "detail": {
        "code": 10000,
        "status": "completed",
        "msg": "Successful",
        "data": {
            "orderId": "B5M<key14>",
            "paidTRX": "<amount charged in TRX>",
            "fulfilledBy": "bandwidth",
            "hash": ["a1b2c3...", "d4e5f6..."],
            "bandwidth": 1500,
            "period": "5m"
        }
    }
}

सफलता — Bandwidth के स्थान पर TRX भेजा गया (200 OK, केवल `amount=400` + `trx_send=true`)

जब पूल में कोई Bandwidth नहीं होती है और trx_send सक्षम होता है, तो पते पर TRX भेजा जाता है ताकि लेनदेन फिर भी पूरा हो सके। इस स्थिति में एक निश्चित शुल्क लागू होता है, अनुरोधित अवधि चाहे जो भी हो।

json

{
    "detail": {
        "code": 10000,
        "status": "completed",
        "msg": "Successful (sent TRX, bandwidth unavailable)",
        "data": {
            "orderId": "B5M<key14>",
            "paidTRX": "<amount charged in TRX>",
            "fulfilledBy": "trx",
            "trxSendHash": ["<txid>"],
            "hash": [],
            "bandwidth": 400,
            "period": "5m"
        }
    }
}

पहले से पर्याप्त — कोई शुल्क नहीं लिया गया (200 OK, केवल `check=true` के साथ)

json

{
    "detail": {
        "code": 10002,
        "status": "enough",
        "msg": "enough band for 1 transfer",
        "data": { "orderId": "B5M<key14>", "paidTRX": 0, "bandwidth": 400, "period": "5m" }
    }
}

प्रसंस्करण — बाहरी प्रदाता (202 Accepted)

यह तब लौटाया जाता है जब ऑर्डर एसिंक्रोनस रूप से किसी बाहरी प्रदाता को सौंपा जाता है। स्थिति एंडपॉइंट (नीचे) को orderId का उपयोग करके तब तक पोल करें जब तक यह पूरा न हो जाए।

json

{
    "detail": {
        "code": 10001,
        "status": "processing",
        "msg": "Order accepted, processed by an external provider. Poll the status endpoint.",
        "data": { "orderId": "B5M<key14>", "bandwidth": 1500, "period": "5m" }
    }
}

परीक्षण रन (200 OK, केवल `test=true` के साथ)

संपूर्ण ऑर्डर प्रवाह सिम्युलेट किया जाता है। testAction आपको बताता है कि क्या होगा और wouldCostTRX बताता है कि क्या शुल्क लिया जाएगा। कुछ भी डेलिगेट नहीं किया जाता है, कोई TRX नहीं भेजा जाता है, कोई शुल्क नहीं लिया जाता है (paidTRX: 0)।

json

{
    "detail": {
        "code": 10003,
        "status": "test",
        "msg": "Test run — no on-chain action, no charge",
        "data": {
            "orderId": "B5M<...>",
            "testAction": "would_delegate",
            "wouldCostTRX": "<amount that would be charged in TRX>",
            "paidTRX": 0,
            "bandwidth": 400,
            "period": "5m",
            "receiverFreeBandwidth": 600
        }
    }
}

testAction के मान: would_delegate (Bandwidth डेलिगेट की जाएगी), would_trx_send (कोई Bandwidth नहीं, amount=400 + trx_send → TRX भेजा जाएगा), enough (प्राप्तकर्ता के पास पहले से पर्याप्त है, check=true के साथ), या would_error:<reason> (उदा. no_bandwidth, not_whitelisted)।

प्रतिक्रिया फ़ील्ड्स

फ़ील्ड	प्रकार	विवरण
detail.code	पूर्णांक	`10000` डेलिगेटेड/TRX, `10002` पर्याप्त, `10001` प्रसंस्करण
detail.status	स्ट्रिंग	`completed` / `enough` / `processing` / `failed`
detail.data.orderId	स्ट्रिंग	ऑर्डर ID, प्रारूप `B5M…` (5m) / `B1H…` (1h) — स्थिति एंडपॉइंट के लिए इसका उपयोग करें
detail.data.paidTRX	संख्या	TRX में ली गई राशि (`enough` होने पर `0`)
detail.data.fulfilledBy	स्ट्रिंग	`bandwidth` (डेलिगेटेड) / `trx` (TRX भेजा गया)
detail.data.hash	ऐरे	डेलिगेशन लेनदेन हैश (10 तक)। हमेशा एक ऐरे (TRX शाखा के लिए खाली)
detail.data.trxSendHash	ऐरे	TRX ट्रांसफर हैश, केवल तभी मौजूद होता है जब `fulfilledBy = trx`
detail.data.bandwidth	पूर्णांक	डेलिगेट की गई Bandwidth यूनिट
detail.data.period	स्ट्रिंग	किराये की अवधि (`5m` / `1h`)

स्थिति एंडपॉइंट (Status Endpoint)

GET https://netts.io/apiv2/bandwidth/status/{orderId}

हेडर: X-API-KEY + X-Real-IP (ऑर्डर प्रमाणीकृत उपयोगकर्ता का होना चाहिए)।

ऑर्डर स्थिति	HTTP	code	status
पूर्ण हुआ	200	10000	`completed` (`hash` / `trxSendHash` के साथ)
प्रगति पर है	200	10001	`processing`
पहले से पर्याप्त है	200	10002	`enough`
विफल रहा	200	5003	`failed`
नहीं मिला / आपका नहीं है	404	-1	—

रिक्लेम एंडपॉइंट (Reclaim Endpoint)

अपनी अवधि समाप्त होने से पहले अपने डेलिगेटेड ऑर्डरों में से किसी एक की Bandwidth को स्वेच्छा से वापस (रिक्लेम/अंडेलिगेट) लें। Bandwidth स्वचालित रूप से अंडेलिगेट हो जाती है और लेनदेन हैश वापस कर दिया जाता है।

POST https://netts.io/apiv2/bandwidth/reclaim/{orderId}

हेडर: X-API-KEY + X-Real-IP (ऑर्डर प्रमाणीकृत उपयोगकर्ता का होना चाहिए)।

ऑर्डर स्थिति	HTTP	code	status	परिणाम
डेलिगेटेड → अब रिक्लेम किया गया	200	10004	`reclaimed`	`reclaimHash` (अंडेलिगेट tx हैश)
पहले ही रिक्लेम किया जा चुका है	200	10004	`reclaimed`	`reclaimHash` + संदेश "already reclaimed"
डेलिगेटेड स्थिति में नहीं है (रिक्लेम करने के लिए कुछ नहीं है)	400	5005	`failed`	—
रिक्लेम अभी पूरा नहीं हुआ है	503	5003	`failed`	थोड़ी देर बाद पुनः प्रयास करें
नहीं मिला / आपका नहीं है	404	-1	—	—

bash

curl -X POST https://netts.io/apiv2/bandwidth/reclaim/B5M<...> \
  -H "X-API-KEY: your_api_key" -H "X-Real-IP: your_whitelisted_ip"

json

{
    "detail": {
        "code": 10004,
        "status": "reclaimed",
        "msg": "Bandwidth reclaimed",
        "data": { "orderId": "B5M<...>", "reclaimHash": ["<txid>"] }
    }
}

python

import requests

order_id = "B5M..."   # the orderId from your rental response
url = f"https://netts.io/apiv2/bandwidth/reclaim/{order_id}"
headers = {"X-API-KEY": "your_api_key", "X-Real-IP": "your_whitelisted_ip"}

resp = requests.post(url, headers=headers)
detail = resp.json()["detail"]

if resp.status_code == 200 and detail["status"] == "reclaimed":
    print(f"Reclaimed: {detail['data']['reclaimHash']} ({detail['msg']})")
else:
    print(f"Code {detail.get('code')}: {detail.get('msg', detail)}")

समय से पहले स्वैच्छिक रिक्लेम करने पर किराये का शुल्क वापस (रिफंड) नहीं किया जाता है — रिक्लेम करने से केवल अवधि समाप्त होने से पहले डेलिगेट की गई Bandwidth पूल में वापस लौटती है।

त्रुटि प्रतिक्रियाएँ (Error Responses)

प्रमाणीकरण त्रुटि (401)

json

{ "detail": { "code": -1, "msg": "Invalid API key or IP not in whitelist" } }

अपर्याप्त बैलेंस (403)

json

{ "detail": { "code": 1004, "status": "failed", "msg": "Insufficient funds" } }

सत्यापन त्रुटि (400)

json

{ "detail": { "code": 5004, "status": "failed", "msg": "Bandwidth amount out of range (400..5000)" } }

डेलिगेशन विफल / सेवा अनुपलब्ध (503)

json

{ "detail": { "code": 5003, "status": "failed", "msg": "Bandwidth delegation failed" } }

त्रुटि कोड संदर्भ

कोड	विवरण	HTTP स्थिति
`10000`	सफलता (डेलिगेटेड, या TRX भेजा गया)	200
`10000`	सफलता (कैश्ड प्रतिक्रिया)	208
`10001`	स्वीकृत, बाहरी प्रदाता द्वारा प्रसंस्करण जारी है	202
`10002`	प्राप्तकर्ता के पास पहले से ही पर्याप्त Bandwidth है (शुल्क नहीं लिया गया)	200
`10003`	परीक्षण रन — परिणाम + मूल्य पूर्वावलोकन, कोई शुल्क नहीं लिया गया (`test=true`)	200
`10004`	Bandwidth वापस ली गई (स्वैच्छिक अंडेलिगेट) — `reclaimHash` लौटाया गया	200
`-`	डुप्लिकेट अनुरोध अभी भी संसाधित हो रहा है	409
`-1`	अमान्य API कुंजी / IP श्वेतसूची में नहीं है	401
`1004`	अपर्याप्त बैलेंस	403
`1005`	उपयोगकर्ता के लिए कोई भुगतानकर्ता पता नहीं है	400
`5004`	अमान्य राशि/अवधि (सत्यापन)	400
`5005`	रिक्लेम करने के लिए कुछ नहीं है (ऑर्डर डेलिगेटेड स्थिति में नहीं है)	400
`5007`	बिना प्रत्यायन के — एक समय में केवल एक किराया; पिछला ऑर्डर अभी भी सक्रिय है (इसके समाप्त होने तक प्रतीक्षा करें)	503
`5008`	बिना प्रत्यायन के — केवल 400-यूनिट ऑर्डरों की अनुमति है; बड़ी राशियों के लिए प्रत्यायन आवश्यक है	503
`5003`	Bandwidth डेलिगेशन विफल / अनुपलब्ध	503
`5000`	आंतरिक सर्वर त्रुटि (Internal server error)	500

दर सीमाएं (Rate Limits)

अवधि	सीमा	विवरण
1 सेकंड	50 अनुरोध	प्रति IP प्रति सेकंड अधिकतम 50 अनुरोध

दर सीमा पार हो गई (429)

json

{ "message": "API rate limit exceeded" }

Idempotency

वैकल्पिक X-Idempotency-Key हेडर भेजें ताकि गलती से दोबारा अनुरोध भेजने पर दूसरा ऑर्डर न बने — मूल प्रतिक्रिया HTTP 208 के साथ वापस कर दी जाती है। यदि आप हेडर नहीं भेजते हैं, तो सर्वर थोड़े समय के भीतर आपके अनुरोध पैरामीटर से स्वचालित रूप से एक कुंजी प्राप्त कर लेता है।

कुंजी कैसे बनाएं

कुंजी base64( HMAC-SHA256( secret, message ) ) है — एक 44-वर्णों की base64 स्ट्रिंग, जहाँ:

secret = आपकी API कुंजी (X-API-KEY);
message = फ़ील्ड जिन्हें : के साथ जोड़ा गया है — receiveAddress:amount:period:nonce।

nonce कोई भी ऐसा मान है जो समान लॉजिकल ऑर्डर के पुन: प्रयासों में स्थिर रहता है लेकिन अलग-अलग ऑर्डरों के बीच भिन्न होता है — उदा. एक UUID जो आप उस ऑर्डर के लिए रखते हैं, या एक मोटा टाइमस्टैम्प बकेट। प्रति ऑर्डर एक बार कुंजी जनरेट करें और हर पुन: प्रयास पर बिल्कुल वही मान दोबारा भेजें।

python

import hmac, hashlib, base64, time

def make_idempotency_key(api_key, receive_address, amount, period, nonce=None):
    if nonce is None:
        nonce = str(int(time.time() // 2))   # 2-second bucket; or your own order UUID
    message = f"{receive_address}:{amount}:{period}:{nonce}"
    digest = hmac.new(api_key.encode(), message.encode(), hashlib.sha256).digest()
    return base64.b64encode(digest).decode()  # 44-char base64

bash

# then send it as a header:
-H "X-Idempotency-Key: <base64_key>"

संदेश में period को शामिल करना महत्वपूर्ण है: 5m और 1h के लिए समान पते को किराए पर लेना अलग-अलग ऑर्डर हैं और उन्हें अलग-अलग कुंजियाँ उत्पन्न करनी चाहिए।

सत्यापन। प्रदान की गई X-Idempotency-Key 16–64 वर्णों (वर्णसेट A–Z a–z 0–9 + / = _ -) की एक base64 स्ट्रिंग होनी चाहिए। एक विकृत या अत्यधिक लंबी कुंजी को HTTP 400 (code 5004) के साथ अस्वीकार कर दिया जाता है।

स्थिति कोड	अर्थ
200	सफलतापूर्वक संसाधित किया गया (पहला अनुरोध)
208	पहले ही सफलतापूर्वक संसाधित किया जा चुका है — कैश्ड प्रतिक्रिया लौटाई गई (कोई दूसरा शुल्क नहीं)
409	वही अनुरोध वर्तमान में संसाधित किया जा रहा है — प्रतीक्षा करें, अभी पुनः प्रयास न करें

विफलता के बाद पुनः प्रयास करना। केवल सफल परिणाम (completed / enough) ही कैश किए जाते हैं। यदि पिछला प्रयास विफल रहा या टाइम आउट हो गया (कोई धनराशि नहीं काटी गई), तो आप सुरक्षित रूप से उसी X-Idempotency-Key के साथ पुन: प्रयास कर सकते हैं — पुरानी त्रुटि लौटाने के बजाय ऑर्डर का पुनः प्रयास किया जाता है। जब तक कोई प्रयास प्रगति पर है तब तक आपको 409 मिलता है; प्रतीक्षा करें और पुन: प्रयास करें।

एक्सेस स्तर: प्रत्यायित खाते समवर्ती ऑर्डरों के साथ पूल/अधिकतम सीमाओं के भीतर किसी भी राशि को किराए पर लेते हैं; बिना प्रत्यायन के — एक बार में 400 यूनिट (पिछला किराया समाप्त होने के बाद ही अगला ऑर्डर)। प्रत्यायन के लिए Netts support से संपर्क करें।
न्यूनतम: 400 यूनिट। अधिकतम: 5000 यूनिट प्रति ऑर्डर (वर्तमान कॉन्फ़िगरेशन)।
अवधियाँ: 5m (300 सेकंड) और 1h (3600 सेकंड)। अवधि समाप्त होने पर Bandwidth स्वचालित रूप से रिक्लेम कर ली जाती है।
कोई बफ़र नहीं: ठीक उतनी ही राशि डेलिगेट की जाती है जितनी अनुरोध की गई थी।
hash एक ऐरे है: एक एकल ऑर्डर 10 डेलिगेशन हैश तक उत्पन्न कर सकता है — सभी वापस किए जाते हैं।
मूल्य निर्धारण: TRX में शुल्क लिया जाता है, जो अनुरोधित राशि और अवधि पर आधारित होता है; दरें दिन के समय के अनुसार भिन्न हो सकती हैं। वर्तमान मूल्य निर्धारण के लिए समर्थन से संपर्क करें।
छोटे ऑर्डर का मुआवज़ा (डेलिगेशन): 1000 यूनिट से कम के ऑर्डरों के लिए, ऑन-चेन डेलिगेशन और रिक्लेम के मुआवज़े के रूप में मूल्य में एक निश्चित 0.372 TRX जोड़ा जाता है। 1000 यूनिट या उससे अधिक के ऑर्डरों में ऐसा कोई अतिरिक्त शुल्क नहीं होता है।
TRX-send मुआवज़ा: जब ऑर्डर TRX भेजकर पूरा किया जाता है (fulfilledBy = trx), तो इसके बजाय एक निश्चित 0.268 TRX जोड़ा जाता है (ऑन-चेन TRX ट्रांसफर के मुआवज़े के रूप में)।
trx_send: केवल amount = 400 के लिए; यदि कोई Bandwidth उपलब्ध नहीं है, तो पते पर TRX भेजा जाता है ताकि लेनदेन फिर भी पूरा हो जाए।
check: जब प्राप्तकर्ता के पास पहले से ही 400 से अधिक Bandwidth होती है, तो डेलिगेशन (और शुल्क कटौती) छोड़ दी जाती है।
ऑर्डर ID प्रारूप: B5M… (5 मिनट) / B1H… (1 घंटा)।
प्रतिक्रिया टाइमआउट: डेलिगेशन की प्रतीक्षा करते समय ~12 सेकंड तक; आमतौर पर 1–2 सेकंड।

POST /apiv2/bandwidth ​

एंडपॉइंट URL ​

अनुरोध हेडर (Request Headers) ​

अनुरोध बॉडी (Request Body) ​

पैरामीटर ​

उदाहरण अनुरोध ​

cURL ​

Python ​

प्रतिक्रिया (Response) ​

सफलता — Bandwidth डेलिगेट की गई (200 OK) ​

सफलता — Bandwidth के स्थान पर TRX भेजा गया (200 OK, केवल amount=400 + trx_send=true) ​

पहले से पर्याप्त — कोई शुल्क नहीं लिया गया (200 OK, केवल check=true के साथ) ​

प्रसंस्करण — बाहरी प्रदाता (202 Accepted) ​

परीक्षण रन (200 OK, केवल test=true के साथ) ​

प्रतिक्रिया फ़ील्ड्स ​

स्थिति एंडपॉइंट (Status Endpoint) ​

रिक्लेम एंडपॉइंट (Reclaim Endpoint) ​

त्रुटि प्रतिक्रियाएँ (Error Responses) ​

प्रमाणीकरण त्रुटि (401) ​

अपर्याप्त बैलेंस (403) ​

सत्यापन त्रुटि (400) ​

डेलिगेशन विफल / सेवा अनुपलब्ध (503) ​

त्रुटि कोड संदर्भ ​

दर सीमाएं (Rate Limits) ​

दर सीमा पार हो गई (429) ​

Idempotency ​

कुंजी कैसे बनाएं ​

टिप्पणियाँ ​

POST /apiv2/bandwidth

एंडपॉइंट URL

अनुरोध हेडर (Request Headers)

अनुरोध बॉडी (Request Body)

पैरामीटर

उदाहरण अनुरोध

cURL

Python

प्रतिक्रिया (Response)

सफलता — Bandwidth डेलिगेट की गई (200 OK)

सफलता — Bandwidth के स्थान पर TRX भेजा गया (200 OK, केवल `amount=400` + `trx_send=true`)

पहले से पर्याप्त — कोई शुल्क नहीं लिया गया (200 OK, केवल `check=true` के साथ)

प्रसंस्करण — बाहरी प्रदाता (202 Accepted)

परीक्षण रन (200 OK, केवल `test=true` के साथ)

प्रतिक्रिया फ़ील्ड्स

स्थिति एंडपॉइंट (Status Endpoint)

रिक्लेम एंडपॉइंट (Reclaim Endpoint)

त्रुटि प्रतिक्रियाएँ (Error Responses)

प्रमाणीकरण त्रुटि (401)

अपर्याप्त बैलेंस (403)

सत्यापन त्रुटि (400)

डेलिगेशन विफल / सेवा अनुपलब्ध (503)

त्रुटि कोड संदर्भ

दर सीमाएं (Rate Limits)

दर सीमा पार हो गई (429)

Idempotency

कुंजी कैसे बनाएं

टिप्पणियाँ