Get started

Make a public request

GET /api/status Public

Check that you can reach the API. This request needs no API key.

  1. Run the status request and check the system and serverTime fields.
  2. Find a market in the instrument catalog, then get a ticker or get order book depth.
  3. Use a READ key to send a signed account request.

The first-call tutorial includes Python and JavaScript examples.

Choose a credential

  • Public market data uses no key.
  • Private account and order reads use a signed API key with READ permission.
  • Private WebSocket updates use a listen key created by a signed request.
  • Wallet registration and sign-in use a wallet challenge signature.

Example request

curl --fail-with-body -sS 'https://app.quote.trade/api/status'

Selected response fields

{
  "system": "operational",
  "serverTime": 1765168545978
}

API keys and resources

API Key Setup

  • Sign in to your Quote.Trade account to create an API key.
  • Open API Management to create a key with the permissions your application needs.
  • Never share your API key or secret key with anyone.
  • Quote.Trade /api/v2 is the canonical route group for regular order placement, lookup and cancellation, and it also carries managed single-parent placement when apiManaged: true is supplied. Quote.Trade /api/v3 provides linked-order lists, managed-parent collection/history and prompt extensions; it does not replace the V2 single-order route. Compatibility is endpoint-specific: signing, instrument symbols, execution behavior and response fields have documented differences, so changing only the hostname is not sufficient for every Binance client.

API Key Restrictions

  • After an API key is created, its default restriction is Enable Reading.
  • To enable withdrawals via API, any identity verification requested by Quote.Trade must be completed, and the API key restriction needs to be modified by the admin.

Platform and integration resources

Non-rehypothecation and collateral coverage: V6's non-upgradeable code restricts supported ERC-20 collateral to registered-wallet withdrawals that pass its release controls. It provides no general-purpose lending, third-party spending-approval, or arbitrary-transfer path.

To verify backing, reconcile published positions with published funding balances, then compare actual funding-contract assets with aggregate positive user liabilities at a matching, completed snapshot. Assets greater than those published liabilities establish a surplus at that snapshot. See the verification reference for addresses, scales, snapshot checks, and formulas.

OpenClaw Quote.Trade operator OpenClaw Skill

Smart Contract Audit (PDF)

Full open-source Telegram Bot project on GitHub

Full open-source CLI Trading Bot project on GitHub

Contact Us

  • Customer Support
    • For questions about a sudden drop in API or WebSocket performance.
    • For questions about your API or WebSocket implementation.
    • For any general questions about the API not covered in the documentation.
    • For cases such as missing funds, help with 2FA, etc.

General Info

General API Information

  • The base endpoint is: https://app.quote.trade/api
  • All HTTP POST and PUT endpoints expect minified JSON. ({} if there is no data to send.)
  • For GET endpoints, parameters must be sent in the query string.
  • For POST and PUT endpoints, the parameters must be sent as the request body with content type application/json.
  • All HTTP endpoints return either a minified JSON object or a minified JSON array.

HTTP Return Codes

  • HTTP 200 return code is used for success or business rejection responses.
  • HTTP 4XX responses indicate a client error. Check the response for details.
  • HTTP 403 return code is used when the WAF Limit (Web Application Firewall) has been violated.
  • HTTP 409 return code is used when a cancelReplace order partially succeeds. (e.g. if the cancellation of the order fails but the new order placement succeeds.)
  • HTTP 429 indicates that the request exceeded a rate limit.
  • HTTP 418 indicates that a client IP was blocked after repeated requests following 429 responses.
  • HTTP 5XX indicates a server error. The request may have been processed. For order requests, check the order status before retrying.

Error Codes and Messages

  • Check the HTTP status and response body for error details.

Example error response

{
  "error":"Invalid symbol."
}

LIMITS

REST Rate Limits

  • Rate limits are runtime configuration and can differ by deployment. Do not hard-code a value from this page.
  • Read the current advertised order limit from GET /api/exchangeInfo and its rateLimits array.
  • Additional gateway, IP, authenticated user/account, route-specific or burst controls may be stricter than the advertised order bucket.
  • When the server returns HTTP 429 or {"error":"rate limit exceeded"}, stop sending requests and retry with bounded backoff. Honor Retry-After when it is present.
  • Do not blindly retry an order, cancellation, transfer or withdrawal after an ambiguous timeout or rate-limit response. Query or reconcile its status first.

WebSocket Limits

  • Connection, message-rate, payload-size and subscription limits are deployment-specific.
  • Clients must use bounded reconnect backoff and reconcile missed order state after reconnecting.
  • Ping, pong and subscription-control traffic may count toward gateway message limits.

API Limit Introduction

