पॉलीमार्केट Perps API ट्रेडिंग बॉट: TypeScript और Python

पॉलीमार्केट बॉट ट्यूटोरियल · अध्याय 24 / 32

पॉलीमार्केट Perps का पूरा सार्वजनिक API है, साथ में आधिकारिक TypeScript और Python SDK भी हैं। इस अध्याय में असली इंटरफ़ेस पर एक बॉट बनाया गया है। इसमें प्रॉक्सी ट्रेडिंग की से ऑथेंटिकेशन, REST और WebSocket से मार्केट डेटा, टेक-प्रॉफ़िट और स्टॉप-लॉस वाले ऑर्डर, और वे रिस्क कंट्रोल शामिल हैं जो लीवरेज वाले बॉट को आपका अकाउंट खाली करने से रोकते हैं।

विज्ञापन यहाँ विज्ञापन दें

लेखक: हार्ले यंग, पॉलीमार्केट्स.co.il के मुख्य लेखक। आखिरी समीक्षा: नवंबर 2026।

इस अध्याय में क्या है

• बॉट बनाने वालों के लिए ज़रूरी आंकड़े
• Perps API कैसे बना है
• चरण 1: SDK इंस्टॉल करें और सेशन खोलें
• चरण 2: REST और WebSocket से मार्केट डेटा पढ़ें
• चरण 3: टेक-प्रॉफ़िट और स्टॉप-लॉस के साथ ऑर्डर लगाएँ
• चरण 4: कोड में रिस्क कंट्रोल वाला बॉट का ढाँचा
• एरर, डेड मैन्स स्विच, बॉट के नियम और होस्टिंग

यहाँ हर SDK मेथड और एंडपॉइंट पॉलीमार्केट के Perps डॉक्स (docs.polymarket.com/perps, 2026-11-06 को पढ़े गए) से लिया गया है। हमारा अपना लॉजिक कमेंट में चिह्नित है, और स्ट्रैटेजी फ़ंक्शन एक साफ़ तौर पर चिह्नित प्लेसहोल्डर है।

बॉट बनाने वालों के लिए ज़रूरी आंकड़े (नवंबर 2026 तक)

Perps API कैसे बना है

Perps एक हाइब्रिड एक्सचेंज है: मैचिंग ऑफ़चेन होती है, जबकि कस्टडी और सेटलमेंट Polygon पर होते हैं। सिर्फ़ डिपॉज़िट और निकासी ऑनचेन होते हैं, इसलिए हर ऑर्डर पर गैस नहीं लगती। API की तीन परतें हैं:

• सार्वजनिक डेटा (/v1/info/): इंस्ट्रूमेंट, टिकर, ऑर्डर बुक, कैंडल, ट्रेड, फंडिंग, शुल्क। कोई की ज़रूरी नहीं और कोई भौगोलिक ब्लॉक नहीं।
• निजी रीड (/v1/account/): पोर्टफोलियो, बैलेंस, ऑर्डर, फ़िल, कॉन्फ़िग।
• साइन किए गए राइट (/v1/trade/): ऑर्डर, कैंसल, लीवरेज, आइसोलेटेड मार्जिन, ऑटो-कैंसल। हर राइट MessagePack में एन्कोड होता है, keccak256 से हैश होता है और प्रॉक्सी की उसे EIP-712 टाइप्ड डेटा के रूप में साइन करती है।

साइनिंग का काम SDK आपके लिए कर देते हैं। इसके अलावा एक OpenAPI स्पेक (डॉक्स साइट पर /api-spec/perps-openapi.json) और WebSocket के लिए एक AsyncAPI स्पेक भी है।

चरण 1: SDK इंस्टॉल करें और सेशन खोलें

pip install polymarket-client या npm install @polymarket/client@latest viem से इंस्टॉल करें। बॉट को आपके पॉलीमार्केट वॉलेट का पता और उस साइनर की प्राइवेट की चाहिए जिसके नाम Perps अकाउंट है (अकाउंट साइनर EOA से जुड़ा है, Safe से नहीं)। सेशन खोलते समय एक बार साइन करके एक नई प्रॉक्सी ट्रेडिंग की को अधिकृत किया जाता है, जो फिर हर ऑर्डर साइन करती है, यानी आपकी फंड वाली की कभी ट्रेड नहीं करती। बाद में सेशन दोबारा शुरू करने के लिए session.credentials को एन्क्रिप्ट करके सेव करें।

