इसे छोड़कर कंटेंट पर जाएं

ProxyMarket Vendor Integration: अपनी प्रॉक्सी बेचें

AI से पूछें

तैयार टास्कअपने कोड में ProxyMarket इंटीग्रेशन बनाएँ

कोडिंग एजेंट

Claude Codeडेस्कटॉप ऐप खोलता हैCodexडेस्कटॉप ऐप खोलता हैCursorवेब से ऐप खोलता है

चैट असिस्टेंट

ChatGPT में खोलेंनया टैबClaude में खोलेंनया टैब

कॉपी करें

Markdown के रूप में देखेंAI टूल्स के लिए सादा टेक्स्ट
प्रॉम्प्ट देखें
I run my own proxy or VPN platform and want to sell it on ProxyMarket (market.xproxy.io). Read https://xproxy.io/document/proxymarket-vendor-integration.md and the OpenAPI spec https://xproxy.io/docs/api/market.openapi.yaml. If you cannot open links, download them with curl.
Then look at my codebase and add, in its language and framework:
1. GET/HEAD /health that answers fast.
2. The HMAC signature check of every webhook (sign the raw body, compare in constant time).
3. The /provision, /deprovision and /settings webhooks, wired to how my platform creates, deletes and updates proxy users or VPN configs.
4. Plan sync and stock updates with the Integration API.
5. Tests for the signature check and for each webhook.
Keep the API key in an environment variable. When done, tell me how to check it with one real order.
Never print or commit my API keys, passwords or customer logins. Ask me before you open firewall ports, restart services or change config files you did not create.
Other XProxy guides, each with a Markdown copy at its URL + .md, are listed in https://xproxy.io/llms.txt.
I am reading this page in Hindi: https://xproxy.io/hi/document/proxymarket-vendor-integration. The Markdown copy is in English. Answer in Hindi.

ऐप प्रॉम्प्ट भरा हुआ खुलता है। Enter दबाने तक कुछ नहीं चलता।

अपनी प्रॉक्सी या VPN ProxyMarket (market.xproxy.io) पर बेचें. आपके सर्वर आप ही चलाते रहते हैं. ProxyMarket शॉप चलाता है, भुगतान लेता है और ग्राहकों को जवाब देता है. आपकी तरफ़ का एक छोटा connector दोनों को जोड़ता है: यह ProxyMarket को कुछ calls करता है और चार webhooks का जवाब देता है.

आपको चाहिए: market.xproxy.io पर एक मंज़ूर vendor अकाउंट, एक सर्वर जिस तक ProxyMarket वैध certificate वाले HTTPS से पहुँच सके, और कोई ऐसा व्यक्ति जो एक छोटी web service लिख सके. हर endpoint, फ़ील्ड और जवाब ProxyMarket API reference में भी है.

सर्वर लिखने का समय नहीं? ProxyMarket connector एक तैयार सर्वर है. इसे अपने सर्वर पर इंस्टॉल करें, इसे एक छोटी script दें जो आपके सिस्टम में ग्राहक का लॉगिन जोड़ती और हटाती है (Python, Node.js और shell में तैयार scripts हैं), और यह हर ऑर्डर पहुँचा देता है. न कोड, न खुला पोर्ट, न डोमेन.

संक्षेप में

आप ProxyMarket को कॉल करते हैं

अपने प्लान भेजें, स्टॉक और प्रॉक्सी की हालत अपडेट रखें, और ज़रूरत हो तो लॉगिन देर से पहुँचाएँ. हर call में आपकी X-API-Key होती है.

ProxyMarket आपको कॉल करता है

हर 10 मिनट में एक health check, फिर एक webhook जब ग्राहक भुगतान करता है, जब ऑर्डर ख़त्म होता है और जब ग्राहक कोई सेटिंग बदलता है.

70% आपका

हर बिक्री में आपका हिस्सा भुगतान पूरा होते ही जुड़ जाता है. ProxyMarket शॉप, भुगतान, सपोर्ट और रिफ़ंड के लिए 30% रखता है.

यह कैसे काम करता है?

आपका सर्वरमॉडेम, प्रॉक्सी, VPN
ProxyMarketशॉप, भुगतान, सपोर्ट
ग्राहकआपकी प्रॉक्सी से जुड़ता है
ProxyMarket बेचता है. आप प्रॉक्सी लॉगिन या VPN config फ़ाइल पहुँचाते हैं, और फिर ग्राहक सीधे आपके सर्वर से जुड़ता है.

लाइव होने के चरण क्या हैं?

इन्हें इसी क्रम में करें. चरण 1 से 3 आपका अकाउंट तैयार करते हैं; चरण 4 से 7 इंटीग्रेशन हैं.

  1. market.xproxy.io पर एक सामान्य अकाउंट बनाएँआप
  2. vendor बनने के लिए आवेदन करें (ऊपर के मेन्यू में Become Vendor)आप
  3. मंज़ूरी, आम तौर पर 24 घंटे के अंदर. तब तक ऊपर का मेन्यू Vendor Pending… दिखाता है; जल्दी के लिए अपने अकाउंट ईमेल के साथ @xproxyio को मैसेज करेंProxyMarket
  4. इस बीच, अपना health check बनाएँ और अपना webhook सर्वर ऑनलाइन करेंआप
  5. vendor डैशबोर्ड में अपनी API key बनाएँआप
  6. अपने प्लान लिस्ट करें, ऑर्डर संभालें और webhook signatures जाँचेंआप
  7. एक असली टेस्ट ऑर्डर करें और जाँचें कि ग्राहक को काम करती प्रॉक्सी मिलती हैआप + ProxyMarket

