exchange.IO

exchange.IO() function is used to call other interfaces related to the exchange object.

    
    
    
exchange.IO(k, ...args)

Examples

• Use the "api" mode to call the OKX futures batch order placement interface, and pass the JSON-formatted order data via the raw parameter:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var arrOrders = [
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
      ]
  
      // Call exchange.IO to directly access the exchange's batch order placement interface
      var ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", JSON.stringify(arrOrders))
      Log(ret)
  }
  

  
      python
      
      
  import json
  def main():
      arrOrders = [
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
      ]
      ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", json.dumps(arrOrders))
      Log(ret)
  

  
      rust
      
      
  fn main() {
      // Rust has no JSON serialization; construct the order array directly using a raw string
      let arrOrders = r#"[
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
      ]"#;
  
      // Call exchange.IO to directly access the exchange's batch order placement interface; multiple parameters are passed in as a tuple
      let ret = exchange.IO(("api", "POST", "/api/v5/trade/batch-orders", "", arrOrders));
      Log!(ret);
  }
  

  
      c++
      
      
  void main() {
      json arrOrders = R"([
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
      ])"_json;
      auto ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", arrOrders.dump());
      Log(ret);
  }
  

• When the value of a key in the params parameter is of string type, you need to wrap the parameter value with single quotes:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  var amount = 1
  var price = 10
  var basecurrency = "ltc"
  function main () {
      // Note that there is a ' character on both the left and right sides of amount.toString() and price.toString()
      var message = "symbol=" + basecurrency + "&amount='" + amount.toString() + "'&price='" + price.toString() + "'&side=buy" + "&type=limit"
      var id = exchange.IO("api", "POST", "/v1/order/new", message)
  }

  
      python
      
      
  amount = 1
  price = 10
  basecurrency = "ltc"
  def main():
      message = "symbol=" + basecurrency + "&amount='" + str(amount) + "'&price='" + str(price) + "'&side=buy" + "&type=limit"
      id = exchange.IO("api", "POST", "/v1/order/new", message)
  

  
      rust
      
      
  fn main() {
      let amount = 1;
      let price = 10;
      let basecurrency = "ltc";
      // Note that there is a ' character on both the left and right sides of the amount and price parameter values
      let message = format!("symbol={}&amount='{}'&price='{}'&side=buy&type=limit", basecurrency, amount, price);
      let id = exchange.IO(("api", "POST", "/v1/order/new", message));
  }
  

  
      c++
      
      
  void main() {
      auto amount = 1.0;
      auto price = 10.0;
      auto basecurrency = "ltc";
      string message = str_format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
      auto id = exchange.IO("api", "POST", "/v1/order/new", message);
  }
  

• The resource parameter supports passing in a complete URL:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
      Log(ret)
  }
  

  
      python
      
      
  def main():
      ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
      Log(ret)
  

  
      rust
      
      
  fn main() {
      let ret = exchange.IO(("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC"));
      Log!(ret);
  }
  

  
      c++
      
      
  void main() {
      auto ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC");
      Log(ret);
  }
  

• A GET request that does not use the raw parameter:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      var ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
      Log(ret)
  }
  

  
      python
      
      
  def main():
      ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
      Log(ret)
  

  
      rust
      
      
  fn main() {
      let ret = exchange.IO(("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT"));
      Log!(ret);
  }
  

  
      c++
      
      
  void main() {
      auto ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT");
      Log(ret);
  }
  

• Switch trading pair at runtime:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // For example, when the live bot starts, the exchange object's current trading pair is BTC_USDT; print the ticker of the current trading pair
      Log(exchange.GetTicker())
      // Switch the trading pair to LTC_BTC
      exchange.IO("currency", "LTC_BTC")
      Log(exchange.GetTicker())
  }
  

  
      python
      
      
  def main():
      Log(exchange.GetTicker())
      exchange.IO("currency", "LTC_BTC")
      Log(exchange.GetTicker())
  

  
      rust
      
      
  fn main() {
      // For example, when the live bot starts, the exchange object's current trading pair is BTC_USDT; print the ticker of the current trading pair
      Log!(exchange.GetTicker(None));
      // Switch the trading pair to LTC_BTC
      let _ = exchange.IO(("currency", "LTC_BTC"));
      Log!(exchange.GetTicker(None));
  }
  

  
      c++
      
      
  void main() {
      Log(exchange.GetTicker());
      exchange.IO("currency", "LTC_BTC");
      Log(exchange.GetTicker());
  }
  