import asyncio
import os
from datetime import timedelta

from polymarket import AsyncSecureClient


async def main():
    client = await AsyncSecureClient.create(
        private_key=os.environ["PRIVATE_KEY"],
        wallet=os.environ["POLYMARKET_WALLET_ADDRESS"],
    )
    # One signature creates a proxy trading key. Orders are signed by the proxy,
    # not by your wallet key. Credentials expire after one week by default.
    session = await client.open_perps_session(
        expires_in=timedelta(days=1),
        label="perps-bot",
    )
    stored = session.credentials.model_dump(mode="json")  # keep it encrypted

    instruments = await client.fetch_perps_instruments()
    btc = next(i for i in instruments if i.symbol == "BTC-USD")
    print(btc.id, btc.max_leverage, btc.min_notional, btc.price_decimals)


asyncio.run(main())

import { createSecureClient } from "@polymarket/client";
import { privateKey } from "@polymarket/client/viem";

const client = await createSecureClient({
  wallet: process.env.POLYMARKET_WALLET_ADDRESS!,
  signer: privateKey(process.env.PRIVATE_KEY!),
});

// One signature creates a proxy trading key. Orders are signed by the proxy,
// not by your wallet key. Credentials expire after one week by default.
const session = await client.openPerpsSession({
  expiresIn: 24 * 60 * 60 * 1000,
  label: "perps-bot",
});
const stored = session.credentials; // keep it encrypted

const instruments = await client.fetchPerpsInstruments();
const btc = instruments.find((i) => i.symbol === "BTC-USD");
if (!btc) throw new Error("BTC-USD not listed");
console.log(btc.id, btc.maxLeverage, btc.minNotional, btc.priceDecimals);

कोड से डिपॉज़िट करने (deposit_to_perps / depositToPerps) के लिए polymarket.com की Settings, API Keys से एक Relayer API की भी चाहिए। ज़्यादा आसान और सुरक्षित तरीका: अकाउंट में पैसा वेब ऐप से डालें और बॉट को पैसे के लेन-देन से दूर रखें। 2026-11-05 से, जिन अकाउंट में निकासी एड्रेस बुक है, वे सिर्फ़ सेव किए गए पतों पर ही निकासी कर सकते हैं। डैशबोर्ड के लिए रीड-ओनली की इस्तेमाल करें (read-only: लेबल वाली प्रॉक्सी, जो साइन किए गए राइट मना कर देती है), ट्रेडिंग की कभी नहीं। की को सुरक्षित रखने का तरीका हमारे वॉलेट और ऑथेंटिकेशन अध्याय में है।

चरण 2: REST और WebSocket से मार्केट डेटा पढ़ें

टिकर में तीन कीमतें होती हैं: इंडेक्स (Pyth, Chainlink Data Streams और Hyperliquid जैसे फ़ीड से निकाली गई उचित कीमत), मार्क (लाभ/हानि, मार्जिन, लिक्विडेशन और TP/SL के लिए इस्तेमाल होती है) और लास्ट (सिर्फ़ एक्ज़ीक्यूशन की कीमत), साथ में फंडिंग रेट और अगली फंडिंग का समय। अपने सिग्नल मार्क या इंडेक्स पर आधारित रखें।

# Inside your async main(), after Step 1 (btc is the BTC-USD instrument)
from polymarket import AsyncPublicClient
from polymarket.streams import PerpsBboSpec

client = AsyncPublicClient()

ticker = await client.fetch_perps_ticker(instrument_id=btc.id)
print(ticker.mark_price, ticker.index_price, ticker.funding_rate)

stream = await client.subscribe(PerpsBboSpec(instrument_id=btc.id))
async for event in stream:
    print(event.payload.bid_price, event.payload.ask_price)