health check पहले क्यों बनाएँ?

ProxyMarket आपके सर्वर को HEAD {webhook_url}/health से जाँचता है. यही एक endpoint तय करता है कि आपके प्लान बिक्री पर रहेंगे या नहीं:

  • जब आप अपनी key बनाते हैं, ProxyMarket इसे एक बार कॉल करता है. 5xx, refused कनेक्शन या 5 सेकंड से ज़्यादा: key नहीं बनती (कारण के साथ HTTP 422).
  • उसके बाद हर 10 मिनट में, जब तक key के प्लान बिक्री पर हैं, यह इसे फिर कॉल करता है. लगातार 2 बार फ़ेल होने पर उस key के सभी प्लान शॉप से छिपा दिए जाते हैं और ख़रीदे नहीं जा सकते. एक सही जवाब उन सबको अपने आप वापस ले आता है.
चालू माना जाता हैबंद माना जाता है
5 सेकंड के अंदर 500 से नीचे का कोई भी status. न लॉगिन चाहिए, न body.timeout, refused कनेक्शन, या कोई भी 5xx status.
python
@app.route("/health", methods=["HEAD", "GET"])
def health():
    return "", 200   # no login, no database, no outside call

इसे अपने webhook URL के नीचे रखें: https://your-vendor-host.com/marketplace के साथ यह /marketplace/health पर जवाब देता है.

चलती हुई शॉप का चुपचाप बिक्री बंद होना ज़्यादातर इसी वजह से होता है. एक deploy, एक restart, या HEAD को ब्लॉक करने वाला firewall लगभग 20 मिनट में आपका पूरा कैटलॉग ख़ाली कर सकता है. /health को अपना सबसे सरल route बनाएँ: न लॉगिन, न डेटाबेस, न बाहर की call, और GET का भी जवाब दें.

इसे अपनी प्रॉक्सी की हालत बताएँ (POST /api/integration/health) से न मिलाएँ. वह एक call है जो आप अलग-अलग प्रॉक्सी के बारे में करते हैं; उससे आपके प्लान लिस्ट में नहीं बने रहते.

मुझे अपनी API key कैसे मिलेगी?

vendor आवेदन मंज़ूर होने के बाद आप इसे ख़ुद बनाते हैं; कोई इसे आपको नहीं भेजता. vendor डैशबोर्ड में key को एक नाम और अपना webhook URL दें, जैसे https://your-vendor-host.com/marketplace. आप यह एक call से भी कर सकते हैं (reference):

bash
curl -X POST "https://market.xproxy.io/api/vendor/integrations" \
  -H "Authorization: Bearer $PROXYMARKET_LOGIN_JWT" \
  -H "Content-Type: application/json" \
  -d '{"name": "primary-instance", "webhook_url": "https://your-vendor-host.com/marketplace"}'

# {"api_key": "pm_..."}   <- shown only this once, save it now
key सिर्फ़ एक बार दिखती है. ProxyMarket सिर्फ़ उसका hash रखता है और उसे वापस नहीं दे सकता. इसे तुरंत सेव करें. खो जाए तो नई बनाएँ.

उस एक key से आपको दो values मिलती हैं. इन्हें अलग रखें:

Valueयह क्या हैकिसके लिए
api_keyख़ुद key, जो pm_ से शुरू होती हैआपकी हर call पर X-API-Key header
signing_key64 अक्षरों के hex में SHA256(api_key)हर webhook का X-Signature जाँचने के लिए (कैसे)

key कभी expire नहीं होती, और उसका webhook URL बाद में बदला नहीं जा सकता: सर्वर बदलने के लिए नई key बनाएँ. अगर आप कई अलग-अलग सर्वर चलाते हैं, तो हर एक को उसकी अपनी key दें. ऑर्डर उस key पर जाते हैं जो vendor डैशबोर्ड में हर प्लान के API Key / Server में सेट है. sync से बना प्लान उसी key से जुड़ता है जिसने उसे sync किया; यह सेटिंग न रखने वाला पुराना प्लान अपने ऑर्डर आपकी सबसे पुरानी active key पर भेजता है.

दूसरी key जोड़ रहे हैं? उससे पहले बने प्लान पुरानी key पर ही जाते रहते हैं. उनका API Key / Server नई key पर सेट करें, या पुरानी key बंद करें. कोई प्लान कहीं और जाए तो pm-connector test चेतावनी देता है.

Errors: X-API-Key header के बिना call को 422, ग़लत key को 401, और जिस key के vendor का आवेदन अभी pending है उसे 403 मिलता है. vendor डैशबोर्ड का Integration Status टैब हर key के लिए दिखाता है कि वह आख़िरी बार कब दिखी, connector का version, और नतीजों के साथ आख़िरी 20 deliveries.

मैं अपने प्लान कैसे लिस्ट करूँ?

connector शुरू होने पर, और जब भी कुछ बदले, अपने सभी products अपने प्लान publish या अपडेट करें से भेजें. sync किए प्लान तुरंत मंज़ूर हो जाते हैं (डैशबोर्ड में हाथ से जोड़े प्लान admin का इंतज़ार करते हैं). आपका external_id product के लिए आपकी अपनी ID है (एक पोर्ट, एक मॉडेम, एक VPN pool), और बाद की हर call और webhook इसी का इस्तेमाल करती है.

bash
curl -X POST "https://market.xproxy.io/api/integration/plans/sync" \
  -H "X-API-Key: $PROXYMARKET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[{
    "external_id": "port-1",
    "name": "US Mobile 4G - Port 1",
    "proxy_type": "mobile",
    "protocol": "HTTP",
    "country": "United States",
    "duration_days": 30,
    "price_usd": 25.00,
    "stock": 1,
    "is_active": true
  }]'