The /api/* endpoints can be subject to independent IP, user/account, endpoint and gateway controls. The rateLimits array returned by GET /api/exchangeInfo is the current advertised order limit for that deployment; it is not a guarantee that every endpoint shares one bucket or that no stricter control applies.


Data Sources

  • The API system is asynchronous, so some delay in the response is normal and expected.
  • Each endpoint has a data source indicating where the data is being retrieved, and thus which endpoints have the most up-to-date response.

These are the three sources, ordered from the most up-to-date to the one with potential update delays.

  • Matching Engine - the data is from the matching engine
  • Memory - the data is from a server's local or external memory
  • Database - the data is taken directly from a database

Endpoint security type

  • Each endpoint has a security type that determines how you will interact with it. This is stated next to the NAME of the endpoint.
    • If no security type is stated, assume the security type is NONE.
  • API keys are passed into the REST API via the X-MBX-APIKEY header.
  • API keys and secret keys are case sensitive.
  • API keys can access only the routes permitted by their assigned permissions; a trade-only key cannot authorize withdrawals.
Security Type Description
NONE Endpoint can be accessed freely.
TRADE Endpoint requires sending a valid API-Key and signature.
USER_DATA Endpoint requires sending a valid API-Key and signature.
USER_STREAM Listen-key management requires a valid API key and signature. Push subscriptions use the returned listenKey.
MARKET_DATA Endpoint requires sending a valid API-Key.
  • TRADE, USER_DATA, and REST USER_STREAM management endpoints are SIGNED endpoints.

SIGNED (TRADE, AND USER_DATA ) Endpoint security

Request signing

  • SIGNED endpoints require an additional parameter, signature, to be sent in the http headers.
  • Endpoints use HMAC SHA256 signatures. The HMAC SHA256 signature is a keyed HMAC SHA256 operation. Use your secretKey as the key. For POST requests, the value is the raw query string after ? exactly as sent (if the URL has one) immediately followed by the exact serialized request body bytes; with no query string it is just the body. Send those same bytes without reformatting. For signed GET requests, sign the raw query string after ? exactly as sent (for example, symbol=USDT), or the empty string when there is no query. Sensitive account actions (profile, password, 2FA, API keys, withdrawals, transfers, whitelists, banks, user files) must include a millisecond timestamp (and optionally recvWindow) inside the signed payload. Withdrawals, transfers and apiKey/apiKeys must be signed with a wallet (non-trade-only) API key.
  • The signature is not case sensitive.

Verify a GET signature locally

Use this fixed query and test secret to check your HMAC-SHA256 implementation. The example runs locally and prints the expected hex digest. For an API request, use your own key and a current timestamp.

Signing test

query='symbol=BTC%2FUSD&origClientOrderId=docs-limit-1&timestamp=1700000000000'
printf '%s' "$query" | openssl dgst -sha256 -hmac 'docs-test-secret' | awk '{print $NF}'

Expected signature

7a8b11516ea00d70d2078fcd27d28d38b5c85894526c7f0df49ae8cb2e1eafcd

SIGNED Endpoint Example for POST /api/v2/order

Sign the exact minified request-body bytes that you send. The example below generates a current millisecond timestamp, signs the body with HMAC SHA256, and sends a regular priced LIMIT order. Replace the placeholder credentials before using it.

Key Value
apiKey YOUR_API_KEY
secretKey YOUR_API_SECRET
Parameter Value
symbol BTC
side BUY
type LIMIT
timeInForce GTC
quantity 0.001
price 75000
timestamp Current Unix time in milliseconds

Signed curl request:

api_key='YOUR_API_KEY'
api_secret='YOUR_API_SECRET'
api_url='https://app.quote.trade/api/v2/order'
timestamp=$(date +%s000)
request_body=$(printf '{"symbol":"BTC","side":"BUY","type":"LIMIT","timeInForce":"GTC","quantity":0.001,"price":75000,"newClientOrderId":"btc-limit-001","timestamp":%s}' "$timestamp")
signature=$(printf '%s' "$request_body" | openssl dgst -sha256 -hmac "$api_secret" | awk '{print $NF}')

curl -X POST "$api_url" --data-binary "$request_body" \
  -H "X-MBX-APIKEY: $api_key" \
  -H "signature: $signature" \
  -H "Content-Type: application/json"

If the URL contains a query string, sign the exact raw query string followed immediately by the exact body bytes. Do not parse, reformat, or reserialize the body after calculating the signature.


Public API Definitions

Terminology

These terms will be used throughout the documentation, so it is recommended especially for new users to read to help their understanding of the API.

  • base asset refers to the asset that is the quantity of a symbol. For the symbol BTC/USDC, BTC would be the base asset.
  • quote asset refers to the asset that is the price of a symbol. For the symbol BTC/USDC, USDC would be the quote asset.

ENUM definitions

Symbol status (status):

  • PRE_TRADING
  • TRADING
  • POST_TRADING
  • END_OF_DAY
  • HALT
  • AUCTION_MATCH
  • BREAK

Account and Symbol Permissions (permissions):

  • SPOT
  • MARGIN
  • LEVERAGED
  • TRD_GRP_002
  • TRD_GRP_003
  • TRD_GRP_004
  • TRD_GRP_005

Order status (status):

Status Description
NEW The order has been accepted by the engine.
PARTIALLY_FILLED A part of the order has been filled.
FILLED The order has been completed.
CANCELED The order has been canceled by the user.
PENDING_CANCEL Currently unused
REJECTED The order was not accepted by the engine and not processed.
EXPIRED The order was canceled according to the order type's rules (e.g. LIMIT FOK orders with no fill, LIMIT IOC or MARKET orders that partially fill) or by the exchange, (e.g. orders canceled during liquidation, orders canceled during maintenance)

OCO Status (listStatusType):

Status Description
RESPONSE This is used when the ListStatus is responding to a failed action. (e.g. order list placement or cancellation)
EXEC_STARTED The order list has been placed or there is an update to the order list status.
ALL_DONE The order list has finished executing and is no longer active.

OCO Order Status (listOrderStatus):

Status Description
EXECUTING Either an order list has been placed or there is an update to the status of the list.
ALL_DONE An order list has completed execution and is no longer active.
REJECT The list status indicates a failed action during order placement or cancellation.

Order types (orderTypes, type):

  • LIMIT
  • MARKET
  • STOP_LOSS
  • STOP_LOSS_LIMIT
  • TAKE_PROFIT
  • TAKE_PROFIT_LIMIT
  • LIMIT_MAKER

Order Response Type (newOrderRespType):

  • ACK
  • RESULT
  • FULL

Order side (side):

  • BUY
  • SELL

Time in force (timeInForce):

This sets how long an order will be active before expiration.

Status Description
GTC Good Till Canceled
An order will be on the book unless the order is canceled.
IOC Immediate Or Cancel
An order will fill as much as possible before it expires.
FOK Fill or Kill
An order will expire if the full order cannot be filled upon execution.

Kline/Candlestick chart intervals:

s-> seconds; m -> minutes; h -> hours; d -> days; w -> weeks; M -> months

  • 1s
  • 1m
  • 3m
  • 5m
  • 15m
  • 30m
  • 1h
  • 2h
  • 4h
  • 6h
  • 8h
  • 12h
  • 1d
  • 3d
  • 1w
  • 1M

User Registration

Code:

const { Wallet, verifyMessage } = require("ethers"); // ethers.js version 6.13.5

const privateKey = "YOUR_PRIVATE_KEY"; // Replace with your actual private key
const wallet = new Wallet(privateKey);

/**
  * Signs a message with the given private key.
  * @param {string} challenge - The challenge text received from the server.
  * @returns {Promise<string>} - The signed message.
  */
async function signMessage(challenge) {
  const signature = await wallet.signMessage(challenge);
  return signature;
}
              

Request Data:

{
    "signature": "{ecrecover signature generated in step 2}",
    "challenge": "{CHALLENGE TEXT received in step 1}"
}
        

Response Data:

{
    "requestToken": "{REQUEST_TOKEN}",
    "requestSecret": "{REQUEST_SECRET}"
}
        

To register a user, follow these steps:

Prerequisites

  • A valid Ethereum wallet address.
  • Access to the wallet's private key.

Steps

  1. Get the challenge text

    Send an HTTP POST request to the following API with the Ethereum wallet address:

    API URL: https://app.quote.trade/api/getChallenge

    Request Data:

    { "login": "{ETHEREUM_WALLET_ADDRESS}" }

    Example response Extract the challenge text from the response:

    { "challenge": "{CHALLENGE_TEXT}" }
  2. Generate an ecrecover signature for the challenge text.

    Use the Ethereum wallet's private key to sign the challenge text received in step 1. The resulting signature will be used for the registration request.

    The following code demonstrates how to generate the ecrecover signature using the ethers.js library.

  3. Call the Register User API

    Send an HTTP POST request to the following API with the necessary data:

    API URL: https://app.quote.trade/api/registerUser
    { "signature": "{ecrecover signature generated in step 2}", "challenge": "{CHALLENGE TEXT received in step 1}" }

    Example response Extract the requestToken and requestSecret from the API response:

    { "requestToken": "{REQUEST_TOKEN}", "requestSecret": "{REQUEST_SECRET}" }

Authentication

Code to generate signature:

const { Wallet, verifyMessage } = require("ethers"); // ethers.js version 6.13.5

