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.
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)
| Punkt | Wert |
|---|---|
| REST-Basis-URL | https://api.perpetuals.polymarket.com |
| WebSocket | wss://ws.perpetuals.polymarket.com/v1/ws |
| TypeScript-SDK | @polymarket/client (mit viem zum Signieren) |
| Python-SDK | polymarket-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-Zugangsdaten | Laufen standardmäßig nach einer Woche ab |
| Mindestorder | 10 $ Nominalwert; Mindesteinzahlung 10 pUSD |
| Größte Market-Order | 1 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öße | Dezimal-Strings, höchstens so viele Nachkommastellen, wie der Markt vorgibt, und höchstens 5 signifikante Stellen |
| Maximaler Hebel | 50x (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 |
| Funding | Stündlich, begrenzt auf +/-4 % pro Stunde |
| TP/SL-Auslöser | Mark-Preis, nicht der letzte Trade |
| WebSocket-Keepalive | Ping etwa alle 25 Sekunden; nach etwa 65 Sekunden Stille als veraltet behandeln |
| Aktualität des Tickers | Bis 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.
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:
- 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.
- 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.
- 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_unavailablebeweist nicht, dass die Anfrage fehlgeschlagen ist. Wiederholen Sie Lesezugriffe und Hebeländerungen mit Backoff und beachten SieRetry-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();
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/clientoderpolymarket-client. Ihre Wallet signiert einmal; danach signiert ein Proxy-Key die Orders. - Gleichen Sie Märkte über das Live-Symbol ab (
BTC-USD, nichtBTC-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.





