Type/to search
Built-in Functions
Global
Log
Market
Trade
Account
Futures
Exchange
IO
Network
Storage
Threads
TA
Talib
OS
Structures
Built-in Variables and Constants
Conventions
Exchanges

Obtains the current unfilled orders.


    
    
    
exchange.GetOrders()

    
    
    
exchange.GetOrders(symbol)

Examples

  • Query open orders (default scope when no argument is given) and print each one.

    
    javascript
    
    
    function main() {
    var orders = exchange.GetOrders()
    if (!orders) return    // null on failure, [] when there are no open orders
    Log("Open orders", orders.length)
    for (var o of orders) {
        Log(o.Symbol, o.Id, "Price", o.Price, "Amount", o.Amount, "Filled", o.DealAmount)
    }
}
    
    python
    
    
    def main():
    orders = exchange.GetOrders()
    if orders is None:
        return
    Log("Open orders", len(orders))
    for o in orders:
        Log(o["Symbol"], o["Id"], "Price", o["Price"], "Amount", o["Amount"], "Filled",
            o["DealAmount"])
    
    rust
    
    
    fn main() {
    let Ok(orders) = exchange.GetOrders(None) else { return };
    Log!("Open orders", orders.len());
    for o in &orders {
        Log!(o.Symbol, o.Id, "Price", o.Price, "Amount", o.Amount, "Filled", o.DealAmount);
    }
}

  • Using a spot exchange object, place buy orders for multiple different trading pairs at half of the current price as the order price, then query the information of unfilled orders.

    
    javascript
    
    
    /*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/

function main() {
    var arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]

    for (var symbol of arrSymbol) {
        var t = exchange.GetTicker(symbol)
        exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01)
    }

    var spotOrders = exchange.GetOrders()

    var tbls = []
    for (var orders of [spotOrders]) {
        var tbl = {type: "table", title: "test GetOrders", cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
        for (var order of orders) {
            tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
        }
        tbls.push(tbl)
    }

    LogStatus("`" + JSON.stringify(tbls) +  "`")

    // Print the information once and then return, to prevent orders from being filled during
    // subsequent backtesting, which would affect data observation
    return
}
    
    python
    
    
    '''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''

import json

def main():
    arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]

    for symbol in arrSymbol:
        t = exchange.GetTicker(symbol)
        exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 0.01)

    spotOrders = exchange.GetOrders()

    tbls = []
    for orders in [spotOrders]:
        tbl = {"type": "table", "title": "test GetOrders", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
        for order in orders:
            tbl["rows"].append([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
        tbls.append(tbl)

    LogStatus("`" + json.dumps(tbls) +  "`")

    return
    
    rust
    
    
    /*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/

fn main() {
    let arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"];

    for symbol in arrSymbol {
        let t = exchange.GetTicker(symbol).unwrap();
        let _ = exchange.CreateOrder(symbol, "buy", t.Last / 2.0, 0.01);
    }

    let spotOrders = exchange.GetOrders(None).unwrap();

    // Rust does not support JSON.stringify, use format! to build the table's JSON text
    let mut tbls = Vec::new();
    for orders in [&spotOrders] {
        let mut rows = Vec::new();
        for order in orders {
            rows.push(format!(r#"["{}", "{}", {}, {}, {}, {}, {}, {}, {}, "{}"]"#,
                order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType));
        }
        let tbl = format!(r#"{{"type": "table", "title": "test GetOrders", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": [{}]}}"#,
            rows.join(","));
        tbls.push(tbl);
    }

    LogStatus!(format!("`[{}]`", tbls.join(",")));

    // Print the information once and then return, to prevent orders from being filled during
    // subsequent backtesting, which would affect data observation
    return;
}

  • Use the futures exchange object to place orders on multiple symbols with different trading pairs and contract codes. The order prices are set far away from the counterparty price at the top of the order book, keeping the orders in an unfilled state, and then query the orders in various ways.

    
    javascript
    
    
    /*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

function main() {
    var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]

    for (var symbol of arrSymbol) {
        var t = exchange.GetTicker(symbol)
        exchange.CreateOrder(symbol, "buy", t.Last / 2, 1)
        exchange.CreateOrder(symbol, "sell", t.Last * 2, 1)
    }

    var defaultOrders = exchange.GetOrders()
    var swapOrders = exchange.GetOrders("USDT.swap")
    var futuresOrders = exchange.GetOrders("USDT.futures")
    var btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")

    var tbls = []
    var arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
    var tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
    for (var index in arr) {
        var orders = arr[index]
        var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
        for (var order of orders) {
            tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
        }
        tbls.push(tbl)
    }

    LogStatus("`" + JSON.stringify(tbls) +  "`")

    // Print the output once and then return immediately, to prevent orders from being filled later
    // in the backtest and affecting the data observation
    return
}
    
    python
    
    
    '''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''

import json

def main():
    arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]

    for symbol in arrSymbol:
        t = exchange.GetTicker(symbol)
        exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 1)
        exchange.CreateOrder(symbol, "sell", t["Last"] * 2, 1)

    defaultOrders = exchange.GetOrders()
    swapOrders = exchange.GetOrders("USDT.swap")
    futuresOrders = exchange.GetOrders("USDT.futures")
    btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")

    tbls = []
    arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
    tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
    for index in range(len(arr)):
        orders = arr[index]
        tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
        for order in orders:
            tbl["rows"].append([order["Symbol"], order["Id"], order["Price"], order["Amount"], order["DealAmount"], order["AvgPrice"], order["Status"], order["Type"], order["Offset"], order["ContractType"]])
        tbls.append(tbl)

    LogStatus("`" + json.dumps(tbls) +  "`")

    return
    
    rust
    
    
    /*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

fn main() {
    let arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"];

    for symbol in arrSymbol {
        let t = exchange.GetTicker(symbol).unwrap();
        let _ = exchange.CreateOrder(symbol, "buy", t.Last / 2.0, 1);
        let _ = exchange.CreateOrder(symbol, "sell", t.Last * 2.0, 1);
    }

    let defaultOrders = exchange.GetOrders(None).unwrap();
    let swapOrders = exchange.GetOrders("USDT.swap").unwrap();
    let futuresOrders = exchange.GetOrders("USDT.futures").unwrap();
    let btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap").unwrap();

    // Rust does not support JSON.stringify, so format! is used here to assemble the JSON text of
    // the table
    let mut tbls = Vec::new();
    let arr = [&defaultOrders, &swapOrders, &futuresOrders, &btcUsdtSwapOrders];
    let tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"];
    for index in 0..arr.len() {
        let orders = arr[index];
        let mut rows = Vec::new();
        for order in orders {
            rows.push(format!(r#"["{}", "{}", {}, {}, {}, {}, {}, {}, {}, "{}"]"#,
                order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType));
        }
        let tbl = format!(r#"{{"type": "table", "title": "{}", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": [{}]}}"#,
            tblDesc[index], rows.join(","));
        tbls.push(tbl);
    }

    LogStatus!(format!("`[{}]`", tbls.join(",")));

    // Print the output once and then return immediately, to prevent orders from being filled later
    // in the backtest and affecting the data observation
    return;
}

  • When calling the exchange.GetOrders() function, you can pass in the Symbol parameter to request order data for a specific trading pair or contract code.

    
    javascript
    
    
    function main() {
    var orders = exchange.GetOrders("BTC_USDT")           // Spot symbol example
    // var orders = exchange.GetOrders("BTC_USDT.swap")   // Futures symbol example
    Log("orders:", orders)
}
    
    python
    
    
    def main():
    orders = exchange.GetOrders("BTC_USDT")          # Spot symbol example
    # orders = exchange.GetOrders("BTC_USDT.swap")   # Futures symbol example
    Log("orders:", orders)
    
    rust
    
    
    fn main() {
    let orders = exchange.GetOrders("BTC_USDT");           // Spot symbol example
    // let orders = exchange.GetOrders("BTC_USDT.swap");   // Futures symbol example
    Log!("orders:", orders);
}

Returns

TypeDescription

Order array / null value

Order structure array on success; null value on failure.

Arguments

NameTypeRequiredDescription

symbol

string

No

The instrument (for example BTC_USDT.swap) or range of instruments (for example USDT.swap) to query. If omitted or an empty string, a spot exchange object queries all instruments and a futures exchange object queries the range of the current quote currency and contract type (USDT.swap when the current instrument is BTC_USDT.swap). The full rules for ranges and the default range are described in Symbols.

See Also

Order exchange.GetOrder exchange.GetHistoryOrders

Remarks

Range notation (USDT.swap, USD.futures, USDT.option, etc.) and the default range when symbol is omitted are described in Symbols; a range the exchange API does not support is reported as an error and returns a null value.

When the account represented by the exchange object exchange has no open orders (i.e., active orders in an unfilled state) within the query range or on the specified trading instrument, calling this function will return an empty array, that is: [].

On a few exchanges the open-order endpoint requires a symbol: there, calling without symbol only queries the open orders of the current instrument, not the whole range. Which exchanges behave like this is noted on each exchange page (all exchanges are listed in Capability Matrix).

Exchanges that do not support this function: OKX_DEX, Web3. The call fails with an error and returns null; for all exchanges see Capability Matrix.