Struct Bybit 

pub struct Bybit { /* private fields */ }

Bybit exchange structure.

Implementations

impl Bybit

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

Get the authentication instance if credentials are configured.

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

Check that required credentials are configured.

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

pub async fn load_markets( &self, reload: bool, ) -> Result<Arc<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-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>, Error>

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_v2( &self, request: OhlcvRequest, ) -> Result<Vec<OHLCV>, Error>

Fetch OHLCV (candlestick) data using the builder pattern.

This is the preferred method for fetching OHLCV data. It accepts an OhlcvRequest built using the builder pattern, which provides validation and a more ergonomic API.

Arguments

• request - OHLCV request built via OhlcvRequest::builder()

Returns

Returns a vector of OHLCV structures.

Errors

Returns an error if the market is not found or the API request fails.

Requirements: 2.3, 2.6

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

👎Deprecated since 0.2.0: Use fetch_ohlcv_v2 with OhlcvRequest::builder() instead

Fetch OHLCV (candlestick) data (deprecated).

Deprecated

This method is deprecated. Use fetch_ohlcv_v2 with OhlcvRequest::builder() instead for a more ergonomic API.

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, 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_v2( &self, request: OrderRequest, ) -> 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 as Amount type.
• price - Optional price as Price type (required for limit orders).

Returns

Returns the created Order structure with order details.

Requirements: 2.2, 2.6

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

👎Deprecated since 0.2.0: Use create_order_v2 with OrderRequest::builder() instead

Create a new order (deprecated).

Deprecated

This method is deprecated. Use create_order_v2 with OrderRequest::builder() instead for a more ergonomic API.

Arguments

• symbol - Trading pair symbol.
• order_type - Order type (Market, Limit).
• side - Order side (Buy or Sell).
• amount - Order quantity as Amount type.
• price - Optional price as Price type (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: 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>, 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: 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<Bybit, Error>

Creates a new Bybit instance.

Arguments

• config - Exchange configuration.

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

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

Returns the exchange ID.

pub fn name(&self) -> &'static str

Returns the exchange name.

pub fn version(&self) -> &'static 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?;

pub fn signed_request( &self, endpoint: impl Into<String>, ) -> BybitSignedRequestBuilder<'_>

Creates a signed request builder for authenticated API calls.

This method provides a fluent API for constructing authenticated requests to Bybit’s private endpoints. The builder handles:

• Credential validation
• Millisecond timestamp generation
• HMAC-SHA256 signature generation (hex encoded)
• Authentication header injection (X-BAPI-* headers)

Arguments

• endpoint - API endpoint path (e.g., “/v5/account/wallet-balance”)

Returns

Returns a BybitSignedRequestBuilder for method chaining.

Example

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

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

// GET request
let balance = bybit.signed_request("/v5/account/wallet-balance")
    .param("accountType", "UNIFIED")
    .execute()
    .await?;

// POST request
let order = bybit.signed_request("/v5/order/create")
    .method(HttpMethod::Post)
    .param("category", "spot")
    .param("symbol", "BTCUSDT")
    .param("side", "Buy")
    .param("orderType", "Limit")
    .param("qty", "0.001")
    .param("price", "50000")
    .execute()
    .await?;

Trait Implementations

impl BybitEndpointRouter for Bybit

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

Returns the REST API endpoint.

fn ws_public_endpoint(&self, category: &str) -> String

Returns the public WebSocket endpoint for a specific category.

fn ws_private_endpoint(&self) -> &str

Returns the private WebSocket endpoint.

impl Debug for Bybit

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

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<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Bybit: '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, Bybit: '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, Bybit: '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, Bybit: '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, Bybit: '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, Bybit: '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, Bybit: '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, Bybit: '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, Bybit: '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, Bybit: '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, Bybit: '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, Bybit: 'async_trait,

Unsubscribe from a channel

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

Get list of active subscriptions