bybit_api/api/
market.rs

1//! Market data API endpoints.
2
3use crate::client::BybitClient;
4use crate::error::Result;
5use crate::models::*;
6
7impl BybitClient {
8    /// Get server time.
9    ///
10    /// # Example
11    /// ```rust,no_run
12    /// # use bybit_api::BybitClient;
13    /// # async fn example() -> bybit_api::Result<()> {
14    /// let client = BybitClient::testnet("key", "secret")?;
15    /// let time = client.get_server_time().await?;
16    /// println!("Server time: {}", time.time_second);
17    /// # Ok(())
18    /// # }
19    /// ```
20    pub async fn get_server_time(&self) -> Result<ServerTime> {
21        self.get_public("/v5/market/time", &[]).await
22    }
23
24    /// Get instruments info.
25    ///
26    /// # Arguments
27    /// * `category` - Product category
28    /// * `symbol` - Optional symbol filter
29    ///
30    /// # Example
31    /// ```rust,no_run
32    /// # use bybit_api::{BybitClient, Category};
33    /// # async fn example() -> bybit_api::Result<()> {
34    /// let client = BybitClient::testnet("key", "secret")?;
35    /// let info = client.get_instruments_info(Category::Linear, Some("BTCUSDT")).await?;
36    /// # Ok(())
37    /// # }
38    /// ```
39    pub async fn get_instruments_info(
40        &self,
41        category: Category,
42        symbol: Option<&str>,
43    ) -> Result<InstrumentsInfo> {
44        let mut params = vec![("category", category.to_string())];
45
46        let symbol_str;
47        if let Some(s) = symbol {
48            symbol_str = s.to_string();
49            params.push(("symbol", symbol_str.clone()));
50        }
51
52        let params_ref: Vec<(&str, &str)> = params.iter().map(|(k, v)| (*k, v.as_str())).collect();
53
54        self.get_public("/v5/market/instruments-info", &params_ref)
55            .await
56    }
57
58    /// Get orderbook.
59    ///
60    /// # Arguments
61    /// * `category` - Product category
62    /// * `symbol` - Symbol name
63    /// * `limit` - Optional depth limit (1-500, default 25)
64    pub async fn get_orderbook(
65        &self,
66        category: Category,
67        symbol: &str,
68        limit: Option<u32>,
69    ) -> Result<Orderbook> {
70        let cat_str = category.to_string();
71        let limit_str = limit.unwrap_or(25).to_string();
72
73        let params = vec![
74            ("category", cat_str.as_str()),
75            ("symbol", symbol),
76            ("limit", limit_str.as_str()),
77        ];
78
79        self.get_public("/v5/market/orderbook", &params).await
80    }
81
82    /// Get tickers.
83    ///
84    /// # Arguments
85    /// * `category` - Product category
86    /// * `symbol` - Optional symbol filter (returns all if None)
87    pub async fn get_tickers(&self, category: Category, symbol: Option<&str>) -> Result<Tickers> {
88        let cat_str = category.to_string();
89        let mut params = vec![("category", cat_str.as_str())];
90
91        if let Some(s) = symbol {
92            params.push(("symbol", s));
93        }
94
95        self.get_public("/v5/market/tickers", &params).await
96    }
97
98    /// Get klines (candlestick data).
99    ///
100    /// # Arguments
101    /// * `category` - Product category
102    /// * `symbol` - Symbol name
103    /// * `interval` - Kline interval
104    /// * `limit` - Optional limit (1-1000, default 200)
105    pub async fn get_klines(
106        &self,
107        category: Category,
108        symbol: &str,
109        interval: Interval,
110        limit: Option<u32>,
111    ) -> Result<Klines> {
112        let cat_str = category.to_string();
113        let interval_str = interval.to_string();
114        let limit_str = limit.unwrap_or(200).to_string();
115
116        let params = vec![
117            ("category", cat_str.as_str()),
118            ("symbol", symbol),
119            ("interval", interval_str.as_str()),
120            ("limit", limit_str.as_str()),
121        ];
122
123        self.get_public("/v5/market/kline", &params).await
124    }
125
126    /// Get funding rate history.
127    ///
128    /// # Arguments
129    /// * `category` - Product category (linear or inverse)
130    /// * `symbol` - Symbol name
131    /// * `limit` - Optional limit (default 200)
132    pub async fn get_funding_history(
133        &self,
134        category: Category,
135        symbol: &str,
136        limit: Option<u32>,
137    ) -> Result<FundingHistory> {
138        let cat_str = category.to_string();
139        let limit_str = limit.unwrap_or(200).to_string();
140
141        let params = vec![
142            ("category", cat_str.as_str()),
143            ("symbol", symbol),
144            ("limit", limit_str.as_str()),
145        ];
146
147        self.get_public("/v5/market/funding/history", &params).await
148    }
149
150    /// Get recent trades.
151    ///
152    /// # Arguments
153    /// * `category` - Product category
154    /// * `symbol` - Symbol name
155    /// * `limit` - Optional limit (1-1000, default 500)
156    pub async fn get_recent_trades(
157        &self,
158        category: Category,
159        symbol: &str,
160        limit: Option<u32>,
161    ) -> Result<RecentTrades> {
162        let cat_str = category.to_string();
163        let limit_str = limit.unwrap_or(500).to_string();
164
165        let params = vec![
166            ("category", cat_str.as_str()),
167            ("symbol", symbol),
168            ("limit", limit_str.as_str()),
169        ];
170
171        self.get_public("/v5/market/recent-trade", &params).await
172    }
173
174    /// Get open interest.
175    ///
176    /// # Arguments
177    /// * `category` - Product category (linear or inverse)
178    /// * `symbol` - Symbol name
179    /// * `interval_time` - Interval (5min, 15min, 30min, 1h, 4h, 1d)
180    /// * `limit` - Optional limit (default 50)
181    pub async fn get_open_interest(
182        &self,
183        category: Category,
184        symbol: &str,
185        interval_time: &str,
186        limit: Option<u32>,
187    ) -> Result<OpenInterest> {
188        let cat_str = category.to_string();
189        let limit_str = limit.unwrap_or(50).to_string();
190
191        let params = vec![
192            ("category", cat_str.as_str()),
193            ("symbol", symbol),
194            ("intervalTime", interval_time),
195            ("limit", limit_str.as_str()),
196        ];
197
198        self.get_public("/v5/market/open-interest", &params).await
199    }
200
201    /// Get risk limit info.
202    ///
203    /// # Arguments
204    /// * `category` - Product category (linear or inverse)
205    /// * `symbol` - Optional symbol filter
206    pub async fn get_risk_limit(
207        &self,
208        category: Category,
209        symbol: Option<&str>,
210    ) -> Result<RiskLimits> {
211        let cat_str = category.to_string();
212        let mut params = vec![("category", cat_str.as_str())];
213
214        if let Some(s) = symbol {
215            params.push(("symbol", s));
216        }
217
218        self.get_public("/v5/market/risk-limit", &params).await
219    }
220
221    /// Get mark price kline.
222    pub async fn get_mark_price_kline(
223        &self,
224        category: Category,
225        symbol: &str,
226        interval: Interval,
227        limit: Option<u32>,
228    ) -> Result<Klines> {
229        let cat_str = category.to_string();
230        let interval_str = interval.to_string();
231        let limit_str = limit.unwrap_or(200).to_string();
232
233        let params = vec![
234            ("category", cat_str.as_str()),
235            ("symbol", symbol),
236            ("interval", interval_str.as_str()),
237            ("limit", limit_str.as_str()),
238        ];
239
240        self.get_public("/v5/market/mark-price-kline", &params)
241            .await
242    }
243
244    /// Get index price kline.
245    pub async fn get_index_price_kline(
246        &self,
247        category: Category,
248        symbol: &str,
249        interval: Interval,
250        limit: Option<u32>,
251    ) -> Result<Klines> {
252        let cat_str = category.to_string();
253        let interval_str = interval.to_string();
254        let limit_str = limit.unwrap_or(200).to_string();
255
256        let params = vec![
257            ("category", cat_str.as_str()),
258            ("symbol", symbol),
259            ("interval", interval_str.as_str()),
260            ("limit", limit_str.as_str()),
261        ];
262
263        self.get_public("/v5/market/index-price-kline", &params)
264            .await
265    }
266
267    /// Get premium index price kline.
268    pub async fn get_premium_index_price_kline(
269        &self,
270        category: Category,
271        symbol: &str,
272        interval: Interval,
273        limit: Option<u32>,
274    ) -> Result<Klines> {
275        let cat_str = category.to_string();
276        let interval_str = interval.to_string();
277        let limit_str = limit.unwrap_or(200).to_string();
278
279        let params = vec![
280            ("category", cat_str.as_str()),
281            ("symbol", symbol),
282            ("interval", interval_str.as_str()),
283            ("limit", limit_str.as_str()),
284        ];
285
286        self.get_public("/v5/market/premium-index-price-kline", &params)
287            .await
288    }
289}
bybit_api/api/market.rs

bybit_api/api/
market.rs