// After Step 1 (btc is the BTC-USD instrument)
import { createPublicClient } from "@polymarket/client";

const client = createPublicClient();

const ticker = await client.fetchPerpsTicker({ instrumentId: btc.id });
console.log(ticker.markPrice, ticker.indexPrice, ticker.fundingRate);

const stream = await client.subscribe([{ topic: "perps.bbo", instrumentId: btc.id }]);
for await (const event of stream) {
  console.log(event.payload.bidPrice, event.payload.askPrice);
}

SDK के बिना, सीधे WebSocket पर {"id": 1, "req": "sub", "chs": ["bbo::6"]} से सब्सक्राइब करें। चैनलों में bbo::<id>, book::<id>, trades::<id>, tickers::<id> और klines::<id>::1m शामिल हैं। हर अपडेट में एक सीक्वेंस नंबर sq होता है: कोई अपडेट छूटने या दोबारा कनेक्ट होने के बाद, स्टेट REST से फिर से पढ़ें। बैकटेस्ट के लिए list_perps_candles / listPerpsCandles इतिहास को पेज के हिसाब से लाता है (REST एंडपॉइंट एक कॉल में अधिकतम 1,000 कैंडल लौटाता है)।

चरण 3: टेक-प्रॉफ़िट और स्टॉप-लॉस के साथ ऑर्डर लगाएँ

हर ऑर्डर में एक side (BUY या SELL), बेस एसेट की इकाइयों में एक quantity, pUSD में एक वैकल्पिक price, और एक टाइम इन फ़ोर्स (gtc, ioc या fok) होता है। Post-only के लिए GTC ज़रूरी है; reduce-only सिर्फ़ पोजीशन को छोटा कर सकता है। लॉन्ग या शॉर्ट का कोई अलग फ़्लैग नहीं है: अगर कोई पोजीशन नहीं है, तो BUY लॉन्ग खोलता है और SELL शॉर्ट खोलता है।

ब्रैकेट ऑर्डर एंट्री के साथ एक टेक-प्रॉफ़िट और एक स्टॉप-लॉस जोड़ देता है। ये तब तक निष्क्रिय रहते हैं जब तक एंट्री पूरी तरह भर न जाए, और अगर एंट्री कैंसल हो जाए या सिर्फ़ आंशिक रूप से भरे, तो ये भी कैंसल हो जाते हैं। नीचे दी गई कीमतें काल्पनिक हैं।

# Inside your async main(), after Step 1 (btc is the BTC-USD instrument)
from polymarket import PerpsTpSlTrigger

result = await session.place_order(
    instrument_id=btc.id,
    side="BUY",
    price="100000",
    quantity="0.01",
    time_in_force="gtc",
    take_profit=PerpsTpSlTrigger(trigger_price="104000"),
    stop_loss=PerpsTpSlTrigger(trigger_price="98000"),
)
print(result.order.id, result.order.status)

// After Step 1 (btc is the BTC-USD instrument)
import { OrderSide, PerpsTimeInForce } from "@polymarket/client";

const result = await session.placeOrder({
  instrumentId: btc.id,
  side: OrderSide.BUY,
  price: "100000",
  quantity: "0.01",
  timeInForce: PerpsTimeInForce.GTC,
  takeProfit: { triggerPrice: "104000" },
  stopLoss: { triggerPrice: "98000" },
});
console.log(result.order.id, result.tpSl.stopLoss?.orderId);

खुली पोजीशन के लिए place_position_tp_sl / placePositionTpSl ऐसे ट्रिगर जोड़ता है जो पूरी पोजीशन बंद कर देते हैं। नियम:

• ट्रिगर मार्क प्राइस पर नज़र रखते हैं और reduce-only ऑर्डर भेजते हैं। पोजीशन TP/SL मार्केट कीमत पर निकलता है, इसलिए कम लिक्विडिटी वाली ऑर्डर बुक में स्लिपेज की उम्मीद रखें।
• हर मार्केट में एक पोजीशन टेक-प्रॉफ़िट और एक स्टॉप-लॉस। स्टॉप को खिसकाने का मतलब है पहले कैंसल करना, फिर नया बनाना, और यह एक साथ (atomic) नहीं होता।
• जिस ट्रिगर को मार्क पहले ही पार कर चुका है, वह रिजेक्ट हो जाता है, और मार्क से बहुत दूर की लिमिट कीमतें भी मना कर दी जाती हैं।