# {"created": 1, "updated": 0, "plans": [{"plan_id": "...", "external_id": "port-1", "status": "created"}]}
जानने लायकक्यों
वही external_id फिर भेजने से प्लान अपडेट होता हैsync को दोहराना सुरक्षित है; इससे कभी duplicate नहीं बनते.
जो प्लान आप छोड़ देते हैं वह बिक्री पर रहता हैउसे बेचना बंद करने के लिए प्लान को बिक्री से हटाएँ कॉल करें.
proxy_type में सिर्फ़ mobile, residential, datacenter, isp, ipv6 या vpn इस्तेमाल करेंAPI कोई भी टेक्स्ट ले लेता है, पर दूसरी value ऑर्डर तोड़ देती है: ग्राहक को कभी लॉगिन नहीं मिलता. VPN और VLESS देखें.
country पूरा अंग्रेज़ी नाम है, जैसे United Statesग्राहक सटीक टेक्स्ट से फ़िल्टर करते हैं, इसलिए हर प्लान पर इसे एक जैसा लिखें (और). ProxyMarket इसे जाँचता नहीं.
प्लान तभी दिखता है जब वह active हो, स्टॉक में हो, लिस्टेड हो और health check ने उसे छिपाया न होstock आम तौर पर हर मॉडेम पोर्ट के लिए 1 होता है: हर पोर्ट पर एक ग्राहक.
protocol न भेजने का मतलब HTTP हैVPN और SOCKS5 प्लान के लिए इसे फिर भी भेजें.
sync से बना प्लान उसी key से जुड़ा रहता है जिसने उसे sync कियाउसके ऑर्डर उसी key पर जाते हैं. sync कभी पहले से मौजूद प्लान की key नहीं बदलता (और).

कोई ख़रीदे तो क्या होता है?

  1. ग्राहक भुगतान करता है. आपका 70% तुरंत आपके बैलेंस में जुड़ जाता है, आपके सर्वर को कॉल होने से भी पहले.
  2. ProxyMarket POST {webhook_url}/provision कॉल करता है, order_id और आपके external_plan_id के साथ (payload). signature जाँचें, फिर ग्राहक का एक्सेस बनाएँ.
  3. आप जवाब देते हैं लॉगिन या config के साथ (सबसे अच्छा), pending के साथ, या error के साथ. नीचे की टेबल देखें.
  4. ग्राहक लॉगिन देखता है ProxyMarket पर और आपके सर्वर से जुड़ता है. ProxyMarket प्लान का स्टॉक ख़ुद एक घटा देता है.
  5. समय ख़त्म होने पर ProxyMarket ऑर्डर ख़ुद ख़त्म करता है (यह हर 5 मिनट में जाँचता है) और POST {webhook_url}/deprovision कॉल करता है. आप एक्सेस हटाते हैं और यूनिट को फिर बिक्री पर रखते हैं. जब ऑर्डर ख़त्म होता है देखें.
आपका जवाब वाला statusकब इस्तेमाल करेंक्या होता है
provisioned (सबसे अच्छा)आप तुरंत एक्सेस बना सकते हैंग्राहक को यह तुरंत मिलता है. चारों जोड़ें: proxy_ip, proxy_port, proxy_username, proxy_password, या VPN के लिए vpn_config_file.
pendingसेट करने में थोड़ा समय लगता हैइसे प्रॉक्सी लॉगिन या VPN config पहुँचाएँ से भेजें. ProxyMarket शुरू से गिनकर कुल 120 सेकंड इंतज़ार करता है; उसके बाद ऑर्डर रिफ़ंड हो जाता है और देर से भेजी delivery को 409 मिलता है.
errorआप नहीं दे सकते (पोर्ट ऑफ़लाइन, कोई ख़ाली profile नहीं)कुछ नहीं पहुँचता. 120 सेकंड बाद ग्राहक को उसके wallet में रिफ़ंड मिलता है और आपकी कमाई हटा दी जाती है.
हमेशा HTTP 200 लौटाएँ, error के लिए भी. अगर /provision कोई दूसरा status लौटाता है, timeout होता है (30 सेकंड बाद), ग़लत JSON लौटाता है, या अधूरे लॉगिन के साथ provisioned कहता है, तो ProxyMarket ग्राहक को उसकी जगह वह लॉगिन दे देता है जो आपने प्लान पर sync किया था, अगर हो. पहुँचाया गया लॉगिन कभी प्लान पर कॉपी नहीं होता, और जो प्लान लॉगिन पहले से किसी दूसरे ऑर्डर का है उसे दोबारा इस्तेमाल नहीं किया जाता: वह ऑर्डर रिफ़ंड हो जाता है. call दोबारा नहीं की जाती.

आपके जवाब का expires_at नज़रअंदाज़ किया जाता है: ProxyMarket समय activation से गिनता है और /deprovision में आपको बताता है.

क्या मैं सादे http:// URL पर जवाब encrypt कर सकता हूँ?

हाँ, वैकल्पिक रूप से. 200 लौटाएँ, headers X-PM-Encrypted: v1 और X-PM-Signature: sha256= + आपकी signing key से बने raw body के HMAC-SHA256 का hex, और body {"enc": "v1", "nonce": "…", "ct": "…"} के साथ: एक random 12-byte nonce और आपके सामान्य जवाब का AES-256-GCM ciphertext (tag साथ जुड़ा), दोनों standard base64 में. key आपकी signing key के UTF-8 bytes पर HKDF-SHA256 है (ख़ाली salt, info pm-provision-v1, 32 bytes), और AAD order_id है. ProxyMarket signature जाँचता है, decrypt करता है और जवाब को हमेशा की तरह पढ़ता है; ख़राब envelope timeout जैसा माना जाता है. पूरा फ़ॉर्मैट और एक test vector API reference और गाइड के section 5.1 में है. pm-connector http:// URL पर यह ख़ुद करता है. फिर भी HTTPS सुझाया जाता है, क्योंकि webhook अनुरोध encrypted नहीं होते.

