Struct Okx 

pub struct Okx { /* private fields */ }

OKX exchange structure.

Implementations

impl Okx

pub fn check_required_credentials(&self) -> Result<(), Error>

Check that required credentials are configured.

pub fn get_inst_type(&self) -> &str

Get the instrument type for API requests.

Maps the configured default_type to OKX’s instrument type (instType) parameter. OKX uses a unified V5 API, so this primarily affects market filtering.

Returns

Returns the OKX instrument type string:

• “SPOT” for spot trading
• “MARGIN” for margin trading
• “SWAP” for perpetual contracts
• “FUTURES” for delivery contracts
• “OPTION” for options trading

pub async fn fetch_markets(&self) -> Result<HashMap<String, Arc<Market>>, Error>

Fetch all trading markets.

Returns

Returns a vector of Market structures containing market information.

Errors

Returns an error if the API request fails or response parsing fails.

Example

let okx = Okx::builder().build()?;
let markets = okx.fetch_markets().await?;
println!("Found {} markets", markets.len());

pub async fn load_markets( &self, reload: bool, ) -> Result<HashMap<String, Arc<Market>>, Error>

Load and cache market data.

If markets are already loaded and reload is false, returns cached data.

Arguments

• reload - Whether to force reload market data from the API.

Returns

Returns a HashMap containing all market data, keyed by symbol (e.g., “BTC/USDT”).

pub async fn fetch_ticker(&self, symbol: &str) -> Result<Ticker, Error>

Fetch ticker for a single trading pair.

Arguments

• symbol - Trading pair symbol (e.g., “BTC/USDT”).

Returns

Returns Ticker data for the specified symbol.

pub async fn fetch_tickers( &self, symbols: Option<Vec<String>>, ) -> Result<Vec<Ticker>, Error>

Fetch tickers for multiple trading pairs.

Arguments

• symbols - Optional list of trading pair symbols; fetches all if None.

Returns

Returns a vector of Ticker structures.

pub async fn fetch_order_book( &self, symbol: &str, limit: Option<u32>, ) -> Result<OrderBook, Error>

Fetch order book for a trading pair.

Arguments

• symbol - Trading pair symbol.
• limit - Optional depth limit (valid values: 1-400; default: 100).

Returns

Returns OrderBook data containing bids and asks.

pub async fn fetch_trades( &self, symbol: &str, limit: Option<u32>, ) -> Result<Vec<Trade>, Error>

Fetch recent public trades.

Arguments

• symbol - Trading pair symbol.
• limit - Optional limit on number of trades (maximum: 500).

Returns

Returns a vector of Trade structures, sorted by timestamp in descending order.

pub async fn fetch_ohlcv( &self, symbol: &str, timeframe: &str, since: Option<i64>, limit: Option<u32>, ) -> Result<Vec<OHLCV>, Error>

Fetch OHLCV (candlestick) data.

Arguments

• symbol - Trading pair symbol.
• timeframe - Candlestick timeframe (e.g., “1m”, “5m”, “1h”, “1d”).
• since - Optional start timestamp in milliseconds.
• limit - Optional limit on number of candles (maximum: 300).

Returns

Returns a vector of OHLCV structures.

pub async fn fetch_balance(&self) -> Result<Balance, Error>

Fetch account balances.

Returns

Returns a Balance structure with all currency balances.

Errors

Returns an error if authentication fails or the API request fails.

pub async fn fetch_my_trades( &self, symbol: &str, since: Option<i64>, limit: Option<u32>, ) -> Result<Vec<Trade>, Error>

Fetch user’s trade history.

Arguments

• symbol - Trading pair symbol.
• since - Optional start timestamp in milliseconds.
• limit - Optional limit on number of trades (maximum: 100).

Returns

Returns a vector of Trade structures representing user’s trade history.

pub async fn create_order( &self, symbol: &str, order_type: OrderType, side: OrderSide, amount: f64, price: Option<f64>, ) -> Result<Order, Error>

Create a new order.

Arguments

• symbol - Trading pair symbol.
• order_type - Order type (Market, Limit).
• side - Order side (Buy or Sell).
• amount - Order quantity.
• price - Optional price (required for limit orders).

Returns

Returns the created Order structure with order details.

pub async fn cancel_order(&self, id: &str, symbol: &str) -> Result<Order, Error>

Cancel an existing order.

Arguments

• id - Order ID to cancel.
• symbol - Trading pair symbol.

Returns

Returns the canceled Order structure.

pub async fn fetch_order(&self, id: &str, symbol: &str) -> Result<Order, Error>

Fetch a single order by ID.

Arguments

• id - Order ID to fetch.
• symbol - Trading pair symbol.

Returns