ऑटोमेट करने से पहले ऑर्डर का पूरा फ़्लो हाथ से आज़माने के लिए पॉलीमार्केट Perps पर BTC मार्केट खोलें और सबसे छोटा अनुमत ऑर्डर लगाएँ। फ़िल, शुल्क और पोजीशन पैनल अपनी आँखों से देख लेने के बाद API के जवाब पढ़ना आसान हो जाता है।

चरण 4: कोड में रिस्क कंट्रोल वाला बॉट का ढाँचा

नीचे दिया गया Python ढाँचा सिर्फ़ डॉक्यूमेंटेड SDK कॉल इस्तेमाल करता है; रिस्क का लॉजिक हमारा है। सुरक्षा की तीन परतें:

1. लीवरेज की सीमा। लीवरेज 3x या मार्केट के अधिकतम में से जो कम हो, उस पर सेट होता है, आइसोलेटेड मार्जिन के साथ। जो साइज़ कम सीमा वाले रिस्क टियर में आते हैं, उन्हें मना कर दिया जाता है।
2. किल स्विच। एक HALT फ़ाइल, 5% की दैनिक नुकसान सीमा और लिक्विडेशन होने पर बाहर निकलना। स्विच reduce-only IOC ऑर्डर से पोजीशन बंद करता है, बचे हुए ऑर्डर कैंसल करता है, फिर जाँचता है कि दोनों खत्म हो गए हैं।
3. हर पोजीशन पर स्टॉप। Fill-or-kill एंट्री का मतलब है कि बिना सुरक्षा वाले आंशिक फ़िल नहीं होंगे। हर फ़िल के बाद पोजीशन स्टॉप और टेक-प्रॉफ़िट लगाया जाता है; अगर वे रिजेक्ट हो जाएँ, तो पोजीशन तुरंत बंद कर दी जाती है।

import asyncio
import logging
import os
from datetime import timedelta
from decimal import Decimal, ROUND_DOWN

from polymarket import AsyncSecureClient, PerpsPositionTpSlTrigger

SYMBOL = "BTC-USD"                   # live API symbol; docs examples say "BTC-PERP"
LEVERAGE_CAP = 3                     # our cap, far below the 50x BTC allows
RISK_PER_TRADE = Decimal("20")       # pUSD we accept losing if the stop fills
STOP_PCT = Decimal("0.02")           # stop 2% from entry
TAKE_PCT = Decimal("0.04")           # take profit 4% from entry
MAX_NOTIONAL = Decimal("2000")       # hard cap per position, in pUSD
MAX_SLIPPAGE = Decimal("0.002")      # worst entry price: ask + 0.2%
MAX_FUNDING = Decimal("0.0005")      # skip longs if funding > 0.05% per hour
DAILY_LOSS_LIMIT = Decimal("0.05")   # kill switch at -5% of start equity
HALT_FILE = "/opt/perps-bot/HALT"    # touch this file to stop the bot


def fit(value: Decimal, decimals: int, sig: int = 5) -> str:
    """Round down to the market's decimals and to 5 significant figures."""
    v = value.quantize(Decimal(1).scaleb(-decimals), rounding=ROUND_DOWN)
    if v != 0:
        step = Decimal(1).scaleb(v.adjusted() - sig + 1)
        if step > Decimal(1).scaleb(-decimals):
            v = v.quantize(step, rounding=ROUND_DOWN)
    return format(v, "f")


def tier_cap(inst, notional: Decimal) -> int:
    """Max leverage allowed for this notional by the market's risk tiers."""
    cap = inst.max_leverage
    for tier in inst.risk_tiers:
        if notional >= Decimal(tier.lower_bound):
            cap = tier.max_leverage
    return cap