order_id सेव करें: देर से पहुँचाने, ख़ुद ऑर्डर ख़त्म करने और दूसरे webhooks से मिलान के लिए यह चाहिए.

मैं कैसे जाँचूँ कि webhook सच में ProxyMarket से आया है?

हर webhook POST में X-Signature: sha256=… होता है, raw body का HMAC-SHA256. secret आपकी signing key है, hex में SHA256(api_key), ख़ुद API key नहीं. कुछ और करने से पहले इसे /provision, /deprovision और /update-settings पर जाँचें.

python
import hashlib, hmac, os

API_KEY = os.environ["PROXYMARKET_API_KEY"]
# The HMAC secret is SHA256(api_key) as hex, NOT the raw key. Compute it once.
SIGNING_KEY = hashlib.sha256(API_KEY.encode()).hexdigest()


def verify_signature(raw_body: bytes, header: str) -> bool:
    expected = "sha256=" + hmac.new(SIGNING_KEY.encode(), raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, header or "")


# Flask: sign the raw bytes, before you parse the JSON
@app.route("/provision", methods=["POST"])
def provision():
    if not verify_signature(request.get_data(), request.headers.get("X-Signature", "")):
        return jsonify({"status": "error", "message": "Invalid signature"}), 401
    data = request.get_json()
    ...

अनुरोध का raw body इस्तेमाल करें. JSON को parse करके फिर से dump करने से bytes बदल जाते हैं, और signature मेल नहीं खाता.

ग्राहकों के ख़रीदने से पहले मैं कैसे टेस्ट करूँ?

  1. अपने नेटवर्क के बाहर से curl -I https://your-vendor-host.com/marketplace/health चलाएँ और जाँचें कि 5 सेकंड के अंदर 500 से नीचे का status मिलता है.
  2. एक प्लान sync करें और उसे market.xproxy.io पर Browse में ढूँढें.
  3. उसके लिए एक असली ऑर्डर करें. आपके सर्वर को वैध signature के साथ /provision मिलना चाहिए, और लॉगिन ग्राहक के ऑर्डर में दिखना चाहिए.
  4. उस लॉगिन से जुड़ें, फिर ऑर्डर ख़त्म होने का इंतज़ार करें (या Telegram पर इसे ख़त्म करने को कहें) और जाँचें कि /deprovision एक्सेस हटाता है और स्टॉक वापस आता है.

टेस्ट ऑर्डर करते समय ProxyMarket को Telegram @xproxyio पर बताएँ, ताकि उनकी तरफ़ से भी जाँच हो सके.

मैं स्टॉक और हालत अपडेट कैसे रखूँ?

जब आपकी तरफ़ यह होCall
कोई मॉडेम या सर्वर ऑफ़लाइन हो जाएstock: 0, is_active: false के साथ PATCH /plans/stock
वह फिर ऑनलाइन हो, या बिका हुआ पोर्ट फिर ख़ाली होstock: 1, is_active: true के साथ PATCH /plans/stock
कीमत, नाम या config बदलेसिर्फ़ उस प्लान के साथ POST /plans/sync
आप कोई product बेचना बंद करेंDELETE /plans/{external_id}
वैकल्पिक, हर कुछ मिनट मेंहर प्रॉक्सी की हालत और मौजूदा IP के साथ POST /health. current_ip हमेशा शामिल करें: इसे छोड़ने से सेव किया IP मिट जाता है. इससे आपके प्लान लिस्ट में नहीं बने रहते; यह काम आपके सर्वर का health check करता है.

सभी paths https://market.xproxy.io/api/integration से शुरू होते हैं.

जब ऑर्डर ख़त्म होता है तो क्या होता है?

ProxyMarket एक reason के साथ POST {webhook_url}/deprovision कॉल करता है:

Reasonमतलब
expiredकिराये का समय ख़त्म. अपने आप भेजा जाता है, 5 मिनट तक की देरी से.
renewedग्राहक ने चल रहे ऑर्डर को रिन्यू करने का भुगतान किया. पुराना ऑर्डर अभी ख़त्म होता है और नए order_id के साथ एक नया /provision आता है.
cancelledकिसी admin ने ऑर्डर रद्द किया.
admin_refundकिसी admin ने ग्राहक को रिफ़ंड दिया. उसकी आपकी कमाई वापस ले ली जाती है.

ग्राहक का लॉगिन हटाएँ (या उसका VPN profile बंद करें). फिर PATCH /plans/stock से ख़ाली यूनिट की अपनी असली संख्या भेजें: रिफ़ंड के बाद ProxyMarket स्टॉक ख़ुद वापस रखता है, पर expire के बाद नहीं. {"status": "deprovisioned"} लौटाएँ; जवाब सिर्फ़ लॉग होता है.

यह call एक बार भेजी जाती है और कभी दोहराई नहीं जाती. अगर उस समय आपका सर्वर बंद है, तो ग्राहक का एक्सेस बना रहता है. हर ऑर्डर को समय पूरा होने पर अपने टाइमर से भी ख़त्म करें (अवधि आपको /provision से पता है). जो ऑर्डर provisioning में फ़ेल हुआ और अपने आप रिफ़ंड हुआ, उसे /deprovision मिलता ही नहीं.