const privateKey = "YOUR_PRIVATE_KEY"; // Replace with your actual private key
const wallet = new Wallet(privateKey);

/**
  * Signs a message with the given private key.
  * @param {string} challenge - The challenge text received from the server.
  * @returns {Promise<string>} - The signed message.
  */
async function signMessage(challenge) {
  const signature = await wallet.signMessage(challenge);
  return signature;
}
              

To authenticate a user, follow these steps:

Prerequisites

  • Already registered Ethereum wallet address.
  • Access to the wallet's private key.

Steps

  1. Get the challenge text

    Send an HTTP POST request to the following API with the Ethereum wallet address:

    API URL: https://app.quote.trade/api/getChallenge

    Request Data:

    { "login": "{ETHEREUM_WALLET_ADDRESS}" }

    Example response Extract the challenge text from the response:

    { "challenge": "{CHALLENGE_TEXT}" }
  2. Generate an ecrecover signature for the challenge text.

    Use the Ethereum wallet's private key to sign the challenge text received in step 1. The resulting signature will be used for the registration request.

    The following code demonstrates how to generate the ecrecover signature using the ethers.js library.

  3. Call the Register User API

    Send an HTTP POST request to the following API with the necessary data:

    API URL: https://app.quote.trade/api/logon

    Request Data:

    { "signature": "{ecrecover signature generated in step 2}", "challenge": "{CHALLENGE TEXT received in step 1}" }

    Example response Extract the requestToken and requestSecret from the API response:

    { "requestToken": "{REQUEST_TOKEN}", "requestSecret": "{REQUEST_SECRET}" }

List trading instruments

Request

GET /api/getInstrumentPairs Public

Example request

curl -X "GET" "https://app.quote.trade/api/getInstrumentPairs?skip=0&limit=2"

Example response

{
  "instrumentPairs": [
    {
      "id": 1,
      "symbol": "BTC",
      "name": "Bitcoin",
      "quantityScale": 6,
      "minOrderQuantityScale": 3,
      "executionQuantityScale": 6,
      "minimumNotionalUsd": 15,
      "chartPairId": 17,
      "chartPriceScale": 2,
      "chartSymbol": "BTC/USD",
      "rank": 1,
      "address": "",
      "url": "https://coinmarketcap.com/currencies/bitcoin"
    },
    {
      "id": 2,
      "symbol": "ETH",
      "name": "Ethereum",
      "quantityScale": 6,
      "minOrderQuantityScale": 2,
      "executionQuantityScale": 6,
      "minimumNotionalUsd": 15,
      "chartPairId": 20,
      "chartPriceScale": 4,
      "chartSymbol": "ETH/USD",
      "rank": 2,
      "address": "",
      "url": "https://coinmarketcap.com/currencies/ethereum"
    }
  ],
  "count": 5047,
  "skip": 0,
  "limit": 2
}

Parameters:

Name Type Mandatory Description
skip INT NO Zero-based number of current catalog entries to skip. Defaults to 0.
limit INT NO Positive page size. When omitted, zero or negative, the current implementation returns the complete catalog and reports limit: 0. No server-side maximum is currently documented; use bounded pages.

count is the total number of current, non-expired catalog entries before paging; skip and limit echo the applied request values. The response above is an illustrative snapshot, so IDs, symbols, metadata and count can differ by deployment.

Data Source: Memory

Get exchange information

Request

GET /api/exchangeInfo Public

Example request

curl -X "GET" "https://app.quote.trade/api/exchangeInfo"

Example response

{
  "exchangeFilters": [],
  "rateLimits": [
    {
      "interval": "MINUTE",
      "intervalNum": 1,
      "limit": 900,
      "rateLimitType": "ORDERS"
    }
  ],
  "serverTime": 1765168536880,
  "symbols": [
    {
      "id": 1,
      "symbol": "BTC",
      "status": "TRADING",
      "baseAsset": "BTC",
      "quoteAsset": "USD",
      "name": "Bitcoin",
      "quantityScale": 6,
      "address": "",
      "url": "https://coinmarketcap.com/currencies/bitcoin"
    },
    {
      "id": 2,
      "symbol": "ETH",
      "status": "TRADING",
      "baseAsset": "ETH",
      "quoteAsset": "USD",
      "name": "Ethereum",
      "quantityScale": 6,
      "address": "",
      "url": "https://coinmarketcap.com/currencies/ethereum"
    }
  ]
}

This is an illustrative production response snapshot. Read rateLimits on the live deployment instead of hard-coding the example value; runtime configuration and additional gateway or route-specific limits can change independently. Use the exact live symbol and status metadata when constructing requests.

Data Source: Memory

Get a ticker

Request

GET /api/ticker?symbol=BTC Public

Example request

curl -X "GET" "https://app.quote.trade/api/ticker?symbol=BTC"

Example response

{
  "symbol": "BTC",
  "lastUpdateId": "1765169207049",
  "price": "91201.73",
  "bid": "90928.07",
  "ask": "91475.39"
}

Parameters:

Name Type Mandatory Description
symbol STRING YES Symbol (eg: BTC)

Data Source: Memory

Get order book depth

Request

GET /api/depth Public

Example request

curl -X "GET" "https://app.quote.trade/api/depth?symbol=BTC&limit=2"

Example response

{
  "symbol": "BTC",
  "lastUpdateId": "1765167780756",
  "bids": [
    ["90850.22","4.15"],
    ["90759.28","22.22"]
  ],
  "asks": [
    ["91397.07","4.69"],
    ["91488.38","18.43"]
  ]
}

Each bid or ask level is [price, cumulativeBaseQuantity]. Both values are decimal strings.

Parameters:

Name Type Mandatory Description
symbol STRING YES Symbol (eg: symbol=BTC)
limit INT NO Maximum levels per side. Default 1000.

Data Source: Memory

Get API status

Request

GET /api/status Public

Example request

curl -X "GET" "https://app.quote.trade/api/status"

Example response

{
  "system": "operational",
  "serverTime": 1765168545978,
  "contracts": {
    "positionManager": "https://polygonscan.com/address/0xf857aC7bed76B43c5457f56483803C4CebbD7eff"
  },
  "features": {
    "leveraged_trading": true,
    "dark_pool_mode": true,
    "bridge_required": false
  }
}

The response is a snapshot. serverTime and contract addresses are deployment values; clients must use the live response rather than copying the example address.

Data Source: Memory

Deposit / Withdraw

Look up a deposit address

GET /liquidityApi/getDepositAddress?symbol=USDT

Example request

curl 'https://app.quote.trade/liquidityApi/getDepositAddress?symbol=USDT'

Example response

{
  "chain": "ETHEREUM",
  "address": "0xYOUR_RETURNED_DEPOSIT_ADDRESS"
}

This public lookup does not require a signature and remains subject to deployment/geographic restrictions. Some gateways expose it under an unversioned /api alias; the explicit handler path is shown above. The response above is illustrative. Request the selected symbol (USDT, USDC, or XUSDC) and use the returned chain and deposit address. The following transfer example applies only when the response selects Ethereum mainnet. A deposit requires the authorized wallet to sign and send the token transfer; retrieving an address does not move funds.

