Polymarket Bot Tutorial · Kapitel 24 von 32

Polymarket Perps bietet eine vollständige öffentliche API mit offiziellen SDKs für TypeScript und Python. In diesem Kapitel bauen wir einen Bot auf der echten Schnittstelle: Authentifizierung mit einem Proxy-Trading-Key, Marktdaten über REST und WebSocket, Orders mit Take-Profit und Stop-Loss sowie die Risikokontrollen, die verhindern, dass ein Bot mit Hebel das Konto leert.

Build your own theme park, free in your browserAnzeige Hier werben
Bevor Sie loslegen. Das Platzieren von Perps-Orders ist aus den USA, Kanada, Kuba, dem Iran, Nordkorea, Syrien, der Krim, Donezk oder Luhansk nicht erlaubt, und polymarket.com sperrt weitere Länder. Ein Bot oder ein ausländischer Server ändert daran nichts. Mit Hebel kostet ein Bug schnell Geld, testen Sie daher mit minimaler Größe. Neu bei Perps? Beginnen Sie mit dem Polymarket-Perps-Leitfaden.

Was dieses Kapitel behandelt

  • Zentrale Kennzahlen für Bot-Entwickler
  • Wie die Perps-API aufgebaut ist
  • Schritt 1: SDK installieren und eine Session öffnen
  • Schritt 2: Marktdaten über REST und WebSocket lesen
  • Schritt 3: Orders mit Take-Profit und Stop-Loss platzieren
  • Schritt 4: ein Bot-Gerüst mit Risikokontrollen im Code
  • Fehler, der Totmannschalter, Regeln für Bots und Hosting

Jede SDK-Methode und jeder Endpunkt in diesem Kapitel stammt aus der Perps-Dokumentation von Polymarket (docs.polymarket.com/perps, gelesen am 6. November 2026). Unsere eigene Logik ist in den Kommentaren gekennzeichnet, und die Strategiefunktion ist ein ausdrücklich markierter Platzhalter.

Zentrale Kennzahlen für Bot-Entwickler (Stand: November 2026)