ऑर्डर को expired मार्क करें सिर्फ़ ProxyMarket पर उसका स्टेटस बदलता है, किसी भी स्थिति में, रद्द ऑर्डर में भी. यह ग्राहक को रिफ़ंड नहीं देता, स्टॉक नहीं बदलता और आपका webhook कॉल नहीं करता.

अगर ग्राहक अपनी IP whitelist या TCP fingerprint बदले तो?

जब ग्राहक किसी active ऑर्डर पर Proxy Settings सेव करता है, ProxyMarket POST {webhook_url}/update-settings कॉल करता है. यह किसी भी ऑर्डर टाइप के लिए एक बार भेजा जाता है. आपका सिस्टम जो सपोर्ट करता है उसे लागू करें और {"status": "ok"} लौटाएँ; जो फ़ील्ड आप सपोर्ट नहीं करते उसे नज़रअंदाज़ कर सकते हैं. body में external_plan_id नहीं होता, इसलिए provision के समय सेव किए order_id से प्लान ढूँढें.

  • ip_whitelist: सिर्फ़ ये IP प्रॉक्सी इस्तेमाल कर सकते हैं. हमेशा अलग-अलग पतों की लिस्ट; [] यानी IP की कोई सीमा नहीं.
  • tcp_fingerprint: कनेक्शन किस OS जैसा दिखे (win1 Windows 11, mac1 macOS, ios1 iPhone 15, android1 Galaxy S24, और भी). null इसे बंद करता है.

मैं VPN और VLESS कैसे बेचूँ?

ऑर्डर का तरीका वही है; बस आप जो पहुँचाते हैं वह बदलता है. पूरी client फ़ाइल भेजें, ठीक वैसी जैसी ग्राहक को import करनी है.

Productप्लान फ़ील्डआप पहुँचाते हैं
OpenVPNproxy_type: "vpn", protocol: "OpenVPN", vpn_protocol: "openvpn"पूरा .ovpn टेक्स्ट, certificates और keys अंदर
WireGuardproxy_type: "vpn", protocol: "WireGuard", vpn_protocol: "wireguard"[Interface] और [Peer] के साथ पूरी .conf
VLESS (Xray)proxy_type: "vpn", protocol: "VLESS", vpn_protocol: "vless"एक लाइन का vless:// लिंक, या पूरा Xray client JSON
कभी proxy_type: "xray" न भेजें. शॉप VLESS प्लान को “Xray” दिखाती है, पर वह label vpn_protocol से आता है. API xray स्वीकार कर लेता है और फिर प्लान टूट जाता है: ग्राहक भुगतान करता है और config कभी नहीं पहुँचता.

फ़ाइल पहुँचाने के तीन तरीके:

  • प्लान के सभी लोगों के लिए एक ही फ़ाइल: sync करते समय इसे vpn_config_template में रखें.
  • हर ऑर्डर के लिए नई फ़ाइल: इसे /provision में बनाएँ और vpn_config_file के साथ जवाब दें.
  • नई फ़ाइल जिसमें समय लगता है: pending लौटाएँ, फिर प्रॉक्सी लॉगिन या VPN config पहुँचाएँ से vpn_config_file भेजें.

VLESS के लिए हर ऑर्डर को उसका अपना UUID दें (एक साझा करने का मतलब है कि एक ग्राहक को हटाने से सब हट जाते हैं), प्लान के विवरण में transport का नाम लिखें (जैसे XTLS-Reality या WS+TLS), और ऑर्डर ख़त्म होने पर UUID को अपने inbound से हटा दें.

OpenVPN फ़ाइल में remote, dev tun या dev tap, या client और एक <ca> block दोनों होने चाहिए; अकेला <ca> block अस्वीकार होता है. हर config में कम से कम 50 अक्षर चाहिए.

IP रोटेशन कैसे काम करता है?

आपका दिया rotation_link एक URL है जिसे ProxyMarket ख़ुद कॉल करता है, सादे GET से (redirects follow होते हैं, certificate जाँचा नहीं जाता, 15 सेकंड का timeout). यह तब होता है जब ग्राहक Rotate दबाता है और ग्राहक के चुने अपने आप रोटेशन टाइमर पर (हर 5 से 60 मिनट), और ऑर्डर ख़त्म होने पर रुक जाता है. ग्राहक भी लिंक देखता है और उसे खोल सकता है.

अगर प्लान का अपना rotation_link fallback के रूप में दिया जाता है (ऊपर देखें), तो वह कभी ऐसा नहीं होता जो पहले से किसी दूसरे ऑर्डर का हो.

क्या कोई तैयार webhook सर्वर है?

हाँ: ProxyMarket connector (pm-connector) आपके Linux या Windows सर्वर पर चलता है और इस पेज का सारा काम आपके लिए करता है. आप इसे बस एक छोटी script देते हैं जो आपके सिस्टम में ग्राहक का लॉगिन जोड़ती और हटाती है; Python, Node.js और shell में तैयार scripts उसके पेज पर हैं.

  • यह signature जाँच के साथ webhooks का जवाब देता है, आपके सिस्टम में ग्राहक का यूज़रनेम और पासवर्ड बनाता है और किराया ख़त्म होने पर उन्हें हटाता है.
  • यह ProxyMarket hook (key टाइप ProxyMarket hook) से ProxyMarket तक पहुँचता है: market-hook-service.xproxy.io तक एक बाहर जाने वाला कनेक्शन, इसलिए सर्वर को न खुला पोर्ट चाहिए, न डोमेन. ग्राहक हमेशा सीधे आपके प्रॉक्सी पोर्ट से जुड़ते हैं.
  • यह बंद रहने के बाद पिछला काम पूरा कर लेता है: जो ऑर्डर इसके ऑफ़लाइन रहते ख़त्म हुए, इसके वापस आते ही उनके user हट जाते हैं.