• Switch the exchange API base address:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main () {
      // exchanges[0] is the first exchange object added when the live bot was created
      exchanges[0].IO("base", "https://api.huobi.pro")
  }

  
      python
      
      
  def main():
      exchanges[0].IO("base", "https://api.huobi.pro")
  

  
      rust
      
      
  fn main() {
      // exchanges[0] is the first exchange object added when the live bot was created
      let _ = exchanges[0].IO(("base", "https://api.huobi.pro"));
  }
  

  
      c++
      
      
  void main() {
      exchanges[0].IO("base", "https://api.huobi.pro");
  }
  

• Switch the market data API base address via "mbase" (using Bitfinex as an example):

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.SetBase("https://api.bitfinex.com")
      exchange.IO("mbase", "https://api-pub.bitfinex.com")
  }
  

  
      python
      
      
  def main():
      exchange.SetBase("https://api.bitfinex.com")
      exchange.IO("mbase", "https://api-pub.bitfinex.com")
  

  
      rust
      
      
  fn main() {
      exchange.SetBase("https://api.bitfinex.com");
      let _ = exchange.IO(("mbase", "https://api-pub.bitfinex.com"));
  }
  

  
      c++
      
      
  void main() {
      exchange.SetBase("https://api.bitfinex.com");
      exchange.IO("mbase", "https://api-pub.bitfinex.com");
  }
  

• Switch between the demo/live trading environment (using OKX Futures as an example):

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("simulate", true)    // Switch to demo trading environment
      // ... trading logic ...
      exchange.IO("simulate", false)   // Switch back to live trading environment
  }
  

  
      python
      
      
  def main():
      exchange.IO("simulate", True)
      # ... trading logic ...
      exchange.IO("simulate", False)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("simulate", true));    // Switch to demo trading environment
      // ... trading logic ...
      let _ = exchange.IO(("simulate", false));   // Switch back to live trading environment
  }
  

  
      c++
      
      
  void main() {
      exchange.IO("simulate", true);
      // ... trading logic ...
      exchange.IO("simulate", false);
  }
  

• Switch contract margin mode and position mode (using Binance Futures as an example):

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("dual", true)    // Switch to hedge mode (dual position)
      exchange.IO("dual", false)   // Switch to one-way mode
  
      exchange.SetContractType("swap")
      exchange.IO("cross", true)    // Switch to cross margin
      exchange.IO("cross", false)   // Switch to isolated margin
  }
  

  
      python
      
      
  def main():
      exchange.IO("dual", True)
      exchange.IO("dual", False)
  
      exchange.SetContractType("swap")
      exchange.IO("cross", True)
      exchange.IO("cross", False)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("dual", true));    // Switch to hedge mode (dual position)
      let _ = exchange.IO(("dual", false));   // Switch to one-way mode
  
      let _ = exchange.SetContractType("swap");
      let _ = exchange.IO(("cross", true));    // Switch to cross margin
      let _ = exchange.IO(("cross", false));   // Switch to isolated margin
  }
  

  
      c++
      
      
  void main() {
      exchange.IO("dual", true);
      exchange.IO("dual", false);
  
      exchange.SetContractType("swap");
      exchange.IO("cross", true);
      exchange.IO("cross", false);
  }
  

• Switch to unified account mode (using Binance Futures as an example):

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("unified", true)   // Switch to unified account mode
      exchange.IO("unified", false)  // Switch to normal mode
  }
  

  
      python
      
      
  def main():
      exchange.IO("unified", True)
      exchange.IO("unified", False)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("unified", true));   // Switch to unified account mode
      let _ = exchange.IO(("unified", false));  // Switch to normal mode
  }
  

  
      c++
      
      
  void main() {
      exchange.IO("unified", true);
      exchange.IO("unified", false);
  }
  

• Set self-trade prevention mode (using Binance as an example):

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // "NONE" means disable STP mode, other parameters: "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"
      exchange.IO("selfTradePreventionMode", "NONE")
  }
  

  
      python
      
      
  def main():
      exchange.IO("selfTradePreventionMode", "NONE")
  

  
      rust
      
      
  fn main() {
      // "NONE" means disable STP mode, other parameters: "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"
      let _ = exchange.IO(("selfTradePreventionMode", "NONE"));
  }
  

  
      c++
      
      
  void main() {
      exchange.IO("selfTradePreventionMode", "NONE");
  }
  