async def close_all(session):
    """Close every position with reduce-only IOC orders, then cancel the rest."""
    portfolio = await session.fetch_portfolio()
    for pos in portfolio.positions:
        if pos.size != 0:
            await session.place_order(
                instrument_id=pos.instrument_id,
                side="SELL" if pos.size > 0 else "BUY",
                quantity=abs(pos.size),
                time_in_force="ioc",
                reduce_only=True,
            )
    await session.cancel_all_orders()


async def kill_switch(session, reason: str):
    logging.error("KILL SWITCH: %s", reason)
    for attempt in range(3):
        await close_all(session)
        portfolio = await session.fetch_portfolio()
        open_orders = await session.fetch_open_orders()
        if not open_orders and all(p.size == 0 for p in portfolio.positions):
            return
        await asyncio.sleep(2)
    logging.critical("Positions still open after kill switch: act manually")


async def open_long(client, session, inst):
    ticker = await client.fetch_perps_ticker(instrument_id=inst.id)
    if Decimal(ticker.funding_rate) > MAX_FUNDING:
        return                                     # longs would pay too much
    book = await client.fetch_perps_book(instrument_id=inst.id, depth=10)
    if not book.asks:
        return
    ask = Decimal(book.asks[0].price)
    stop = ask * (1 - STOP_PCT)
    qty = RISK_PER_TRADE / (ask - stop)            # size from the stop, not leverage
    qty = min(qty, MAX_NOTIONAL / ask)
    notional = qty * ask
    if notional < Decimal(inst.min_notional):
        return
    if tier_cap(inst, notional) < LEVERAGE_CAP:
        return                                     # size would break our cap

    entry = await session.place_order(
        instrument_id=inst.id,
        side="BUY",
        price=fit(ask * (1 + MAX_SLIPPAGE), inst.price_decimals),
        quantity=fit(qty, inst.quantity_decimals),
        time_in_force="fok",                       # all or nothing
    )
    if entry.order.status != "filled":
        return

    try:                                           # stop on the whole position
        await session.place_position_tp_sl(
            instrument_id=inst.id,
            take_profit=PerpsPositionTpSlTrigger(
                trigger_price=fit(ask * (1 + TAKE_PCT), inst.price_decimals)),
            stop_loss=PerpsPositionTpSlTrigger(
                trigger_price=fit(stop, inst.price_decimals)),
        )
    except Exception:
        logging.exception("TP/SL rejected: closing the unprotected position")
        await close_all(session)


async def my_signal(client, inst) -> bool:
    """PLACEHOLDER: your strategy goes here. Not part of the SDK."""
    return False


async def main():
    logging.basicConfig(level=logging.INFO)
    client = await AsyncSecureClient.create(
        private_key=os.environ["PRIVATE_KEY"],
        wallet=os.environ["POLYMARKET_WALLET_ADDRESS"],
    )
    session = await client.open_perps_session(
        expires_in=timedelta(days=1), label="perps-bot")
    inst = next(i for i in await client.fetch_perps_instruments()
                if i.symbol == SYMBOL)

    # Control 1: leverage cap and isolated margin, set before any order
    await session.update_leverage(
        instrument_id=inst.id,
        leverage=min(LEVERAGE_CAP, inst.max_leverage),
        cross_margin=False,
    )

    # Field names below follow the documented portfolio JSON
    # (margin.total_account_value, in_liquidation). Check them in your SDK.
    start_equity = Decimal((await session.fetch_portfolio()).margin.total_account_value)

    while True:
        portfolio = await session.fetch_portfolio()
        equity = Decimal(portfolio.margin.total_account_value)

        # Control 2: kill switches
        if os.path.exists(HALT_FILE):
            await kill_switch(session, "HALT file found")
            break
        if equity < start_equity * (1 - DAILY_LOSS_LIMIT):
            await kill_switch(session, f"daily loss limit hit: {equity}")
            break
        if portfolio.in_liquidation:
            await kill_switch(session, "account in liquidation")
            break

        in_position = any(p.instrument_id == inst.id and p.size != 0
                          for p in portfolio.positions)
        if not in_position and await my_signal(client, inst):
            await open_long(client, session, inst)   # Control 3 lives here

        await asyncio.sleep(5)