प्लान आप Vendor Dashboard में बनाते हैं. अगर आप चाहते हैं कि ProxyMarket hook की जगह आपके अपने HTTPS पते को कॉल करे, तो अपना पता इस्तेमाल करना देखें.

मुझे भुगतान कैसे मिलता है?

आपका हिस्साहर बिक्री का 70% (सामान्य दर; हर vendor के साथ अलग तय हो सकती है)
ProxyMarket का हिस्सा30%, शॉप, भुगतान, सपोर्ट और रिफ़ंड के लिए
कब जुड़ता हैजैसे ही ग्राहक का भुगतान पूरा होता है और ऑर्डर active होता है, आपके /provision को कॉल होने से पहले
कहाँ देखेंआपके vendor डैशबोर्ड में Earnings: हर बिक्री उसकी रकम, आपकी रकम और इस्तेमाल हुई दर के साथ
PayoutsProxyMarket admin आपके बैलेंस से भुगतान करता है. पैसा निकालना हो तो Telegram पर कहें.
रिफ़ंडअपने आप होने वाला रिफ़ंड (120 सेकंड में कुछ नहीं पहुँचा) या admin रिफ़ंड आपकी कमाई बैलेंस से हटा देता है. promo code बिक्री की रकम घटाता है, और उसके साथ आपका हिस्सा भी.
पैसा निकालनाएक payout आपके बैलेंस तक का हो सकता है और आपकी सबसे पुरानी बिना भुगतान वाली कमाई को paid मार्क करता है.

दर हर बिक्री के साथ सेव होती है, इसलिए बाद में दर बदलने से पहले कमाए पैसे पर कोई असर नहीं पड़ता.

मेरे प्लान शॉप में कहाँ दिखते हैं?

Browse प्लान को सबसे सस्ते से शुरू करके लिस्ट करता है, एक नियम के साथ जो कीमत तय करने से पहले जान लें: XProxy सॉफ़्टवेयर चलाने वाले vendors के प्लान पहले आते हैं, Powered by xProxy के नीचे, xProxy बैज के साथ. आपके अपने connector के प्लान उसके बाद Other vendors के नीचे आते हैं, वे भी सबसे सस्ते से.

कहाँक्रम किससे तय होता है
Browse, डिफ़ॉल्टपहले XProxy समूह, फिर आपका, हर एक सबसे सस्ते से
Browse, जब ग्राहक क्रम बदलेक्रम हर समूह के अंदर लागू होता है, इसलिए आपका सस्ता प्लान भी XProxy समूह के नीचे ही रहता है
होमपेज के “from $X” कार्डहर कैटेगरी का सबसे सस्ता XProxy प्लान; आपका सिर्फ़ तब जब वहाँ XProxy का स्टॉक न हो
देश, प्रोटोकॉल और सर्च फ़िल्टर, आपका स्टोर पेजहर vendor के लिए बिल्कुल एक जैसा

जब लिस्ट में सब कुछ एक ही समूह का हो, तो Browse बिना शीर्षक की एक सीधी लिस्ट दिखाता है. ज़्यादातर ग्राहक देश या प्रोटोकॉल से फ़िल्टर करके आते हैं, और वहाँ आपके प्लान सबके प्लान के साथ होते हैं.

error codes का क्या मतलब है?

Codeमतलबक्या करें
401Invalid API key (ग़लत या बंद key), Missing API key (ख़ाली header) या Vendor inactiveX-API-Key header जाँचें और देखें कि डैशबोर्ड में key चालू है
403आपका vendor आवेदन अभी pending है (किसी भी call पर), या अकाउंट मंज़ूर vendor नहीं है (key बनाते समय)मंज़ूरी का इंतज़ार करें
404अनजान external_id या order_idID जाँचें; पहले प्लान sync करें
409ऐसे ऑर्डर को credentials पहुँचाना जो अब paid या active नहीं हैआम तौर पर 120 सेकंड बीत गए और ऑर्डर रिफ़ंड हो गया. दोबारा कोशिश न करें
422कोई value वैध नहीं है, या X-API-Key header है ही नहींजवाब में detail फ़ील्ड का नाम बताता है
500ProxyMarket errorबढ़ती देरी के साथ दोबारा कोशिश करें

Errors {"detail": "…"} के रूप में आते हैं. कोई प्रकाशित rate limit नहीं है; तंग loop में नहीं, बदलाव होने पर sync करें.

क्या कोई पूरा उदाहरण है?

हाँ. यह Python connector एक प्रॉक्सी प्लान sync करता है, हर 5 मिनट में हालत बताता है और चारों webhooks का जवाब देता है. ऊपर के दो functions को अपने सिस्टम की calls से बदलें, और एक टाइमर जोड़ें जो हर ऑर्डर का समय पूरा होने पर उसे ख़त्म करे.

python
"""Minimal ProxyMarket connector: sync plans, report health, answer the four webhooks."""
import hashlib
import hmac
import os
import secrets
import threading
import time

import requests
from flask import Flask, jsonify, request

API_KEY = os.environ["PROXYMARKET_API_KEY"]          # pm_... from "Create your API key"
MARKET = "https://market.xproxy.io/api/integration"
HEADERS = {"X-API-Key": API_KEY, "Content-Type": "application/json"}
SIGNING_KEY = hashlib.sha256(API_KEY.encode()).hexdigest()