• Futures_edgeX calculates the order Hash and signs it:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var strJson = `{
          "assetIdSynthetic":     "0x4554482d3900000000000000000000",
          "assetIdCollateral":   "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "assetIdFee":          "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "isBuyingSynthetic":   true,
          "amountSynthetic":     10000000,
          "amountCollateral":    13020000,
          "amountFee":           6250,
          "nonce":               676432751,
          "accountID":           601416704693633632,
          "expirationTimestamp": 484831
      }`
      var signature = exchange.IO("calcOrderHashAndSign", strJson)
      Log(signature)
  }
  

  
      python
      
      
  import json
  def main():
      params = {
          "assetIdSynthetic":    "0x4554482d3900000000000000000000",
          "assetIdCollateral":   "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "assetIdFee":          "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "isBuyingSynthetic":   True,
          "amountSynthetic":     10000000,
          "amountCollateral":    13020000,
          "amountFee":           6250,
          "nonce":               676432751,
          "accountID":           601416704693633632,
          "expirationTimestamp": 484831
      }
      signature = exchange.IO("calcOrderHashAndSign", json.dumps(params))
      Log(signature)
  

  
      rust
      
      
  fn main() {
      let strJson = r#"{
          "assetIdSynthetic":    "0x4554482d3900000000000000000000",
          "assetIdCollateral":   "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "assetIdFee":          "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "isBuyingSynthetic":   true,
          "amountSynthetic":     10000000,
          "amountCollateral":    13020000,
          "amountFee":           6250,
          "nonce":               676432751,
          "accountID":           601416704693633632,
          "expirationTimestamp": 484831
      }"#;
      let signature = exchange.IO(("calcOrderHashAndSign", strJson));
      Log!(signature);
  }
  

  
      c++
      
      
  void main() {
      json params = R"({
          "assetIdSynthetic":    "0x4554482d3900000000000000000000",
          "assetIdCollateral":   "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "assetIdFee":          "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "isBuyingSynthetic":   true,
          "amountSynthetic":     10000000,
          "amountCollateral":    13020000,
          "amountFee":           6250,
          "nonce":               676432751,
          "accountID":           601416704693633632,
          "expirationTimestamp": 484831
      })"_json;
      auto signature = exchange.IO("calcOrderHashAndSign", params.dump());
      Log(signature);
  }
  

• rate mode rate limiting - Limit GetTicker to a maximum of 10 calls per second; returns null when the limit is exceeded:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("rate", "GetTicker", 10, "1s")
  
      for (var i = 0; i < 20; i++) {
          var ticker = exchange.GetTicker("BTC_USDT")
          if (ticker) {
              Log("Ticker:", ticker.Last)
          } else {
              Log("Rate limit exceeded")
          }
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("rate", "GetTicker", 10, "1s")
  
      for i in range(20):
          ticker = exchange.GetTicker("BTC_USDT")
          if ticker:
              Log("Ticker:", ticker["Last"])
          else:
              Log("Rate limit exceeded")
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("rate", "GetTicker", 10, "1s"));
  
      for _i in 0..20 {
          // GetTicker returns Err when the limit is exceeded
          match exchange.GetTicker("BTC_USDT") {
              Ok(ticker) => Log!("Ticker:", ticker.Last),
              Err(_) => Log!("Rate limit exceeded"),
          }
      }
  }
  

  
      c++
      
      
  // C++ is not supported yet

• rate mode rate limiting - Use the "delay" parameter to automatically wait instead of returning null when the limit is exceeded:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("rate", "GetTicker", 10, "1s", "delay")
  
      for (var i = 0; i < 20; i++) {
          var ticker = exchange.GetTicker("BTC_USDT")
          Log("Call", i+1, "Ticker:", ticker.Last)
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("rate", "GetTicker", 10, "1s", "delay")
  
      for i in range(20):
          ticker = exchange.GetTicker("BTC_USDT")
          Log("Call", i+1, "Ticker:", ticker["Last"])
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("rate", "GetTicker", 10, "1s", "delay"));
  
      for i in 0..20 {
          let ticker = exchange.GetTicker("BTC_USDT").unwrap();
          Log!("Call", i + 1, "Ticker:", ticker.Last);
      }
  }
  

  
      c++
      
      
  // C++ is not supported yet

