Struct Bybit 

pub struct Bybit { /* private fields */ }

Bybit exchange structure.

Implementations

impl Bybit

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

Check that required credentials are configured.

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

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 bybit = Bybit::builder().build()?;
let markets = bybit.fetch_markets().await?;
println!("Found {} markets", markets.len());

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

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>

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>>

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>

Fetch order book for a trading pair.

Arguments

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

Returns

Returns OrderBook data containing bids and asks.

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

Fetch recent public trades.

Arguments

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

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>>

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: 1000).

Returns

Returns a vector of OHLCV structures.

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

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>>

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>

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>

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>

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>>

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: 50).

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>>

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: 50).

Returns

Returns a vector of closed Order structures.

impl Bybit

pub fn builder() -> BybitBuilder

Creates a new Bybit instance using the builder pattern.

This is the recommended way to create a Bybit instance.

Example

use ccxt_exchanges::bybit::Bybit;

let bybit = Bybit::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .testnet(true)
    .build()
    .unwrap();

pub fn new(config: ExchangeConfig) -> Result<Self>

Creates a new Bybit instance.

Arguments

• config - Exchange configuration.

pub fn new_with_options( config: ExchangeConfig, options: BybitOptions, ) -> Result<Self>

Creates a new Bybit instance with custom options.

This is used internally by the builder pattern.

Arguments

• config - Exchange configuration.
• options - Bybit-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) -> &BybitOptions

Returns the Bybit options.

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

Sets the Bybit 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/testnet mode is enabled.

Sandbox mode is enabled when either:

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

Returns

true if sandbox mode is enabled, false otherwise.

Example

use ccxt_exchanges::bybit::Bybit;
use ccxt_core::ExchangeConfig;

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

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

Returns the supported timeframes.

pub fn urls(&self) -> BybitUrls

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 category(&self) -> &'static str

Returns the Bybit category string based on the current default_type and default_sub_type.

Bybit V5 API uses category parameter for filtering:

• Spot -> “spot”
• Swap + Linear -> “linear”
• Swap + Inverse -> “inverse”
• Futures + Linear -> “linear”
• Futures + Inverse -> “inverse”
• Option -> “option”
• Margin -> “spot” (margin trading uses spot category)

Returns

The category string to use for Bybit API calls.

pub fn create_ws(&self) -> BybitWs

Creates a public WebSocket client.

The WebSocket URL is selected based on the configured default_type:

• Spot -> spot public stream
• Swap/Futures + Linear -> linear public stream
• Swap/Futures + Inverse -> inverse public stream
• Option -> option public stream

Returns

Returns a BybitWs instance for public data streams.

Example

use ccxt_exchanges::bybit::Bybit;
use ccxt_core::ExchangeConfig;

let bybit = Bybit::new(ExchangeConfig::default())?;
let ws = bybit.create_ws();
ws.connect().await?;

Trait Implementations

impl Debug for Bybit

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

Formats the value using the given formatter.

impl WsExchange for Bybit

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

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

Connect to the WebSocket server

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

where Self: 'async_trait, 'life0: '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<MessageStream<Ticker>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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<MessageStream<Vec<Ticker>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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<MessageStream<OrderBook>>> + Send + 'async_trait>>

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

Watch order book updates

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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<MessageStream<Ohlcv>>> + Send + 'async_trait>>

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

Watch OHLCV candlestick updates

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

where Self: 'async_trait, 'life0: '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<MessageStream<Order>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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<MessageStream<Trade>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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<()>> + Send + 'async_trait>>

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

Unsubscribe from a channel

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

Get list of active subscriptions