# ── Your system (replace with your own code) ─────────────────────────
PORTS = {
    "port-1": {"name": "US Mobile 4G - Port 1", "country": "United States", "protocol": "HTTP",
               "price": 25.00, "days": 30, "online": True, "ip": "203.0.113.1", "port": 8080},
}

def add_proxy_login(port_id, username, password): ...   # create the customer's login
def remove_proxy_login(port_id, order_id): ...          # delete it again


# ── Calls you make ───────────────────────────────────────────────────
def sync_plans():
    plans = [{
        "external_id": pid, "name": p["name"], "proxy_type": "mobile", "protocol": p["protocol"],
        "country": p["country"], "duration_days": p["days"], "price_usd": p["price"],
        "stock": 1 if p["online"] else 0, "is_active": p["online"],
    } for pid, p in PORTS.items()]
    r = requests.post(f"{MARKET}/plans/sync", json=plans, headers=HEADERS, timeout=15)
    print("[sync]", r.status_code, r.json())


def set_stock(port_id, free):
    requests.patch(f"{MARKET}/plans/stock", headers=HEADERS, timeout=15,
                   json=[{"external_id": port_id, "stock": 1 if free else 0, "is_active": free}])


def health_reporter():
    while True:
        try:
            reports = [{"external_id": pid, "status": "online" if p["online"] else "offline",
                        "current_ip": p["ip"]} for pid, p in PORTS.items()]
            requests.post(f"{MARKET}/health", json=reports, headers=HEADERS, timeout=15)
        except requests.RequestException as e:
            print("[health]", e)
        time.sleep(300)  # every 5 minutes


# ── Webhooks ProxyMarket calls ───────────────────────────────────────
app = Flask(__name__)