Returns the Order structure with current status.

pub async fn fetch_open_orders( &self, symbol: Option<&str>, since: Option<i64>, limit: Option<u32>, ) -> Result<Vec<Order>, Error>

Fetch open orders.

Arguments

• symbol - Optional trading pair symbol. If None, fetches all open orders.
• since - Optional start timestamp in milliseconds.
• limit - Optional limit on number of orders (maximum: 100).

Returns

Fetch open orders.

Arguments

• symbol - Optional trading pair symbol. If None, fetches all open orders.
• since - Optional start timestamp in milliseconds.
• limit - Optional limit on number of orders (maximum: 100).

Returns

Returns a vector of open Order structures.

pub async fn fetch_closed_orders( &self, symbol: Option<&str>, since: Option<i64>, limit: Option<u32>, ) -> Result<Vec<Order>, Error>

Fetch closed orders.

Arguments

• symbol - Optional trading pair symbol. If None, fetches all closed orders.
• since - Optional start timestamp in milliseconds.
• limit - Optional limit on number of orders (maximum: 100).

Returns

Returns a vector of closed Order structures.

impl Okx

pub fn builder() -> OkxBuilder

Creates a new OKX instance using the builder pattern.

This is the recommended way to create an OKX instance.

Example

use ccxt_exchanges::okx::Okx;

let okx = Okx::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .passphrase("your-passphrase")
    .sandbox(true)
    .build()
    .unwrap();

pub fn new(config: ExchangeConfig) -> Result<Okx, Error>

Creates a new OKX instance.

Arguments

• config - Exchange configuration.

pub fn new_with_options( config: ExchangeConfig, options: OkxOptions, ) -> Result<Okx, Error>

Creates a new OKX instance with custom options.

This is used internally by the builder pattern.

Arguments

• config - Exchange configuration.
• options - OKX-specific options.

pub fn base(&self) -> &BaseExchange

Returns a reference to the base exchange.

pub fn base_mut(&mut self) -> &mut BaseExchange

Returns a mutable reference to the base exchange.

pub fn options(&self) -> &OkxOptions

Returns the OKX options.

pub fn set_options(&mut self, options: OkxOptions)

Sets the OKX options.

pub fn id(&self) -> &str

Returns the exchange ID.

pub fn name(&self) -> &str

Returns the exchange name.

pub fn version(&self) -> &str

Returns the API version.

pub fn certified(&self) -> bool

Returns true if the exchange is CCXT-certified.

pub fn pro(&self) -> bool

Returns true if Pro version (WebSocket) is supported.

pub fn rate_limit(&self) -> u32

Returns the rate limit in requests per second.

pub fn is_sandbox(&self) -> bool

Returns true if sandbox/demo mode is enabled.

Sandbox mode is enabled when either:

• config.sandbox is set to true
• options.demo is set to true

Returns

true if sandbox mode is enabled, false otherwise.

Example

use ccxt_exchanges::okx::Okx;
use ccxt_core::ExchangeConfig;

let config = ExchangeConfig {
    sandbox: true,
    ..Default::default()
};
let okx = Okx::new(config).unwrap();
assert!(okx.is_sandbox());

pub fn is_testnet_trading(&self) -> bool

Returns true if demo trading mode is enabled.

This is an OKX-specific alias for is_sandbox(). Demo trading mode is enabled when either:

• config.sandbox is set to true
• options.demo is set to true

When demo trading is enabled, the client will:

• Add the x-simulated-trading: 1 header to all REST API requests
• Use demo WebSocket URLs (wss://wspap.okx.com:8443/ws/v5/*?brokerId=9999)
• Continue using the production REST domain (https://www.okx.com)

Returns

true if demo trading mode is enabled, false otherwise.

Example

use ccxt_exchanges::okx::Okx;
use ccxt_core::ExchangeConfig;

let config = ExchangeConfig {
    sandbox: true,
    ..Default::default()
};
let okx = Okx::new(config).unwrap();
assert!(okx.is_testnet_trading());

pub fn timeframes(&self) -> HashMap<String, String>

Returns the supported timeframes.

pub fn urls(&self) -> OkxUrls

Returns the API URLs.

pub fn default_type(&self) -> DefaultType

Returns the default type configuration.

pub fn default_sub_type(&self) -> Option<DefaultSubType>

Returns the default sub-type configuration.

pub fn is_contract_type(&self) -> bool

Checks if the current default_type is a contract type (Swap, Futures, or Option).

This is useful for determining whether contract-specific API parameters should be used.

Returns

true if the default_type is Swap, Futures, or Option; false otherwise.

pub fn is_inverse(&self) -> bool

Checks if the current configuration uses inverse (coin-margined) contracts.

Returns

true if default_sub_type is Inverse; false otherwise.

pub fn is_linear(&self) -> bool

Checks if the current configuration uses linear (USDT-margined) contracts.

Returns

true if default_sub_type is Linear or not specified (defaults to Linear); false otherwise.

pub fn create_ws(&self) -> OkxWs

Creates a new WebSocket client for OKX.

Returns an OkxWs instance configured with the appropriate WebSocket URL based on the exchange configuration (production or demo).

Example

use ccxt_exchanges::okx::Okx;
use ccxt_core::ExchangeConfig;

let okx = Okx::new(ExchangeConfig::default())?;
let ws = okx.create_ws();
ws.connect().await?;

Trait Implementations

impl Debug for Okx

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Exchange for Okx

fn id(&self) -> &str

Returns the exchange identifier (e.g., “binance”, “coinbase”)

fn name(&self) -> &str

Returns the human-readable exchange name (e.g., “Binance”, “Coinbase”)

fn version(&self) -> &'static str

Returns the API version string

fn certified(&self) -> bool

Returns whether this exchange is CCXT certified

fn has_websocket(&self) -> bool

Returns whether this exchange supports WebSocket (pro features)

fn capabilities(&self) -> ExchangeCapabilities

Returns the exchange capabilities

fn timeframes(&self) -> Vec<Timeframe>

Returns supported timeframes for OHLCV data

fn rate_limit(&self) -> u32

Returns the rate limit (requests per second)

fn fetch_markets<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Market>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Okx: 'async_trait,

Fetch all available markets

fn load_markets<'life0, 'async_trait>( &'life0 self, reload: bool, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, Market>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Okx: 'async_trait,

Load markets and cache them

fn fetch_ticker<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Ticker, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Fetch ticker for a single symbol

fn fetch_tickers<'life0, 'life1, 'async_trait>( &'life0 self, symbols: Option<&'life1 [String]>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Ticker>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Fetch tickers for multiple symbols (or all if None)

fn fetch_order_book<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<OrderBook, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Fetch order book for a symbol

fn fetch_trades<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Trade>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Fetch recent public trades

fn fetch_ohlcv<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, timeframe: Timeframe, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Ohlcv>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Fetch OHLCV candlestick data

fn create_order<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, order_type: OrderType, side: OrderSide, amount: Decimal, price: Option<Decimal>, ) -> Pin<Box<dyn Future<Output = Result<Order, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Create a new order

fn cancel_order<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<Order, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Okx: 'async_trait,

Cancel an existing order

fn cancel_all_orders<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Order>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Cancel all orders (optionally for a specific symbol)

fn fetch_order<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<Order, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Okx: 'async_trait,

Fetch a specific order by ID

fn fetch_open_orders<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Order>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Fetch all open orders

fn fetch_closed_orders<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Order>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Fetch closed orders

fn fetch_balance<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Balance, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Okx: 'async_trait,

Fetch account balance

fn fetch_my_trades<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Trade>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Fetch user’s trade history

fn market<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Market, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Get a specific market by symbol

fn markets<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HashMap<String, Market>> + Send + 'async_trait>>

where 'life0: 'async_trait, Okx: 'async_trait,

Get all cached markets

fn is_symbol_active<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Check if a symbol is valid and active

impl WsExchange for Okx

fn ws_connect<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Okx: 'async_trait,

Connect to the WebSocket server

fn ws_disconnect<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Okx: 'async_trait,

Disconnect from the WebSocket server

fn ws_is_connected(&self) -> bool

Check if WebSocket is connected

fn ws_state(&self) -> WsConnectionState

Get WebSocket connection state

fn watch_ticker<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Ticker, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Watch ticker updates for a symbol

fn watch_tickers<'life0, 'life1, 'async_trait>( &'life0 self, _symbols: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Vec<Ticker>, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Watch tickers for multiple symbols

fn watch_order_book<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<OrderBook, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Watch order book updates

fn watch_trades<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Vec<Trade>, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Watch public trades

fn watch_ohlcv<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: &'life1 str, _timeframe: Timeframe, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Ohlcv, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Watch OHLCV candlestick updates

fn watch_balance<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Balance, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Okx: 'async_trait,

Watch account balance updates

fn watch_orders<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Order, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Watch order updates

fn watch_my_trades<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Trade, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Okx: 'async_trait,

Watch user trade updates

fn subscribe<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _channel: &'life1 str, _symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Okx: 'async_trait,

Subscribe to a channel

fn unsubscribe<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _channel: &'life1 str, _symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Okx: 'async_trait,

Unsubscribe from a channel

fn subscriptions(&self) -> Vec<String>

Get list of active subscriptions