Ethereum Mainnet: 0xdac17f958d2ee523a2206206994597c13d831ec7 (USDT_CONTRACT_ADDRESS)

JavaScript Code:

import { ethers } from "ethers"; // (ethers.js version 6.13.5)

// Set your wallet and RPC parameters.
const PRIVATE_KEY = "your_private_key_here";  // Keep this value private.
const DEPOSIT_ADDRESS = "0xYOUR_RETURNED_DEPOSIT_ADDRESS"; // Use getDepositAddress for USDT; verify its chain is ETHEREUM
const USDT_CONTRACT_ADDRESS = "0xdac17f958d2ee523a2206206994597c13d831ec7"; // USDT on Ethereum
const RPC_URL = "https://mainnet.infura.io/v3/YOUR_INFURA_API_KEY"; // Replace with your Infura/Alchemy RPC

// USDT ERC-20 ABI (Minimal for transfer function)
const USDT_ABI = [
  "function transfer(address to, uint256 amount) public returns (bool)"
];

// Initialize ethers.js Provider & Wallet
const provider = new ethers.JsonRpcProvider(RPC_URL);
const wallet = new ethers.Wallet(PRIVATE_KEY, provider);

// Connect to USDT Smart Contract
const usdtContract = new ethers.Contract(USDT_CONTRACT_ADDRESS, USDT_ABI, wallet);

async function sendUSDT() {
    try {
        console.log(`Sending USDT from ${wallet.address} to ${DEPOSIT_ADDRESS}...`);

        // Convert USDT amount (5 USDT = 5 * 10^6 because USDT has 6 decimals)
        const amount = ethers.parseUnits("5", 6);

        // Call transfer function
        const tx = await usdtContract.transfer(DEPOSIT_ADDRESS, amount);

        console.log("Transaction submitted:", tx.hash);

        // Wait for transaction confirmation
        await tx.wait();
        console.log("Transaction confirmed:", tx.hash);

    } catch (error) {
        console.error("USDT transfer failed:", error);
    }
}

// Execute the function
sendUSDT();

               
              

Request a withdrawal

POST /api/v2/sendWithdrawRequest

sendWithdrawWithVTokenRequest is disabled in the current V2 handler. Use the enabled withdrawal route below when permitted by the deployment.

Submit a signed withdrawal request with a withdrawal-enabled API key, the authenticated user ID and an allowlisted destination address. Account entitlements, withdrawal enablement, IP restrictions, token configuration, balance and any required 2FA are checked. Request acceptance does not mean an on-chain payout is complete.

quantity is an integer string in token base units: 50 USDT is "50000000" at quantity_scale: 6. Use the selected token's decimal scale and instrument ID from the deployment catalog. userId must identify the authenticated user; this example withdraws from that same account. Supply code when 2FA is required. Sending the example requests a withdrawal.

JavaScript Code (Node.js):

import { createHmac } from "node:crypto";

// Withdrawals require the wallet API key pair; trade-only keys are refused.
const apiKey = process.env.QT_WALLET_API_KEY;
const apiSecret = process.env.QT_WALLET_API_SECRET;
const account = Number(process.env.QT_ACCOUNT_ID);
const instrumentId = Number(process.env.QT_USDT_INSTRUMENT_ID);
const withdrawAddress = process.env.QT_WITHDRAW_ADDRESS;
const twoFactorCode = process.env.QT_2FA_CODE;

if (!apiKey || !apiSecret || !Number.isSafeInteger(account) || account <= 0 ||
    !Number.isSafeInteger(instrumentId) || instrumentId <= 0 || !withdrawAddress) {
  throw new Error("Set credentials, account ID, USDT instrument ID and allowlisted withdrawal address.");
}

const requestBody = JSON.stringify({
  userId: account,
  account,
  instrumentId,
  quantity: "50000000",
  quantity_scale: 6,
  address: withdrawAddress,
  nonce: Date.now(),
  ...(twoFactorCode ? { code: twoFactorCode } : {})
});
const signature = createHmac("sha256", apiSecret).update(requestBody).digest("hex");

const response = await fetch("https://app.quote.trade/api/v2/sendWithdrawRequest", {
  method: "POST",
  headers: {
    "X-MBX-APIKEY": apiKey,
    "signature": signature,
    "Content-Type": "application/json"
  },
  body: requestBody
});
const result = await response.json();
if (!response.ok || result.error || Number(result.code) < 0) throw new Error(JSON.stringify(result));
console.log(result);

Place an order

Use POST /api/v2/order without apiManaged: true for regular MARKET and LIMIT orders. The unversioned POST /api/order route belongs to the older native JSON contract and specialized flows; it is not a drop-in alias for the V2 request body. Existing clients may continue using that contract. Use DELETE /api/v2/order for cancellation and the V2 status / history queries to verify the result.

Regular orders execute against Quote.Trade's private liquidity. A LIMIT request supplies an executable price condition; it does not publish a resting order to a public order book. Always verify the returned status and the account or order-status response.

POST /api/v2/order

Request parameters

Parameters:

Name Type Mandatory Description
symbolSTRINGYESSupported symbol from getInstrumentPairs or exchangeInfo, for example BTC. USDC and USDT select supported stablecoin conversion flows.
sideSTRINGYESBUY or SELL.
quantityDECIMALYESPositive base-asset quantity. The regular order parser uses up to six decimal places; also follow the instrument's live minimum and precision metadata.
typeSTRINGNOLIMIT or MARKET. Defaults to LIMIT.
priceDECIMALCONDITIONALLIMIT price in USD, with up to eight decimal places. It may be omitted or set to 0 for a server-priced LIMIT. It is not required for MARKET and is ignored for supported stablecoin conversions.
targetStrategyINTNO204 selects the engine routing strategy for a regular liquidity MARKET order. See the named Market Aggressive execution strategy for tradeStrategy: "MARKET_AGGRESSIVE" and its separate FOK and protective-price rules.
timeInForceSTRINGNODefaults to GTC for this regular REST order path.
newClientOrderIdSTRINGNOClient-provided unique order ID with at least three characters. clientOrderId is also accepted. The server generates an ID when omitted.
accountINTNOAccount ID. Defaults to the authenticated user's account. Trading for another account requires the appropriate entitlement.
isToCloseINTNODefaults to 0. Set to 1 when requesting an order that closes an existing position; server-side reduction checks still apply.
disableLeverageINTNODefaults to 0. Set to 1 to disable leverage for the request.
blockWaitAckINTNODefaults to 1. Use 1 to wait briefly for an order acknowledgement or 0 to return immediately.
apiManagedBOOLEANNOOmit or set to false for the regular order flow documented here. Setting it to true requests an API-managed advanced parent and switches to the advanced-order contract.
timestampLONGNORecommended request creation time in Unix milliseconds.
recvWindowLONGNOOptional compatibility field. Use a value from 1 to 60000 when the selected transport validates request freshness.