• Multiple functions sharing a rate limit quota:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // GetTicker and GetDepth share the rate limit quota, with a combined maximum of 10 calls per second
      exchange.IO("rate", "GetTicker,GetDepth", 10, "1s")
  
      for (var i = 0; i < 20; i++) {
          if (i % 2 == 0) {
              Log("Ticker:", exchange.GetTicker("BTC_USDT"))
          } else {
              Log("Depth:", exchange.GetDepth("BTC_USDT"))
          }
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("rate", "GetTicker,GetDepth", 10, "1s")
  
      for i in range(20):
          if i % 2 == 0:
              Log("Ticker:", exchange.GetTicker("BTC_USDT"))
          else:
              Log("Depth:", exchange.GetDepth("BTC_USDT"))
  

  
      rust
      
      
  fn main() {
      // GetTicker and GetDepth share the rate limit quota, with a combined maximum of 10 calls per second
      let _ = exchange.IO(("rate", "GetTicker,GetDepth", 10, "1s"));
  
      for i in 0..20 {
          if i % 2 == 0 {
              Log!("Ticker:", exchange.GetTicker("BTC_USDT"));
          } else {
              Log!("Depth:", exchange.GetDepth("BTC_USDT"));
          }
      }
  }
  

  
      c++
      
      
  // C++ is not supported yet

• Use a wildcard to uniformly limit the call frequency of all APIs:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("rate", "*", 100, "1m")
  
      for (var i = 0; i < 10; i++) {
          exchange.GetTicker("BTC_USDT")
          exchange.GetDepth("BTC_USDT")
          exchange.GetAccount()
          Log("Round", i+1, "completed")
          Sleep(1000)
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("rate", "*", 100, "1m")
  
      for i in range(10):
          exchange.GetTicker("BTC_USDT")
          exchange.GetDepth("BTC_USDT")
          exchange.GetAccount()
          Log("Round", i+1, "completed")
          Sleep(1000)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("rate", "*", 100, "1m"));
  
      for i in 0..10 {
          let _ = exchange.GetTicker("BTC_USDT");
          let _ = exchange.GetDepth("BTC_USDT");
          let _ = exchange.GetAccount();
          Log!("Round", i + 1, "completed");
          Sleep(1000);
      }
  }
  

  
      c++
      
      
  // C++ is not supported yet

• quota mode - strict rate limiting aligned to time windows:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("quota", "GetTicker", 3, "1s")
  
      for (var i = 0; i < 10; i++) {
          var ticker = exchange.GetTicker("BTC_USDT")
          if (ticker) {
              Log(_D(), "Ticker:", ticker.Last)
          } else {
              Log(_D(), "Quota exceeded, waiting for next window")
          }
          Sleep(100)
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("quota", "GetTicker", 3, "1s")
  
      for i in range(10):
          ticker = exchange.GetTicker("BTC_USDT")
          if ticker:
              Log(_D(), "Ticker:", ticker["Last"])
          else:
              Log(_D(), "Quota exceeded, waiting for next window")
          Sleep(100)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("quota", "GetTicker", 3, "1s"));
  
      for _i in 0..10 {
          match exchange.GetTicker("BTC_USDT") {
              Ok(ticker) => Log!(_D(None), "Ticker:", ticker.Last),
              Err(_) => Log!(_D(None), "Quota exceeded, waiting for next window"),
          }
          Sleep(100);
      }
  }
  

  
      c++
      
      
  // C++ not supported yet

• quota mode - intraday quota, resets daily at the specified time:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("quota", "GetTicker", 1000, "@0815")
  
      var count = 0
      while (true) {
          var ticker = exchange.GetTicker("BTC_USDT")
          if (ticker) {
              count++
              Log("Call count:", count, "Ticker:", ticker.Last)
          } else {
              Log("Daily quota exceeded, waiting for reset at 08:15")
              Sleep(60000)  // Wait 1 minute
          }
          Sleep(1000)
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("quota", "GetTicker", 1000, "@0815")
  
      count = 0
      while True:
          ticker = exchange.GetTicker("BTC_USDT")
          if ticker:
              count += 1
              Log("Call count:", count, "Ticker:", ticker["Last"])
          else:
              Log("Daily quota exceeded, waiting for reset at 08:15")
              Sleep(60000)  # Wait 1 minute
          Sleep(1000)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("quota", "GetTicker", 1000, "@0815"));
  
      let mut count = 0;
      loop {
          match exchange.GetTicker("BTC_USDT") {
              Ok(ticker) => {
                  count += 1;
                  Log!("Call count:", count, "Ticker:", ticker.Last);
              }
              Err(_) => {
                  Log!("Daily quota exceeded, waiting for reset at 08:15");
                  Sleep(60000);  // Wait 1 minute
              }
          }
          Sleep(1000);
      }
  }
  

  
      c++
      
      
  // C++ not supported yet

