Unofficial Rust Library for the Binance API
https://t.me/binance_api_english
It is a personal project, use at your own risk. I will not be responsible for your investment losses. Cryptocurrency investment is subject to high market risk.
Add this to your Cargo.toml
toml
[dependencies]
binance = { git = "https://github.com/wisespace-io/binance-rs.git" }
rustup install stable
```rust extern crate binance;
use binance::api::; use binance::market::;
fn main() { let market: Market = Binance::new(None, None);
// Order book
match market.get_depth("BNBETH") {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
// Latest price for ALL symbols
match market.get_all_prices() {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
// Latest price for ONE symbol
match market.get_price("KNCETH") {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
// Best price/qty on the order book for ALL symbols
match market.get_all_book_tickers() {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
// Best price/qty on the order book for ONE symbol
match market.get_book_ticker("BNBETH") {
Ok(answer) => println!(
"Bid Price: {}, Ask Price: {}",
answer.bid_price, answer.ask_price
),
Err(e) => println!("Error: {}", e),
}
// 24hr ticker price change statistics
match market.get_24h_price_stats("BNBETH") {
Ok(answer) => println!(
"Open Price: {}, Higher Price: {}, Lower Price: {:?}",
answer.open_price, answer.high_price, answer.low_price
),
Err(e) => println!("Error: {}", e),
}
// last 10 5min klines (candlesticks) for a symbol:
match market.get_klines("BNBETH", "5m", 10, None, None) {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
} ```
```rust extern crate binance;
use binance::api::; use binance::account::;
fn main() { let apikey = Some("YOURAPIKEY".into()); let secretkey = Some("YOURSECRETKEY".into());
let account: Account = Binance::new(api_key, secret_key);
match account.get_account() {
Ok(answer) => println!("{:?}", answer.balances),
Err(e) => println!("Error: {}", e),
}
match account.get_open_orders("WTCETH") {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
match account.limit_buy("WTCETH", 10, 0.014000) {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
match account.market_buy("WTCETH", 5) {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
match account.limit_sell("WTCETH", 10, 0.035000) {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
match account.market_sell("WTCETH", 5) {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
let order_id = 1_957_528;
match account.order_status("WTCETH", order_id) {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
match account.cancel_order("WTCETH", order_id) {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
match account.get_balance("KNC") {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
match account.trade_history("WTCETH") {
Ok(answer) => println!("{:?}", answer),
Err(e) => println!("Error: {}", e),
}
} ```
You can check out the Binance Error Codes
```rust use binance::errors::ErrorKind as BinanceLibErrorKind;
[...]
Err(err) => { println!("Can't put an order!");
match err.0 {
BinanceLibErrorKind::BinanceError(code, msg, response) => match code {
-1013_i16 => println!("Filter failure: LOT_SIZE!"),
-2010_i16 => println!("Funds insufficient! {}", msg),
_ => println!("Non-catched code {}: {}", code, msg),
},
BinanceLibErrorKind::Msg(msg) => {
println!("Binancelib error msg: {}", msg)
}
_ => println!("Other errors: {}.", err.0),
};
} ```
```rust extern crate binance;
use binance::api::; use binance::userstream::;
fn main() { let apikeyuser = Some("YOURAPIKEY".into()); let userstream: UserStream = Binance::new(apikey_user.clone(), None);
if let Ok(answer) = user_stream.start() {
println!("Data Stream Started ...");
let listen_key = answer.listen_key;
match user_stream.keep_alive(&listen_key) {
Ok(msg) => println!("Keepalive user data stream: {:?}", msg),
Err(e) => println!("Error: {}", e),
}
match user_stream.close(&listen_key) {
Ok(msg) => println!("Close user data stream: {:?}", msg),
Err(e) => println!("Error: {}", e),
}
} else {
println!("Not able to start an User Stream (Check your API_KEY)");
}
} ```
```rust extern crate binance;
use binance::api::; use binance::userstream::; use binance::websockets::*;
let apikeyuser = Some("YOURKEY".into()); let userstream: UserStream = Binance::new(apikeyuser, None);
if let Ok(answer) = userstream.start() { let listenkey = answer.listen_key;
let mut web_socket: WebSockets = WebSockets::new(|event: WebsocketEvent| {
match event {
WebsocketEvent::AccountUpdate(account_update) => {
for balance in &account_update.balance {
println!(
"Asset: {}, free: {}, locked: {}",
balance.asset, balance.free, balance.locked
);
}
},
WebsocketEvent::OrderTrade(trade) => {
println!(
"Symbol: {}, Side: {}, Price: {}, Execution Type: {}",
trade.symbol, trade.side, trade.price, trade.execution_type
);
},
_ => (),
};
Ok(())
});
web_socket.connect(&listen_key).unwrap(); // check error
if let Err(e) = web_socket.event_loop() {
match e {
err => {
println!("Error: {}", err);
}
}
}
} else { println!("Not able to start an User Stream (Check your API_KEY)"); } ```
```rust extern crate binance;
use binance::api::; use binance::websockets::;
let aggtrade: String = format!("!ticker@arr"); let mut websocket: WebSockets = WebSockets::new(|event: WebsocketEvent| { match event { WebsocketEvent::DayTicker(tickerevents) => { for tickevent in tickerevents { if tickevent.symbol == "BTCUSDT" { btcusdt = tickevent.averageprice.parse().unwrap(); let btcusdtclose: f32 = tickevent.currentclose.parse().unwrap(); println!("{} - {}", btcusdt, btcusdtclose); } } }, _ => (), };
Ok(())
});
websocket.connect(&aggtrade).unwrap(); // check error if let Err(e) = websocket.eventloop() { match e { err => { println!("Error: {}", err); } } } ```
```rust extern crate binance;
use binance::api::; use binance::websockets::;
let kline: String = format!("{}", "ethbtc@kline1m"); let mut websocket: WebSockets = WebSockets::new(|event: WebsocketEvent| { match event { WebsocketEvent::Kline(klineevent) => { println!( "Symbol: {}, high: {}, low: {}", klineevent.kline.symbol, klineevent.kline.low, klineevent.kline.high ); }, _ => (), }; Ok(()) });
websocket.connect(&kline).unwrap(); // check error if let Err(e) = websocket.event_loop() { match e { err => { println!("Error: {}", err); } } } ```
If you use Bitfinex check out my Rust library for bitfinex API