Generate timestamp at request time. For a complete HMAC and curl example, see SIGNED Endpoint Example for POST /api/v2/order.

Request examples:

Priced LIMIT

{
  "symbol": "BTC",
  "side": "BUY",
  "type": "LIMIT",
  "quantity": 0.001,
  "price": 75000,
  "newClientOrderId": "btc-limit-001",
  "timestamp": 1793942400000
}

LIMIT without a client price

{
  "symbol": "BTC",
  "side": "SELL",
  "type": "LIMIT",
  "quantity": 0.001,
  "newClientOrderId": "btc-limit-002",
  "timestamp": 1793942400000
}

MARKET

{
  "symbol": "ETH",
  "side": "BUY",
  "type": "MARKET",
  "quantity": 0.01,
  "newClientOrderId": "eth-market-001",
  "timestamp": 1793942400000
}

MARKET with engine routing strategy 204

{
  "symbol": "ETH",
  "side": "SELL",
  "type": "MARKET",
  "quantity": 0.01,
  "targetStrategy": 204,
  "newClientOrderId": "eth-market-002",
  "timestamp": 1793942400000
}

Example response

{
  "accountId": 222,
  "symbol": "BTC",
  "clientOrderId": "1786712423281580746",
  "executedQty": "0.001000",
  "orderId": 28051110618,
  "origQty": "0.001",
  "price": "62755.1000",
  "reduceOnly": "false",
  "side": "BUY",
  "status": "FILLED",
  "stopPrice": "0",
  "timeInForce": "GOOD_TILL_CANCEL",
  "type": "LIMIT",
  "targetStrategy": "196",
  "updateTime": 1786712423287,
  "assetId": 0,
  "tokenId": 0,
  "groupAssetId": 0,
  "selectId": 0
}

Data Source: Memory

Get an order (V2)

Signed GET routes require a deployment with V2 order queries enabled. HTTP 404 or 503 can indicate that the route is unavailable. See the existing POST queries for clients that use those endpoints.

Quote.Trade /api/v2 is the canonical single-order API. It handles regular placement, lookup and cancellation, and also identifies API-managed single-parent orders. Quote.Trade /api/v3 handles linked-order lists, managed-parent collection/history and prompt extensions; it does not replace V2 single-order operations.

RESTWebSocket methodResult
GET /api/v2/orderorder.statusOne native order, or one API-managed parent by its identity.
GET /api/v2/allOrdersallOrdersBounded array of latest native order snapshots, including closed orders.
GET /api/v2/getOrderStatus
GET /api/v2/orderStatus
getOrderStatus, orderStatusAliases of order.status.
GET /api/v2/getOrderHistorygetOrderHistoryQuote.Trade alias of allOrders. This is not a Binance endpoint name.

These GET routes are read-only. Create a regular order, or a managed single-parent order with apiManaged: true, through POST /api/v2/order; cancel one identified order through DELETE /api/v2/order. API-managed parent collection/history remains on GET /api/v3/openOrders; native child executions may also appear in native history. Do not count parent size and child fills as separate trades.

Query parameters

NameRequiredDescription
symbolYesExact instrument symbol from exchangeInfo, for example BTC/USD.
orderIdOne identityServer order ID; alternatively supply a client order ID.
origClientOrderIdOne identityClient order ID. Also accepts clientOrderId, clOrdId or clordid. If orderId is also supplied, both identities must match.
timestampYesCurrent Unix time in milliseconds.
recvWindowNoDefault 5000 ms; greater than 0 and at most 60000 ms.
signatureYesHMAC-SHA256 of the exact encoded query, excluding signature. Send the API key in X-MBX-APIKEY.

Order lookup

GET /api/v2/order READ

Supply symbol and either orderId or origClientOrderId. The aliases clientOrderId, clOrdId and clordid are accepted. Query client IDs must be nonempty and at most 64 characters; managed-order creation has a separate 36-character limit. Conflicting client-ID aliases are rejected. If both numeric and client IDs are present, both must match the same order. IDs remain 64-bit integers; do not round them through JavaScript floating-point values.

Native lookup checks current and archived orders, then persisted execution reports on a cache miss. Client IDs are case-sensitive. On a cache hit, reused client IDs resolve among cached matching records; persistence is consulted only on a cache miss. Do not reuse client IDs across logical orders or assume a global latest-across-cache-and-database lookup. Use the returned orderId to disambiguate. API-managed parent IDs use the existing negative-ID namespace.

Filled limit order example

{
  "symbol": "BTC/USD", "orderId": 12345, "orderListId": -1,
  "clientOrderId": "my-btc-limit", "clOrdId": "my-btc-limit",
  "status": "FILLED", "type": "LIMIT", "side": "BUY",
  "timeInForce": "GTC", "price": "66186.24", "origQty": "0.000302",
  "executedQty": "0.000302", "stopPrice": "0.00",
  "rejectReason": null, "reason": null, "errorMessage": null,
  "updateTime": 1792144800000, "isWorking": false,
  "accountId": 123, "isPaperTrade": false
}

Prices and quantities on the new V2 GET queries are decimal strings. A status is the latest known state, not a promise that a new order will fill. Unknown native orders return {"code":-2013,"msg":"Order does not exist"}. A negative managed-parent ID uses the managed lookup and its error contract; do not assume every missing parent returns -2013.

Authentication for V2 GET queries

Use X-MBX-APIKEY and a signed query, with timestamp in Unix milliseconds. HMAC-SHA256 signs the exact URL-encoded query bytes before the signature parameter is appended. A signature header is also accepted. If both are supplied they must agree.

recvWindow defaults to 5000 milliseconds, must be greater than zero and no more than 60000, and accepts up to three fractional digits. Requests 1000 milliseconds or more ahead of server time or older than the receive window are rejected. These V2 GET queries validate timestamps. POST nonce conventions are separate and do not currently enforce freshness; see request signing.

API keys require active READ permission. User/account ownership or an existing on-behalf entitlement and IP restrictions are checked before any lookup. A known order ID never grants access to another account.

Signed GET ยท client-ID lookup

GET /api/v2/order?symbol=BTC%2FUSD&origClientOrderId=my-btc-limit&timestamp=REPLACE_WITH_CURRENT_MS&signature=HMAC_HEX
X-MBX-APIKEY: YOUR_API_KEY

Use the exact symbol returned by the deployment's exchangeInfo catalog. A Quote.Trade USD instrument is not automatically the same product as Binance BTCUSDT spot.

For client-ID aliases and recorded cancellation or rejection explanations, see Client IDs & Order Errors. For WebSocket examples, see Order Queries (V2).

List orders (V2)

GET /api/v2/allOrders READ
Alias: GET /api/v2/getOrderHistory

Use the same signed GET authentication as order status. Returns an array of latest order snapshots, rather than a list of every execution event.