asyncio.run(main())

साइज़ का हिसाब। साइज़ स्टॉप की दूरी से तय होता है, लीवरेज से नहीं। मान लीजिए BTC का आस्क 100,000 pUSD है और स्टॉप 2% पर है, तो स्टॉप 98,000 पर होगा। प्रति यूनिट रिस्क 2,000 है, इसलिए मात्रा 20 / 2,000 = 0.01 BTC होगी, यानी 1,000 pUSD का नोशनल। 3x पर इसके लिए लगभग 333 pUSD मार्जिन चाहिए। BTC का मेंटेनेंस मार्जिन रेट 1% (0.5 / 50x) है, इसलिए लॉन्ग का लिक्विडेशन प्राइस 100,000 x (1 - 1/3) / (1 - 0.01) = लगभग 67,340 है, यानी 32.7% की गिरावट। -2% वाला स्टॉप उससे बहुत पहले चल जाता है। अगर स्टॉप अपने ट्रिगर पर भरता है, तो नुकसान 20 pUSD और शुल्क होगा: 0.040% टेकर रेट पर खोलने के 0.40 और बंद करने के लगभग 0.39, यानी स्लिपेज से पहले कुल लगभग 20.79 pUSD। लीवरेज सिर्फ़ यह तय करता है कि कितना मार्जिन फँसा रहेगा। स्टॉप पर होने वाले नुकसान को यह नहीं बदलता।

लाइव जाने से पहले एक दैनिक ट्रेड सीमा, फ़िल और किल स्विच पर अलर्ट, और स्टार्टअप पर मिलान (fetch_portfolio, fetch_open_orders, fetch_orders, list_fills) जोड़ें। हमारे रिस्क कोड और पेपर ट्रेडिंग अध्याय, Perps लीवरेज और लिक्विडेशन गाइड और Perps फंडिंग रेट गाइड देखें।

एरर, दोबारा कोशिश और डेड मैन्स स्विच

• 503 service_unavailable इस बात का सबूत नहीं है कि रिक्वेस्ट फ़ेल हुई। रीड और लीवरेज बदलाव को बैकऑफ़ के साथ दोबारा आज़माएँ और Retry-After का पालन करें। साइन किए गए बैलेंस बदलावों (मार्जिन, निकासी) के लिए सिर्फ़ वही मूल साइन की हुई रिक्वेस्ट दोबारा भेजें; नया सिग्नेचर एक दूसरा बदलाव माना जाएगा।
• signature expired: 5 मिनट से पुराना। सिस्टम की घड़ी सिंक रखें।
• insufficient_margin / invalid_leverage: जाँच में आपकी पोजीशन और सभी पेंडिंग ऑर्डर गिने जाते हैं।
• message_rate_limited: WebSocket की सीमा खत्म हो गई। रीड-ओनली की को प्रति IP प्रति मिनट 1,000 मैसेज (बर्स्ट 50) और प्रति गेटवे प्रति अकाउंट चार कनेक्शन मिलते हैं; बाकी के लिए डॉक्स का Rate Limits पेज देखें।
• फ़ॉर्मेट एरर: बहुत ज़्यादा दशमलव स्थान या 5 से ज़्यादा सार्थक अंक। इसीलिए fit() है।

अगर आपका बॉट ऑटो-कैंसल को दोबारा आर्म करना बंद कर दे, तो यह हर खुला ऑर्डर कैंसल कर देता है। डेडलाइन कम से कम 5 सेकंड आगे होनी चाहिए, और हर UTC दिन में ट्रिगर की संख्या सीमित है, इसलिए सामान्य शटडाउन पर इसे डिसआर्म करें।

// For quoting bots: cancel all resting orders if this process dies
await session.armAutoCancel({ cancelAt: Date.now() + 60_000 });
const rearm = setInterval(() => {
  // A missed re-arm is fail-safe: the armed switch still fires.
  session.armAutoCancel({ cancelAt: Date.now() + 60_000 }).catch(console.error);
}, 20_000);

// On a clean shutdown
clearInterval(rearm);
await session.disarmAutoCancel();