def signed():
    expected = "sha256=" + hmac.new(SIGNING_KEY.encode(), request.get_data(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, request.headers.get("X-Signature", ""))


@app.route("/health", methods=["HEAD", "GET"])
def health():
    return "", 200


@app.route("/provision", methods=["POST"])
def provision():
    if not signed():
        return jsonify({"status": "error", "message": "Invalid signature"}), 401
    data = request.get_json()
    port = PORTS.get(data["external_plan_id"])
    if not port or not port["online"]:
        return jsonify({"status": "error", "message": "Port offline"})  # ProxyMarket refunds the customer
    username = f"cust_{data['order_id'][:8]}"
    password = secrets.token_urlsafe(16)
    add_proxy_login(data["external_plan_id"], username, password)
    set_stock(data["external_plan_id"], free=False)
    return jsonify({
        "status": "provisioned",
        "proxy_ip": port["ip"], "proxy_port": port["port"],
        "proxy_username": username, "proxy_password": password,
    })


@app.route("/deprovision", methods=["POST"])
def deprovision():
    if not signed():
        return jsonify({"status": "error", "message": "Invalid signature"}), 401
    data = request.get_json()
    remove_proxy_login(data["external_plan_id"], data["order_id"])  # must be safe to run twice
    set_stock(data["external_plan_id"], free=True)
    return jsonify({"status": "deprovisioned"})


@app.route("/update-settings", methods=["POST"])
def update_settings():
    if not signed():
        return jsonify({"status": "error", "message": "Invalid signature"}), 401
    data = request.get_json()
    # data["ip_whitelist"]: [] = allow everyone, None = leave as it is
    # data["tcp_fingerprint"]: "win1", "ios1", ... or None = no spoofing
    return jsonify({"status": "ok"})  # apply what you support, ignore the rest


if __name__ == "__main__":
    sync_plans()
    threading.Thread(target=health_reporter, daemon=True).start()
    # Serve this behind HTTPS at your webhook_url, for example https://your-vendor-host.com/marketplace
    app.run(host="0.0.0.0", port=9090)

पूरा API reference कहाँ है?

हर call और webhook, सभी फ़ील्ड, उदाहरण जवाब और curl, Python, Node.js और PHP में कोड के साथ, ProxyMarket API reference में है. OpenAPI 3.1 फ़ाइल market.openapi.yaml पर है.

दिशाEndpointयह क्या करता है
आप कॉल करते हैंPOST /api/vendor/integrationsअपनी API key बनाएँ
आप कॉल करते हैंPOST /plans/syncप्लान publish या अपडेट करें
आप कॉल करते हैंPATCH /plans/stockस्टॉक और दिखना बदलें
आप कॉल करते हैंDELETE /plans/{external_id}प्लान को बिक्री से हटाएँ
आप कॉल करते हैंPOST /healthअपनी प्रॉक्सी की हालत बताएँ
आप कॉल करते हैंPOST /orders/{order_id}/credentialsलॉगिन या config देर से पहुँचाएँ
आप कॉल करते हैंPOST /orders/{order_id}/expireऑर्डर को expired मार्क करें (रिफ़ंड नहीं)
हम आपको कॉल करते हैंHEAD /healthhealth check जो आपके प्लान लिस्ट में रखता है
हम आपको कॉल करते हैंPOST /provisionग्राहक ने भुगतान किया: पहुँचाएँ
हम आपको कॉल करते हैंPOST /deprovisionऑर्डर ख़त्म हुआ: एक्सेस हटाएँ
हम आपको कॉल करते हैंPOST /update-settingsनई IP whitelist या TCP fingerprint लागू करें
आप कॉल करते हैंGET /orders/activeआपकी key पर भेजे गए paid और active ऑर्डर

मैं कौन-से देश लिस्ट कर सकता हूँ?

कोई भी. देश का पूरा अंग्रेज़ी नाम भेजें, जैसे United States, Germany या Vietnam, और हर प्लान पर इसे एक जैसा लिखें: ग्राहक सटीक टेक्स्ट से फ़िल्टर करते हैं. ProxyMarket नाम नहीं जाँचता; गाइड और vendor डैशबोर्ड की लिस्ट वही spelling है जो इस्तेमाल करनी है. pm-connector test उस लिस्ट से बाहर का नाम अस्वीकार करता है.

version 1.13 में क्या बदला?

  • नई call: आपकी key पर भेजे गए ऑर्डर की लिस्ट (GET /orders/active, routed_plans और ETag के साथ), बंद रहने के बाद पिछला काम पूरा करने के लिए.
  • ज़्यादा सुरक्षित fallback: पहुँचाया गया लॉगिन अब प्लान पर कॉपी नहीं होता, और किसी दूसरे ऑर्डर का प्लान लॉगिन या रोटेशन लिंक कभी नहीं दिया जाता.
  • Provision का समय: /provision सिर्फ़ भुगतान पक्का होने के बाद भेजा जाता है, इसलिए तुरंत किया गया credential push स्वीकार होता है. /update-settings में हमेशा वही values होती हैं जो ग्राहक ने अभी सेव कीं.
  • ProxyMarket connector: एक तैयार webhook सर्वर, NAT के पीछे उस तक पहुँचने के तरीके सहित. connector देखें.
  • Encrypted provision जवाब (वैकल्पिक): सादे http:// webhook URL पर अपने /provision जवाब को X-PM-Encrypted: v1 से सील करें. ऊपर देखें.
  • Plan pinning: sync से बना प्लान उसी key पर जाता है जिसने उसे sync किया.
  • रोटेशन: ProxyMarket आपके rotation_link को GET से कॉल करता है. IP रोटेशन देखें.
  • vendor डैशबोर्ड में Integration Status टैब, और वैकल्पिक X-PM-Connector header.
  • कोड से मेल खाने के लिए लिखा गया: X-API-Key header के बिना 422, आवेदन pending रहते 403, 30 सेकंड का provision timeout, बिना जाँचा देश और sync पोर्ट, protocol का डिफ़ॉल्ट HTTP, current_ip के बिना /health रिपोर्ट उसे मिटा देती है, OpenVPN <ca> नियम, और /update-settings में external_plan_id नहीं.

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

मैं XProxy चलाता हूँ. क्या मुझे यह बनाना होगा?

नहीं. पैनल में ProxyMarket चालू करें (Selling Platform → ProxyMarket) और यह आपके लिए यह सब करता है, webhooks सहित. ProxyMarket पर बेचें देखें. तब आपके प्लान को xProxy बैज भी मिलता है.

मेरे सारे प्लान शॉप से क्यों ग़ायब हो गए?

लगभग हमेशा health check की वजह से: HEAD {webhook_url}/health लगातार दो बार फ़ेल हुआ (बंद, 5 सेकंड से धीमा, 5xx, या HEAD ब्लॉक). इसे ठीक करें और अगली सही जाँच के बाद, 10 मिनट के अंदर, प्लान वापस आ जाते हैं.

मेरी API key खो गई. क्या ProxyMarket इसे फिर भेज सकता है?

नहीं. सिर्फ़ hash सेव होता है. नई key बनाएँ, और याद रखें कि उसके साथ signing key भी बदल जाती है.

मेरी signature जाँच हमेशा फ़ेल होती है. क्यों?

आम तौर पर दो में से एक वजह: आपने HMAC secret के रूप में hex वाले SHA256(api_key) की जगह सीधी API key इस्तेमाल की, या आपने raw request body की जगह parse करके फिर से encode किया JSON sign किया.

अगर मेरा सर्वर नहीं पहुँचा पाता, तो क्या मुझे भुगतान मिलता है?

नहीं. अगर 120 सेकंड में कुछ इस्तेमाल लायक नहीं पहुँचता, तो ग्राहक को रिफ़ंड मिलता है और कमाई आपके बैलेंस से हट जाती है.

ग्राहक को पुराना लॉगिन क्यों मिला?

आपके /provision ने 200 के अलावा कोई status लौटाया, timeout हुआ या ग़लत JSON भेजा, इसलिए ProxyMarket ने वह लॉगिन दिया जो आपने प्लान पर sync किया था. पहुँचाया गया लॉगिन कभी प्लान पर सेव नहीं होता, और प्लान लॉगिन पहले से किसी दूसरे ऑर्डर का हो तो दोबारा इस्तेमाल नहीं होता (तब वह ऑर्डर रिफ़ंड होता है). हमेशा 200 लौटाएँ, और न पहुँचा सकें तो error के साथ.

क्या मैं कई सर्वर जोड़ सकता हूँ?

हाँ. हर सर्वर के लिए एक key बनाएँ, हर एक का अपना webhook URL. sync से बना प्लान उसी key पर जाता है जिसने उसे sync किया; पुराने प्लान के लिए डैशबोर्ड में API Key / Server सेट करें, नहीं तो उनके ऑर्डर आपकी सबसे पुरानी key पर जाते हैं.

जब ग्राहक रिन्यू करता है तो क्या होता है?

expired ऑर्डर को रिन्यू करना एक सामान्य नया ऑर्डर है. चल रहे ऑर्डर को रिन्यू करने पर पहले पुराने ऑर्डर के लिए reason: renewed के साथ /deprovision आता है, फिर नए के लिए नए order_id के साथ /provision.

आगे क्या?

पूरा reference खोलें, या Telegram पर ProxyMarket से पूछें.

अब भी अटके हैं?एक तकनीशियन वन-टाइम PIN से आपका डिवाइस देख सकता है, या Telegram पर हमसे चैट करें।