allOrders requires symbol. It returns one latest snapshot per native order, including NEW, PARTIALLY_FILLED, FILLED, CANCELED, EXPIRED and REJECTED when recorded. An empty successful query returns []. Database failures return an error, never an apparently empty history.

  • limit: default 500; minimum 1; maximum 1000. Larger or invalid values are rejected.
  • orderId: inclusive lower bound, not an exact-match filter on this list endpoint. For a forward scan of positive native IDs, start at orderId=1 and continue with the last returned orderId plus one. Starting without orderId selects the newest page; advancing from that page does not recover older orders. Rejections without an assigned ID are not covered by a positive-ID scan; query them by client ID while retained.
  • Without orderId, the newest numeric order IDs are selected. The returned page is sorted by ascending orderId. This differs from the UI's newest-first managed-parent list.
  • startTime and endTime: inclusive Unix milliseconds, filtering stored update/event time. This is a Quote.Trade difference from an exchange's order-creation-time filtering.
  • Client-ID aliases can filter the native list. Use the single-order endpoint for an exact server-ID lookup.

Use GET /api/v3/openOrders with the documented managed-order history filters and cursor for API-managed parent history. Its existing pagination and response envelope are unchanged.

Query parameters

NameRequiredDescription
symbolYesExact instrument symbol.
limitNoDefault 500; range 1 to 1000.
orderIdNoInclusive lower bound for pagination.
startTime / endTimeNoInclusive update/event-time bounds in Unix milliseconds.
origClientOrderIdNoClient-ID filter; clientOrderId, clOrdId and clordid are aliases.
timestamp / signatureYesSigned GET authentication; recvWindow is optional.

Signed GET history request

GET /api/v2/allOrders?symbol=BTC%2FUSD&limit=100&timestamp=REPLACE_WITH_CURRENT_MS&signature=HMAC_HEX
X-MBX-APIKEY: YOUR_API_KEY

Existing V2 POST status and event-history endpoints

POST /api/v2/orderStatus also accepts the alias POST /api/v2/getOrderStatus. These are existing V2 POST contracts, not aliases of the newer signed GET response shape: they retain scaled-integer price/quantity fields and their scale fields. POST /api/v2/getOrderHistory retains its {"orders":[...]} execution-event envelope and decimal-string fields. Existing POST signing and nonce conventions still apply. Use the V2 GET endpoints when timestamp freshness validation is required. See REST authentication and replay protection.