• Combining multiple rate-limiting rules:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("rate", "GetTicker", 10, "1s")      // GetTicker 10 times per second
      exchange.IO("rate", "GetDepth", 5, "1s")        // GetDepth 5 times per second
      exchange.IO("rate", "CreateOrder", 2, "1s")     // CreateOrder 2 times per second
      exchange.IO("quota", "*", 1000, "@0000")        // All APIs reset daily at 00:00, cap of 1000 calls
  
      Log("Rate limits configured successfully")
  
      for (var i = 0; i < 5; i++) {
          exchange.GetTicker("BTC_USDT")
          exchange.GetDepth("BTC_USDT")
          Sleep(200)
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("rate", "GetTicker", 10, "1s")      # GetTicker 10 times per second
      exchange.IO("rate", "GetDepth", 5, "1s")        # GetDepth 5 times per second
      exchange.IO("rate", "CreateOrder", 2, "1s")     # CreateOrder 2 times per second
      exchange.IO("quota", "*", 1000, "@0000")        # All APIs reset daily at 00:00, cap of 1000 calls
  
      Log("Rate limits configured successfully")
  
      for i in range(5):
          exchange.GetTicker("BTC_USDT")
          exchange.GetDepth("BTC_USDT")
          Sleep(200)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("rate", "GetTicker", 10, "1s"));      // GetTicker 10 times per second
      let _ = exchange.IO(("rate", "GetDepth", 5, "1s"));        // GetDepth 5 times per second
      let _ = exchange.IO(("rate", "CreateOrder", 2, "1s"));     // CreateOrder 2 times per second
      let _ = exchange.IO(("quota", "*", 1000, "@0000"));        // All APIs reset daily at 00:00, cap of 1000 calls
  
      Log!("Rate limits configured successfully");
  
      for _i in 0..5 {
          let _ = exchange.GetTicker("BTC_USDT");
          let _ = exchange.GetDepth("BTC_USDT");
          Sleep(200);
      }
  }
  

  
      c++
      
      
  // C++ is not supported yet

Returns

Arguments

See Also

Remarks

I. Directly Calling Exchange APIs ("api" mode)

            javascript
            
            

exchange.IO("api", httpMethod, resource, params, raw)

Used to call the exchange's native API endpoints that are not wrapped by FMZ. FMZ automatically handles signature verification; you only need to fill in the request parameters.

Returns a null value on failure, and this mode is only supported in live trading.

II. Switching Trading Pairs at Runtime ("currency" mode)

            javascript
            
            

exchange.IO("currency", "ETH_USDT")

Used to dynamically switch trading pairs at runtime. The trading pair format is uppercase letters separated by an underscore. This instruction is equivalent to exchange.SetCurrency.

In backtesting mode, only spot is supported, and you can only switch to a trading pair with the same quote currency. After switching trading pairs for futures, you need to call exchange.SetContractType() again.

III. Switching the Base Address ("base" / "mbase" mode)

• "base": Switches the base address of the trading interface, equivalent to exchange.SetBase().

• "mbase": Switches the base address of the market data interface, suitable for exchanges that use different domain names for market data and trading.

IV. Common Trading Mode Instructions

The following instructions are common across multiple exchanges. For the specific support of each exchange, please refer to the description in Section V.

V. Exchange-Specific IO Commands

All exchanges support the "api" and "currency" commands; only the exchange-specific commands are listed below.

Spot Exchanges

Binance

OKX

Huobi

Bybit

Gate.io

Bitget

CoinEx

WOO

Crypto.com

AscendEx

Gemini

Poloniex

Bitfinex

Backpack

Hyperliquid (Spot)

Futures Exchanges

Futures_Binance (Binance Futures)

Futures_OKX (OKX Futures)

Futures_HuobiDM (Huobi Futures)

Futures_Bybit

Futures_KuCoin

Futures_GateIO

Futures_Bitget

Futures_MEXC

Futures_BitMEX

Futures_CoinEx

Futures_WOO

Futures_Kraken

Futures_Aevo

Futures_Hyperliquid

Futures_Deepcoin

Futures_DigiFinex

Futures_ApolloX

Futures_Aster

Futures_CoinW

Futures_BitMart

Futures_Backpack

Futures_Lighter

Futures_Crypto.com

Futures_Bitfinex

Futures_edgeX

Futures_Bibox

Futures_Pionex

Futures_Phemex

Futures_WooFi

Only the generic commands "api" and "currency" are supported; no exchange-specific commands.

VI. Special Platform IO Commands

Polymarket (Prediction Market)

Web3 (Blockchain)

IB (Interactive Brokers)

Futu (Futu Securities)

VII. API Rate Limiting Control ("rate" / "quota" modes)

            javascript
            
            
exchange.IO("rate", functionNames, maxCalls, period, [behavior])
exchange.IO("quota", functionNames, maxCalls, period, [behavior])

• rate: Smooth rate limiting, not strictly aligned to time windows.
• quota: Quota-based rate limiting, strictly aligned to time windows.

The rate limiting of Buy/Sell follows the settings of CreateOrder; Go follows the settings of the actual concurrent function; IO/api only takes effect for exchange.IO("api", ...).