प्रतियोगिताएँ, बिल्डर कोड और बॉट के नियम

डॉक्स में API के इस्तेमाल के तौर पर "मार्केट सिग्नल पर प्रतिक्रिया देने वाले ट्रेडिंग बॉट" और मार्केट मेकर का ज़िक्र है। दो तरह के नियम लागू होते हैं।

• प्रतियोगिताएँ। वॉश ट्रेडिंग, सेल्फ़-ट्रेडिंग, एक से ज़्यादा अकाउंट, मुख्य रूप से वॉल्यूम के लिए ट्रेडिंग और "प्रोग्राम में हेरफेर के इरादे से बनाए गए बॉट, स्क्रिप्ट या ऑटोमेटेड तरीके" प्रतिबंधित हैं। असल में ट्रेड करने वाला बॉट ठीक है; सिर्फ़ वॉल्यूम बढ़ाने वाले बॉट को अयोग्य ठहराया जा सकता है।
• बिल्डर कोड। दूसरे यूज़र्स के लिए ट्रेड करने वाला ऐप हर ट्रेडर की मंज़ूरी से 10 बेसिस पॉइंट तक का शुल्क जोड़ सकता है। उसे हर यूज़र की लोकेशन जाँचनी होगी और प्रतिबंधित क्षेत्रों से आने वाले ऑर्डर ब्लॉक करने होंगे, सिर्फ़ चेतावनी देना काफ़ी नहीं।

मेकर लिक्विडिटी रिवॉर्ड और प्रतियोगिताओं की जानकारी पॉलीमार्केट Perps गाइड में है।

बॉट की होस्टिंग

लीवरेज वाला बॉट लैपटॉप पर नहीं चलना चाहिए। उसे अपना WebSocket चालू रखना होता है, सेकंडों में फ़िल पर प्रतिक्रिया देनी होती है और घर का इंटरनेट जाने पर भी चलते रहना होता है। इसे VPS पर systemd के तहत ऑटोमैटिक रीस्टार्ट के साथ चलाएँ, की को ऐसी एनवायरनमेंट फ़ाइल में रखें जिसे सिर्फ़ बॉट का यूज़र पढ़ सके, और घड़ी सिंक रखें। प्रतिबंधित जगहों से ऑर्डर लगाने की अनुमति नहीं है, इसलिए अमेरिका या कनाडा में होस्ट न करें, और अपने ऊपर लागू ब्लॉक से बचने के लिए कभी VPS का इस्तेमाल न करें। हम अपने बॉट TradingVPS पर चलाते हैं (एफ़िलिएट लिंक: हमें छोटा कमीशन मिलता है और आपकी कीमत वही रहती है)। हमारा VPS होस्टिंग अध्याय लेटेंसी, कीमत और रीजन के आधार पर इसकी तुलना दूसरे प्रोवाइडर से करता है।

पेपर ट्रेडिंग के बाद पॉलीमार्केट Perps पेज से अकाउंट में थोड़ी रकम डालें और साइज़ बढ़ाने से पहले एक हफ़्ते तक न्यूनतम साइज़ पर चलाएँ।

मुख्य बातें

• आधिकारिक SDK, @polymarket/client या polymarket-client इस्तेमाल करें। आपका वॉलेट एक बार साइन करता है; ऑर्डर एक प्रॉक्सी की साइन करती है।
• मार्केट का मिलान लाइव सिंबल (BTC-USD, न कि BTC-PERP) से करें और संख्या वाला ID सेव करें।
• साइज़ स्टॉप की दूरी से तय करें, कोड में लीवरेज की सीमा रखें, आइसोलेटेड मार्जिन इस्तेमाल करें, और फ़िल होते ही हर पोजीशन पर स्टॉप लगाएँ।
• TP/SL मार्क पर ट्रिगर होता है और मार्केट कीमत पर निकलता है। ऑटो-कैंसल स्टॉप हटा सकता है।
• बॉट की अनुमति है, प्रतियोगिताओं में हेरफेर की नहीं। किसी प्रतिबंधित देश से कभी ट्रेड न करें।

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