Both gain client-ID aliases and additive clientOrderId/status/rejectReason/reason/errorMessage fields. Event history returns at most the latest 1000 retained events in chronological order. For snapshot pagination use GET /api/v2/allOrders. A specific native history request no longer appends unrelated managed-parent orders. The unversioned /api/* native contract is separate and is not redefined by this V2 reference.

Compatibility and troubleshooting

This adds Binance-style query names, signing, ID lookup, statuses and decimal-string values. It is not a claim of full Binance Spot API parity. Native order snapshots do not currently provide all Binance fields, such as original creation time, cumulative quote quantity and self-trade-prevention metadata. Quote.Trade instruments, FOK execution, managed negative parent IDs and request-rejection retention differ.

Regular placement uses POST /api/v2/order without apiManaged: true. Managed single-parent placement uses the same endpoint with apiManaged: true. Query and cancellation of one identified order use GET and DELETE /api/v2/order. Linked-order operations and managed-parent collection/history use the documented /api/v3 routes, including /api/v3/openOrders. Managed snapshots have their own schema and do not currently return the native rejectReason/reason/errorMessage fields.

Use the documented versioned paths. A successful history query with no matching orders returns []. If an order query returns HTTP 200 with an empty body, verify the endpoint URL and gateway routing.

Reference: Binance REST account queries, Binance WebSocket account queries and execution-report fields, reviewed October 16, 2026.

Client IDs & Order Errors

Lookup by client order ID (clOrdId)

Supply origClientOrderId, clientOrderId, clOrdId or clordid on the order-status query. These aliases also filter native order history. Values are case-sensitive; conflicting aliases are rejected. When both orderId and a client ID are supplied, both must identify the same order.

Canceled and rejected orders

FieldMeaning
statusLatest recorded order state, including CANCELED or REJECTED.
rejectReasonRecorded engine business-rejection enum, when available.
reasonRecorded execution-restatement/cancellation enum, when available.
errorMessageRecorded rejection text, with JSON escaping preserved.

Missing reasons are null. A canceled order is not necessarily an error. A failed cancellation request must not change the original order to REJECTED.

Open the standalone V2 order-query reference →

Staking Endpoints

Stake or redeem an eligible position

POST /api/v2/order with a trade-enabled API key and a body signature.

A submitted request places an order. Check the position and the applicable terms in the staking app before submitting.

FieldValue
accountNumeric ID of the eligible account.
liquidityOrder, stakeSet both fields to 1.
quantityAmount to stake or redeem. Use the available balance as the upper bound.
sideBUY to stake. SELL to redeem an eligible 24-hour stake.
symbolUse the funding asset for BUY, such as USDC. For SELL, use the staking position symbol, such as STAKE_USDC_24H.
stakeOptionFor BUY, send integer 1 for 24 hours, 2 for 6 months, 3 for 12 months, or 4 for 18 months. Use 0 with the explicit 24-hour position symbol when redeeming.
timestampCurrent Unix time in milliseconds. Set this before signing the body.
typeLIMIT.

The order endpoint rejects redemption orders for 6-, 12-, and 18-month staking symbols. Check the staking app for current terms, rates, and options available to your account.

Check the returned order status or error before treating a submission as completed.

Build a 24-hour stake request

const body = JSON.stringify({
  liquidityOrder: 1,
  account: 123, // Replace with your account ID.
  symbol: "USDC",
  side: "BUY",
  type: "LIMIT",
  quantity: 100,
  timestamp: Date.now(),
  stake: 1,
  stakeOption: 1
});

Build a redemption request for an eligible 24-hour stake

const body = JSON.stringify({
  liquidityOrder: 1,
  account: 123, // Replace with your account ID.
  symbol: "STAKE_USDC_24H",
  side: "SELL",
  type: "LIMIT",
  quantity: 100,
  timestamp: Date.now(),
  stake: 1,
  stakeOption: 0
});

Get positions

POST /api/v2/positions

Position snapshot

Returns the authenticated account's current asset positions and valuation data.

Example request

api_key='your_api_key'
secret_key='your_secret_key'
request_body='{}'
signature=$(printf '%s' "$request_body" | openssl dgst -sha256 -hmac "$secret_key" | awk '{print $NF}')
curl -X POST 'https://app.quote.trade/api/v2/positions' --data-binary "$request_body" \
  -H "X-MBX-APIKEY: $api_key" \
  -H "signature: $signature" \
  -H "Content-Type: application/json"

Example response

{
  "e": "ACCOUNT_UPDATE",
  "E": 1781517334248,
  "T": 1781517334248,
  "a": {
    "m": "ORDER",
    "B": [
      {
        "a": "USD",
        "wb": "413209.28",
        "aq": "413209.28",
        "u": 222,
        "i": 1,
        "at": "ASSET",
        "ucb": "0.00",
        "uacb": "0.00",
        "uv": "413209.28",
        "up": "0.00",
        "ur": "0.00",
        "m": "1.00",
        "sm": "0.00",
        "su": "0.00",
        "sr": "0.00"
      },
      {
        "a": "BTC",
        "wb": "0.024000",
        "aq": "0.024000",
        "u": 222,
        "i": 3,
        "at": "ASSET",
        "ucb": "0.00",
        "uacb": "0.00",
        "uv": "1571.98",
        "up": "98931.60",
        "ur": "0.00",
        "m": "65499.30",
        "sm": "0.00",
        "su": "0.00",
        "sr": "0.00"
      }
    ]
  }
}

Response fields:

Name Type Description
eSTRINGEvent type. The value is ACCOUNT_UPDATE.
ELONGEvent time in milliseconds.
TLONGTransaction time in milliseconds.
a.mSTRINGReason for the account update.
a.BARRAYCurrent asset position records.

Position fields (a.B[]):

Name Type Description
aSTRINGAsset symbol.
wbSTRINGWallet balance.
aqSTRINGAsset quantity.
uINTUser ID.
iINTAsset ID.
atSTRINGAsset type.
ucbSTRINGUSD cost basis.
uacbSTRINGUSD average cost basis.
uvSTRINGUSD value.
upSTRINGUSD unrealized profit or loss.
urSTRINGUSD realized profit or loss.
mSTRINGBase asset USD mark price.
smSTRINGSettlement asset USD mark price.
suSTRINGSettlement asset unrealized profit or loss.
srSTRINGSettlement asset realized profit or loss.

Data Source: Memory

Liquidity Price Feed

WebSocket Information

  • The base endpoint is: wss://app.quote.trade
  • Streams can be accessed either in a single raw stream or in a combined stream
  • Raw streams are accessed at /ws/liquidity
  • The liquidity stream accepts symbols in either case.

Subscribe to a Stream

In a liquidity update, s is the symbol. Each bid and ask contains a price p and cumulative base quantity q.

Subscription request

{
  "symbol": "BTC",
  "unsubscribe": 0
}

Subscription acknowledgement

{
  "status": "subscribed"
}

Liquidity update

{
  "s": "BTC",
  "bids": [
    {
      "p": 88913.4,
      "q": 160.69
    },
    {
      "p": 88824.4,
      "q": 388.43
    }
  ],
  "asks": [
    {
      "p": 89091.5,
      "q": 170.06
    },
    {
      "p": 89180.5,
      "q": 473.8
    },
    {
      "p": 89269.5,
      "q": 680.95
    }
  ]
}

Unsubscribing from a Stream

Unsubscribe request

{
  "symbol": "BTC",
  "unsubscribe": 1
}

Unsubscribe acknowledgement

{
  "status": "unsubscribed"
}

Private stream setup (listenKey)

Use a managed API key with READ permission to create a listen key. The subscription also checks the account's trading/on-behalf entitlement. A managed API key is not a wallet/session requestToken: putting it in that field can return invalid user for request. The legacy session-token branch also requires its password; use the listen-key flow for API clients.

Signed REST requestJSON bodyResponse
POST /api/v2/userDataStream{}{"userId":123,"listenKey":"..."}
PUT /api/v2/userDataStream{"listenKey":"..."}{"userId":123,"listenKey":"..."}
DELETE /api/v2/userDataStream{"listenKey":"..."}{"status":"success"}

All three requests use the same REST signature. With no query, sign the exact JSON body, including {} when creating. No timestamp/nonce is required by these lifecycle handlers. Open wss://app.quote.trade/ws/listenKey and send the returned key in listenKey, with numeric account set to the returned userId. One subscription delivers positions, risk and order updates; do not create a key for each event type.

// Node.js 22+. Use a read-enabled API key.
import { createHmac } from "node:crypto";

const apiKey = process.env.QUOTE_TRADE_API_KEY;
const secret = process.env.QUOTE_TRADE_API_SECRET;
if (!apiKey || !secret) throw new Error("Set the Quote.Trade API credentials");
const baseUrl = new URL("https://app.quote.trade");
const streamPath = "/api/v2/userDataStream";

async function signedStreamRequest(method, body) {
  const signature = createHmac("sha256", secret).update(body).digest("hex");
  const response = await fetch(new URL(streamPath, baseUrl), {
    method,
    headers: {
      "X-MBX-APIKEY": apiKey, signature, "Content-Type": "application/json"
    },
    body
  });
  const result = await response.json();
  if (!response.ok || result.error || result.code < 0 || result.status === "error") {
    throw new Error("Listen-key request failed");
  }
  return result;
}

const stream = await signedStreamRequest("POST", "{}");
if (!Number.isSafeInteger(stream.userId) || !stream.listenKey) {
  throw new Error("Missing listen-key response fields");
}
const streamBody = JSON.stringify({ listenKey: stream.listenKey });
const wsUrl = new URL("/ws/listenKey", baseUrl);
wsUrl.protocol = "wss:";
const socket = new WebSocket(wsUrl);
socket.addEventListener("open", () => {
  socket.send(JSON.stringify({
    account: stream.userId, unsubscribe: 0, listenKey: stream.listenKey
  }));
});
socket.addEventListener("message", event => {
  const message = JSON.parse(event.data);
  // Dispatch updates by message.e. Acknowledgements may contain credentials.
  if (message.e) console.log("Private stream update received");
});
socket.addEventListener("error", () => console.error("Private stream error"));

// Call before the configured TTL expires.
async function renewStream() {
  return signedStreamRequest("PUT", streamBody);
}

// On shutdown, stop your renewal timer, close the socket, and revoke the key.
async function closeStream() {
  socket.close();
  return signedStreamRequest("DELETE", streamBody);
}

The default key TTL is one hour, configurable by LISTEN_KEY_VALIDITY_IN_MILLIS. Renew before expiry. A subscription using a key created 24 hours ago is rejected even if the key was renewed; create a replacement and reconnect before that limit. An expired key cannot be renewed. Keys are held in memory on one API process, with one current key per user: creating a replacement invalidates the previous key for new subscriptions. Route creation, renewal and WebSocket connections to the same process; a restart requires a new key.

On renewal failure or disconnect, establish a valid key/subscription again and reconcile missed changes with account and order queries. Revoking a key does not promise to close an already connected socket; close it explicitly. Treat the listen key as a credential and do not log it.

Signed WebSocket method queries use params.apiKey and their own timestamp/signature. They need no prior push subscription and do not replace listen-key setup for pushed events.

User Positions Stream

WebSocket Information

  • The base endpoint is: wss://app.quote.trade
  • Raw streams are accessed at /ws/listenKey

Subscribe to a Stream

Position updates carry event time E, transaction time T, and balance records in a.B. See the position fields for balance, identifier, and valuation definitions.

First create a listen key using signed REST. Send it in listenKey below. Omit account to use the key owner, or set it to the numeric returned userId. The same subscription delivers positions, orders and risk events.

Subscription request

{
  "unsubscribe": 0,
  "listenKey": "YOUR_LISTEN_KEY"
}

Subscription acknowledgement

{
  "userId": 0,
  "unsubscribe": 0,
  "listenKey": "YOUR_LISTEN_KEY"
}

Position update

{
  "e": "ACCOUNT_UPDATE",
  "E": 1742279156668,
  "T": 1742279156668,
  "a": {
    "m": "ORDER",
    "B": [
      {
        "a": "USDC",
        "wb": "435367.58",
        "aq": "435367.58",
        "u": 222,
        "i": 1,
        "at": "ASSET",
        "ucb": "0.0",
        "uacb": "0.0",
        "uv": "435367.57",
        "up": "0.0",
        "ur": "0.0",
        "m": "1.00",
        "sm": "0.0",
        "su": "0.0",
        "sr": "0.0"
      }
    ]
  }
}

Unsubscribing from a Stream

Unsubscribe request

{
  "unsubscribe": 1,
  "listenKey": "YOUR_LISTEN_KEY"
}

Unsubscribe acknowledgement

{
  "userId": 123, "unsubscribe": 1, "listenKey": "YOUR_LISTEN_KEY"
}

Order Queries (V2 WebSocket)

order.status, getOrderStatus and orderStatus query a single order. allOrders and getOrderHistory query bounded native history. Methods are versionless; these queries belong to regular V2 order flow.

Use /ws/listenKey. Each method request authenticates independently with its managed API key; no prior subscription is required. Push updates separately require listen-key setup. Supply flat params with apiKey, timestamp and signature. For HMAC, sort all parameter names except signature alphabetically and join their decoded key=value pairs with & before signing.

Order status request

{
  "id": "status-1", "method": "order.status",
  "params": {
    "apiKey": "YOUR_API_KEY", "symbol": "BTC/USD",
    "origClientOrderId": "my-btc-limit",
    "timestamp": 1792144800000, "signature": "REPLACE_WITH_SIGNATURE"
  }
}

Successful replies use {"id":"status-1","status":200,"result":{...},"rateLimits":[]}. History uses an array in result. Query errors use the same request id with an error object. Subscribe to private execution updates and reconcile after reconnect using the read-only queries; queries do not submit orders.

See Order Status, Order History and Client IDs & Order Errors for the shared parameter and response rules. V3 remains reserved for advanced and prompt-order support.

User Orders Stream

WebSocket Information

  • The base endpoint is: wss://app.quote.trade
  • Raw streams are accessed at /ws/listenKey

Subscribe to a Stream

An order update carries event type e and event time E. In o, s is the symbol, c is the client order ID, and i is the order ID. S, o, and f describe side, order type, and time in force. q and p are order quantity and price. x and X describe execution type and order status. l, z, L, and lv carry last fill quantity, cumulative fill quantity, last fill price, and remaining quantity. t, si, us, and u are execution ID, instrument ID, order update sequence, and user ID. ts and qt identify target strategy and quote type. n2 is total fees, h indicates a hidden order, and liq indicates liquidation.

First create a listen key using signed REST. Send it in listenKey below. Omit account to use the key owner, or set it to the numeric returned userId. The same subscription delivers positions, orders and risk events.

Subscription request

{
  "unsubscribe": 0,
  "listenKey": "YOUR_LISTEN_KEY"
}

Subscription acknowledgement

{
  "userId": 0,
  "unsubscribe": 0,
  "listenKey": "YOUR_LISTEN_KEY"
}

Order update

{
  "e": "ORDER_TRADE_UPDATE",
  "E": 1742290299907,
  "is": true,
  "T": 1742207668434,
  "o": {
    "s": "BTC/USDC",
    "c": "1742207668436941915",
    "S": "1",
    "o": "2",
    "f": "3",
    "q": "0.02",
    "p": "83506.22",
    "ap": "83506.22",
    "x": "F",
    "X": "2",
    "i": 8425490864,
    "l": "0.02",
    "z": "0.02",
    "L": "83506.22",
    "N": "1",
    "n": "0.00",
    "n2": "0.00",
    "T": 1742207668434,
    "t": 298568904,
    "m": true,
    "R": false,
    "si": 289,
    "us": 1,
    "u": 222,
    "ts": 0,
    "h": false,
    "liq": false,
    "lv": "0.00",
    "qt": "NULL_VAL"
  }
}

Unsubscribing from a Stream

Unsubscribe request

{
  "unsubscribe": 1,
  "listenKey": "YOUR_LISTEN_KEY"
}

Unsubscribe acknowledgement

{
  "userId": 123, "unsubscribe": 1, "listenKey": "YOUR_LISTEN_KEY"
}

Risk Update

WebSocket Information

  • The base endpoint is: wss://app.quote.trade
  • Raw streams are accessed at /ws/listenKey

Subscribe to a Stream

A risk update carries event type e, event time E, risk update time rd, and user ID u. USD values include estimated buying power bpe, maintenance margin value mmv, required margin mrv, margin value mv, open-order value oo, required open-order margin oor, position value pv, marginable value um, and unrealized profit or loss up. lr is the leverage ratio.

First create a listen key using signed REST. Send it in listenKey below. Omit account to use the key owner, or set it to the numeric returned userId. The same subscription delivers positions, orders and risk events.

Subscription request

{
  "unsubscribe": 0,
  "listenKey": "YOUR_LISTEN_KEY"
}

Subscription acknowledgement

{
  "userId": 0,
  "unsubscribe": 0,
  "listenKey": "YOUR_LISTEN_KEY"
}

Risk update

{
  "e": "RISK_UPDATE",
  "E": 1742290299907,
  "bpe": "0.0",
  "lr": "0.0",
  "mmv": "0.0",
  "mrv": "0.0",
  "mv": "0.0",
  "oo": "0.0",
  "oor": "0.0",
  "pv": "0.0",
  "rd": "20260129-06:36:30.742",
  "u": 95,
  "um": "0.0",
  "up": "0.0",
  "uv": "0.0"
}

Unsubscribing from a Stream

Unsubscribe request

{
  "unsubscribe": 1,
  "listenKey": "YOUR_LISTEN_KEY"
}

Unsubscribe acknowledgement

{
  "userId": 123, "unsubscribe": 1, "listenKey": "YOUR_LISTEN_KEY"
}

V3 Advanced Orders

See the complete V3 prompt endpoint table for chart/research requests, conversation history, connection settings and restricted worker operations.

Manage persistent limits, stops, trailing orders, TWAP, VWAP, participation and linked OCO, OTO and OTOCO orders directly through the API. An LLM is not required.

The new reference covers REST and WebSocket signing, decimal precision, the $15 opening-notional minimum, cancellation and bounded, newest-first managed-order history.

Read the V3 Advanced Orders reference →

Available on deployments that enable advanced orders for eligible accounts and markets. Advanced-order support spans two route groups: POST /api/v2/order creates a managed single-parent order when apiManaged: true is supplied, while /api/v3 provides linked-order, managed-parent collection/history and prompt routes. A V2 LIMIT or MARKET request without apiManaged: true remains a regular order.