The Propology API

The API is the same account a trader uses in the app, reached from somewhere else — a bot, a dashboard, or another application. Every order placed through it goes through the same margin checks, leverage limits and risk engine as an order placed by hand.

Version 1 is stable. Fields are not removed or renamed within a version; new fields may be added, so ignore ones you do not recognise. A breaking change would ship as /v2 alongside it.

curl https://api.propology.trade/v1/accounts \
  -H "Authorization: Bearer plg_your_key_here"

A trader creates a key in the Propology app under Platforms → API keys. Send it as a bearer token on every request:

Authorization: Bearer plg_7Fq2Kx9aB3nR5tYwLm0pQ8sVc4ZdE6hJkU1oXgTy

Keys begin with plg_. Each one carries:

• A scope. read — accounts, positions, orders and history — or read and trade, which adds placing, cancelling and closing.
• Optionally, a set of accounts. A key can be limited to specific trading accounts; otherwise it reaches all of them, including ones opened later.
• Optionally, allowed IP addresses and an expiry. If your app runs from a fixed address, lock the key to it.

There is no withdrawal scope, and there will not be one. A key can trade an account; it can never move money out of it. Withdrawals always require the trader's password and a two-factor code in the app.

Creating a key requires the trader to enter a two-factor code, and they are emailed every time one is created. The key is shown once, at creation — Propology stores only a fingerprint of it and cannot show it again. Treat it like a password: keep it on your server, never in a browser or a mobile app bundle.

Every response is JSON wrapped in the same envelope:

{ "success": true,  "data": { ... } }
{ "success": false, "error": { "code": "VALIDATION_ERROR", "message": "price is required for limit orders" } }

• Money and quantities are strings — "10432.18", never 10432.18. A JSON number is a floating-point value, and a balance that has been through one is no longer the balance. Parse them with a decimal library.
• Times are epoch milliseconds, UTC.
• Lists that can grow are paginated as { "items": [...], "nextCursor": "..." }. Pass cursor to get the next page; nextCursor is null on the last one. limit is 1–200, default 50.

A key that is revoked, expired or used from the wrong address gets the same 401 as one that never existed — so the response cannot be used to probe which keys were once valid.

Limits are per trader, and shared with the app: a trader running a bot and trading by hand at the same time has one allowance between them.

Responses carry X-RateLimit-Limit and X-RateLimit-Remaining; a 429 carries Retry-After in seconds.

{
  "id": "5b0e…",
  "name": "10K Evaluation",
  "type": "evaluation",            // evaluation | funded | free
  "status": "active",              // active | breached | passed | pending_review | suspended | closed
  "currency": "USDT",
  "balance": "10000",
  "equity": "9812.40",
  "availableBalance": "9412.40",
  "marginUsed": "400",
  "unrealizedPnl": "-187.60",
  "maxLeverage": 250,
  "rules": {
    "phase": "phase_1",
    "profitTarget": { "targetEquity": "10800", "pct": 8 },
    "dailyLoss":    { "limitEquity": "9700", "remaining": "112.40", "pct": 3 },
    "totalLoss":    { "limitEquity": "9000", "remaining": "812.40", "pct": 10, "mode": "trailing" },
    "tradingDays":  { "completed": 2, "required": 5 },
    "minHoldSeconds": 120,
    "endsAt": 1790380800000
  }
}

rules is what a prop-trading integration exists for. Each limitEquity is the equity at which that rule is breached, and remaining is how far the account is above it right now. They are computed by the same functions the risk engine enforces with, so a drawdown bar drawn from them is the bar the engine will honour. rules is null on an account no live evaluation governs — a funded account, or one whose evaluation has ended.

totalLoss.mode is static (measured from the starting balance), trailing (follows the high-water mark), or trailing_to_initial (trails until it reaches the starting balance, then stays there).

{
  "symbol": "BTCUSDT",
  "side": "buy",
  "type": "limit",
  "quantity": "0.010",
  "price": "60000",
  "leverage": 10,
  "timeInForce": "gtc",
  "clientOrderId": "my-bot-000123",
  "stopLossPrice": "58500",
  "takeProfitPrice": "63000"
}

The response is the order, plus fill — the position and trade it produced — when it executed immediately. fill is null for an order that is resting or was rejected.

Networks fail. If a request to place an order times out, you cannot tell whether it was placed — and sending it again could open a second position.

Send a clientOrderId and retrying is always safe. Retry with the same id and you get back the order the first request placed, instead of a new one. If the first request is still being processed when the retry arrives, the retry gets a 409 — look the order up with GET …/orders before trying again.

const id = `bot-${Date.now()}`;       // one id per intended order

async function place(order) {
  for (let attempt = 0; attempt < 3; attempt++) {
    try {
      const res = await fetch(`https://api.propology.trade/v1/accounts/${ACCOUNT}/orders`, {
        method: 'POST',
        headers: { Authorization: `Bearer ${KEY}`, 'Content-Type': 'application/json' },
        body: JSON.stringify({ ...order, clientOrderId: id }),   // same id on every attempt
      });
      const body = await res.json();
      if (body.success) return body.data;
      if (res.status !== 409 && res.status < 500) throw new Error(body.error.message);
    } catch (networkError) { /* fall through and retry with the same id */ }
    await new Promise((r) => setTimeout(r, 1000 * (attempt + 1)));
  }
}

A clientOrderId is unique per account for good: once used, it always refers to that order.

Public — no key needed.

Which price means what matters when you model an order:

The mark is Binance's futures mark price, derived from an index across several exchanges — so a brief spike on one order book does not trigger stops or breach an account on its own.

An account traded through the API is the same account, under the same trading rules. Three matter most to automated strategies:

• Positions must be held at least two minutes. Closing sooner is a violation, whether a person or a bot closed it. The account's rules.minHoldSeconds says the exact figure.
• Latency arbitrage is prohibited — systematically taking fills against prices the engine has not yet updated.
• Copy trading across Propology accounts is prohibited — running the same signal on several accounts you control.

Questions, or building something we should know about? Write to support@propx.dev.