PunktWert
REST-Basis-URLhttps://api.perpetuals.polymarket.com
WebSocketwss://ws.perpetuals.polymarket.com/v1/ws
TypeScript-SDK@polymarket/client (mit viem zum Signieren)
Python-SDKpolymarket-client (asynchron)
Öffentliche Daten/v1/info/*, ohne Authentifizierung
Private Abfragen/v1/account/* mit den Headern polymarket-proxy und polymarket-secret
Signierte Schreibvorgänge/v1/trade/*, EIP-712-Signatur durch den Proxy-Key, 5 Minuten gültig
Session-ZugangsdatenLaufen standardmäßig nach einer Woche ab
Mindestorder10 $ Nominalwert; Mindesteinzahlung 10 pUSD
Größte Market-Order1 Mio. $ auf den 50x- und 20x-Märkten, 500.000 $ auf den meisten anderen, 50.000 $ bei 3x- und 5x-Coins
Format für Preis und GrößeDezimal-Strings, höchstens so viele Nachkommastellen, wie der Markt vorgibt, und höchstens 5 signifikante Stellen
Maximaler Hebel50x (BTC, ETH, USA500, US100), sonst je nach Markt 20x, 10x, 5x oder 3x, niedriger bei großen Positionen
Gebühren (Basisstufe)Taker 0,040 %, Maker 0,0125 %; ANT zum halben Preis
FundingStündlich, begrenzt auf +/-4 % pro Stunde
TP/SL-AuslöserMark-Preis, nicht der letzte Trade
WebSocket-KeepalivePing etwa alle 25 Sekunden; nach etwa 65 Sekunden Stille als veraltet behandeln
Aktualität des TickersBis zu 10 Sekunden alt

Wie die Perps-API aufgebaut ist

Perps ist eine hybride Börse: Das Matching läuft offchain, Verwahrung und Abwicklung erfolgen auf Polygon. Nur Einzahlungen und Auszahlungen laufen onchain, daher fällt pro Order kein Gas an. Die API hat drei Ebenen:

  • Öffentliche Daten (/v1/info/): Instrumente, Ticker, Orderbuch, Kerzen, Trades, Funding, Gebühren. Kein Key nötig und keine geografische Sperre.
  • Private Abfragen (/v1/account/): Portfolio, Guthaben, Orders, Ausführungen, Konfiguration.
  • Signierte Schreibvorgänge (/v1/trade/): Orders, Stornierungen, Hebel, isolierte Margin, Auto-Cancel. Jeder Schreibvorgang wird mit MessagePack kodiert, mit keccak256 gehasht und vom Proxy-Key als EIP-712-Typed-Data signiert.

Das Signieren übernehmen die SDKs für Sie. Außerdem gibt es eine OpenAPI-Spezifikation (/api-spec/perps-openapi.json auf der Doku-Website) und eine AsyncAPI-Spezifikation für den WebSocket.

Die Symbole weichen von den Beispielen in der Doku ab. Die Doku zeigt BTC-PERP. Die Live-API liefert BTC-USD, SP500-USD (USA500), NAS100-USD (US100), ANT-USD und so weiter. Rufen Sie die Instrumentenliste ab, gleichen Sie das Live-symbol ab und speichern Sie die numerische id. Kopieren Sie keine IDs aus Beispielen: Live hat BTC die 6 und SP500 die 1.

Schritt 1: SDK installieren und eine Session öffnen

Installieren Sie mit pip install polymarket-client oder npm install @polymarket/client@latest viem. Der Bot braucht Ihre Polymarket-Wallet-Adresse und den Private Key des Signers, dem das Perps-Konto gehört (das Konto ist an den Signer-EOA gebunden, nicht an den Safe). Beim Öffnen einer Session wird einmal signiert, um einen neuen Proxy-Trading-Key zu autorisieren, der danach jede Order signiert. Der Key, der Ihre Mittel hält, handelt also nie. Speichern Sie session.credentials verschlüsselt, um die Session später fortzusetzen.

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

Einzahlungen per Code (deposit_to_perps / depositToPerps) benötigen zusätzlich einen Relayer-API-Key aus den Einstellungen von polymarket.com unter API Keys. Einfacher und sicherer ist es, das Konto in der Web-App aufzuladen und den Bot von Geldbewegungen fernzuhalten. Seit dem 5. November 2026 können Konten mit Auszahlungs-Adressbuch nur noch an gespeicherte Adressen auszahlen. Für Dashboards verwenden Sie einen Read-only-Key (einen Proxy mit dem Label read-only:, der signierte Schreibvorgänge ablehnt), niemals den Trading-Key. Die sichere Aufbewahrung von Keys behandeln wir im Kapitel zu Wallets und Authentifizierung.

Schritt 2: Marktdaten über REST und WebSocket lesen

Der Ticker enthält drei Preise: Index (fairer Wert aus Feeds wie Pyth, Chainlink Data Streams und Hyperliquid), Mark (maßgeblich für PnL, Margin, Liquidation und TP/SL) und Last (nur der letzte Ausführungspreis), dazu die Funding-Rate und den nächsten Funding-Zeitpunkt. Stützen Sie Signale auf Mark-Preis oder Index.

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

Ohne SDK abonnieren Sie auf dem rohen WebSocket mit {"id": 1, "req": "sub", "chs": ["bbo::6"]}. Zu den Kanälen gehören bbo::<id>, book::<id>, trades::<id>, tickers::<id> und klines::<id>::1m. Jedes Update trägt eine Sequenznummer sq: Lesen Sie nach einer Lücke oder einem Reconnect den Zustand über REST neu ein. Für Backtests paginiert list_perps_candles / listPerpsCandles die Historie (der REST-Endpunkt liefert bis zu 1.000 Kerzen pro Aufruf).

Schritt 3: Orders mit Take-Profit und Stop-Loss platzieren

Eine Order hat eine side (BUY oder SELL), eine quantity in Einheiten des Basiswerts, einen optionalen price in pUSD und eine Gültigkeitsdauer (gtc, ioc oder fok). Post-only erfordert GTC; Reduce-only kann eine Position nur verkleinern. Ein Long- oder Short-Flag gibt es nicht: Ohne bestehende Position eröffnet BUY ein Long und SELL ein Short.

Eine Bracket-Order hängt einen Take-Profit und einen Stop-Loss an den Einstieg. Beide bleiben inaktiv, bis der Einstieg vollständig ausgeführt ist, und werden storniert, wenn der Einstieg storniert oder nur teilweise ausgeführt wird. Die Preise unten sind hypothetisch.

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

Für eine offene Position fügt place_position_tp_sl / placePositionTpSl Auslöser hinzu, die die gesamte Position schließen. Dabei gilt:

  • Auslöser beobachten den Mark-Preis und senden eine Reduce-only-Order. Positions-TP/SL steigt zum Marktpreis aus, rechnen Sie in dünnen Orderbüchern also mit Slippage.
  • Pro Markt ein Take-Profit und ein Stop-Loss für die Position. Einen Stop zu verschieben heißt stornieren und neu anlegen, und das geschieht nicht atomar.
  • Ein Auslöser, den der Mark-Preis bereits überschritten hat, wird abgelehnt, ebenso Limit-Preise, die zu weit vom Mark-Preis entfernt liegen.

Um den Order-Ablauf vor der Automatisierung von Hand auszuprobieren, öffnen Sie den BTC-Markt auf Polymarket Perps und platzieren Sie die kleinste erlaubte Order. Wer Ausführungen, Gebühren und das Positions-Panel einmal gesehen hat, liest die API-Antworten deutlich leichter.

Schritt 4: ein Bot-Gerüst mit Risikokontrollen im Code

Das Python-Gerüst unten verwendet ausschließlich dokumentierte SDK-Aufrufe; die Risikologik stammt von uns. Drei Schutzebenen:

  1. Hebel-Obergrenze. Der Hebel wird auf 3x oder das Marktmaximum gesetzt, je nachdem, was niedriger ist, und zwar mit isolierter Margin. Größen, die in eine Risikostufe mit niedrigerer Obergrenze fallen, werden abgelehnt.
  2. Notschalter (Kill Switches). Eine HALT-Datei, ein Tagesverlustlimit von 5 % und ein Ausstieg bei Liquidation. Der Schalter schließt Positionen mit Reduce-only-IOC-Orders, storniert verbleibende Orders und prüft dann, ob beides verschwunden ist.
  3. Ein Stop für jede Position. Fill-or-Kill-Einstiege bedeuten: keine ungeschützten Teilausführungen. Nach jeder Ausführung folgen Positions-Stop und Take-Profit; werden sie abgelehnt, wird die Position sofort geschlossen.
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())

Die Rechnung zur Positionsgröße. Die Größe ergibt sich aus dem Abstand zum Stop, nicht aus dem Hebel. Bei einem hypothetischen BTC-Angebot von 100.000 pUSD und einem Stop von 2 % liegt der Stop bei 98.000. Das Risiko pro Einheit beträgt 2.000, die Menge ist also 20 / 2.000 = 0,01 BTC, ein Nominalwert von 1.000 pUSD. Bei 3x sind dafür etwa 333 pUSD Margin nötig. Der Satz für die Erhaltungs-Margin von BTC beträgt 1 % (0,5 / 50x), daher liegt der Liquidationspreis des Longs bei 100.000 x (1 - 1/3) / (1 - 0,01) = etwa 67.340, ein Rückgang von 32,7 %. Der Stop bei -2 % greift lange vorher. Wird der Stop zum Auslösepreis ausgeführt, beträgt der Verlust 20 pUSD plus Gebühren: 0,40 für die Eröffnung und etwa 0,39 für das Schließen zum Taker-Satz von 0,040 %, insgesamt also etwa 20,79 pUSD vor Slippage. Der Hebel bestimmt nur, wie viel Margin gebunden ist. Am Verlust beim Stop ändert er nichts.

Bevor Sie live gehen, ergänzen Sie ein tägliches Trade-Limit, Benachrichtigungen bei Ausführungen und ausgelösten Notschaltern sowie einen Abgleich beim Start (fetch_portfolio, fetch_open_orders, fetch_orders, list_fills). Lesen Sie dazu unsere Kapitel zu Risiko-Code und Paper Trading, den Leitfaden zu Hebel und Liquidation bei Perps und den Leitfaden zu Funding-Rates bei Perps.

Fehler, Wiederholungen und der Totmannschalter

  • 503 service_unavailable beweist nicht, dass die Anfrage fehlgeschlagen ist. Wiederholen Sie Lesezugriffe und Hebeländerungen mit Backoff und beachten Sie Retry-After. Bei signierten Guthabenänderungen (Margin, Auszahlungen) senden Sie nur exakt die ursprüngliche signierte Anfrage erneut; eine neue Signatur gilt als zweite Anpassung.
  • signature expired: älter als 5 Minuten. Halten Sie die Systemuhr synchron.
  • insufficient_margin / invalid_leverage: Die Prüfungen berücksichtigen Ihre Position plus alle im Orderbuch liegenden Orders.
  • message_rate_limited: WebSocket-Kontingent aufgebraucht. Read-only-Keys erhalten 1.000 Nachrichten pro Minute und IP (Burst 50) und vier Verbindungen pro Konto und Gateway; alles Weitere steht auf der Seite Rate Limits der Doku.
  • Formatfehler: zu viele Nachkommastellen oder mehr als 5 signifikante Stellen. Deshalb gibt es fit().

Auto-Cancel storniert alle offenen Orders, sobald Ihr Bot den Schalter nicht mehr erneut scharf schaltet. Die Frist muss mindestens 5 Sekunden in der Zukunft liegen, und die Zahl der Auslösungen pro UTC-Tag ist begrenzt, schalten Sie ihn beim sauberen Herunterfahren also ab.

// 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();
Auto-Cancel und Stops. Die Doku nennt Auto-Cancel als einen der Wege, auf denen eine TP/SL-Order storniert wird. Ein Absturz kann also den Stop einer offenen Position entfernen. Auto-Cancel eignet sich für quotierende Bots wie Market Maker. Unser Gerüst hat keine im Orderbuch liegenden Einstiegsorders und lässt Auto-Cancel daher ausgeschaltet, damit seine Stops bestehen bleiben. So oder so gilt: Erst ein niedriger Hebel bewahrt einen abgestürzten Bot vor der Liquidation.

Wettbewerbe, Builder-Codes und die Regeln für Bots

Die Doku nennt „Trading-Bots, die auf Marktsignale reagieren“ und Market Maker als Einsatzzwecke der API. Dabei gelten zwei Regelwerke.

  • Wettbewerbe. Wash Trading, Self-Trading, mehrere Konten, Handeln vorwiegend für Volumen sowie „Bots, Skripte oder automatisierte Mittel, die das Programm manipulieren sollen“ sind verboten. Ein Bot, der echt handelt, ist in Ordnung; einer, der nur Volumen umwälzt, kann disqualifiziert werden.
  • Builder-Codes. Eine App, die für andere Nutzer handelt, kann mit Zustimmung jedes Traders eine Gebühr von bis zu 10 Basispunkten aufschlagen. Sie muss den Standort jedes Nutzers prüfen und Orders aus eingeschränkten Rechtsordnungen blockieren, statt nur zu warnen.

Liquiditätsprämien für Maker und Wettbewerbe behandelt der Polymarket-Perps-Leitfaden.

Den Bot hosten

Ein Bot mit Hebel sollte nicht auf einem Laptop laufen. Er muss seine WebSocket-Verbindung halten, binnen Sekunden auf Ausführungen reagieren und einen Ausfall des heimischen Internets überstehen. Betreiben Sie ihn auf einem VPS unter systemd mit automatischem Neustart, legen Sie den Key in einer Umgebungsdatei ab, die nur der Bot-Benutzer lesen kann, und synchronisieren Sie die Uhr. Das Platzieren von Orders ist aus eingeschränkten Regionen nicht erlaubt. Hosten Sie also nicht in den USA oder in Kanada, und nutzen Sie niemals einen VPS, um eine Sperre zu umgehen, die für Sie gilt. Unsere eigenen Bots laufen auf TradingVPS (Affiliate-Link: Wir erhalten eine kleine Vergütung, Ihr Preis bleibt gleich). Unser Kapitel zum VPS-Hosting vergleicht den Dienst mit anderen Anbietern nach Latenz, Preis und Regionen.

Laden Sie das Konto nach dem Paper Trading über die Polymarket-Perps-Seite mit einem kleinen Betrag auf und handeln Sie eine Woche lang mit minimaler Größe, bevor Sie hochskalieren.

Das Wichtigste in Kürze

  • Nutzen Sie die offiziellen SDKs, @polymarket/client oder polymarket-client. Ihre Wallet signiert einmal; danach signiert ein Proxy-Key die Orders.
  • Gleichen Sie Märkte über das Live-Symbol ab (BTC-USD, nicht BTC-PERP) und speichern Sie die numerische ID.
  • Bemessen Sie die Größe am Abstand zum Stop, begrenzen Sie den Hebel im Code, nutzen Sie isolierte Margin und sichern Sie jede Position direkt nach der Ausführung mit einem Stop ab.
  • TP/SL löst am Mark-Preis aus und steigt zum Marktpreis aus. Auto-Cancel kann Stops entfernen.
  • Bots sind erlaubt, die Manipulation von Wettbewerben nicht. Handeln Sie nie aus einem eingeschränkten Land.

Häufig gestellte Fragen

Hat Polymarket Perps eine API für Trading-Bots?
Ja. Es gibt eine REST-API unter api.perpetuals.polymarket.com, einen WebSocket unter ws.perpetuals.polymarket.com und offizielle SDKs: @polymarket/client für TypeScript und polymarket-client für Python. Die Doku von Polymarket nennt Trading-Bots und Market-Making-Systeme als unterstützte Einsatzzwecke.
Sollte ich das TypeScript- oder das Python-SDK verwenden?
Beide sind geeignet. Sie decken denselben Ablauf ab: einen Secure Client erstellen, eine Perps-Session öffnen, Instrumente abrufen, Orders mit TP/SL platzieren und Events streamen. Das TypeScript-SDK nutzt viem zum Signieren, das Python-SDK arbeitet asynchron. Wählen Sie die Sprache, in der Ihr Bot bereits geschrieben ist.
Braucht mein Bot den Private Key meiner Haupt-Wallet?
Nur zum Öffnen einer Session. Diese eine Signatur autorisiert einen Proxy-Trading-Key, und von da an signiert der Proxy die Orders. Session-Zugangsdaten laufen standardmäßig nach einer Woche ab. Speichern Sie sie verschlüsselt und verwenden Sie für Dashboards Read-only-Keys.
Wie lege ich über die Perps-API einen Stop-Loss fest?
Hängen Sie takeProfit- und stopLoss-Auslöser als Bracket an die Einstiegsorder, oder rufen Sie bei einer offenen Position placePositionTpSl (in Python place_position_tp_sl) auf. Auslöser beobachten den Mark-Preis und steigen mit einer Reduce-only-Order aus. Positions-TP/SL schließt die gesamte Position zum Marktpreis.
Wie hoch ist die Mindestordergröße bei Polymarket Perps?
10 $ Nominalwert pro Order, die Mindesteinzahlung beträgt 10 pUSD (Stand: November 2026). Preise und Größen müssen außerdem zu den Nachkommastellen des jeweiligen Marktes passen und dürfen höchstens 5 signifikante Stellen haben, sonst wird die Order abgelehnt.
Gibt es einen Notschalter oder Totmannschalter?
Ja. Auto-Cancel storniert alle offenen Orders, sobald Ihr Bot den Schalter nicht mehr erneut scharf schaltet, und cancelAllOrders löscht Orders auf Abruf. Die Doku nennt Auto-Cancel als einen der Wege, auf denen eine TP/SL-Order storniert werden kann, ein Absturz kann also auch Ihre Stops entfernen. Programmieren Sie zusätzlich einen eigenen Notschalter.
Kann ich einen Polymarket-Perps-Bot aus den USA oder Kanada betreiben?
Nein. Das Platzieren von Perps-Orders ist aus den USA, Kanada, Kuba, dem Iran, Nordkorea, Syrien, der Krim, Donezk oder Luhansk nicht erlaubt. Hosten Sie dort keinen Bot, und nutzen Sie keinen VPS oder VPN, um eine Sperre zu umgehen, die für Sie gilt.
Sind Bots bei den Trading-Wettbewerben von Polymarket Perps erlaubt?
Das Handeln mit einem Bot ist erlaubt. Die Wettbewerbsregeln verbieten Wash Trading, Self-Trading, mehrere Konten, Handeln vorwiegend zur Erzeugung von Volumen sowie Bots oder Skripte, die das Programm manipulieren sollen. Verstöße können zur Disqualifikation führen.