binance-rs

Unofficial Rust Library for the Binance API and Binance Futures API (Under development with upcoming breaking changes)

Documentation on docs.rs

Binance API Telegram

apienglish>

Usage

Add this to your Cargo.toml

[dependencies]
binance = { git = "https://github.com/ccxt/binance-rs.git" }

Rust >= 1.56.1

rustup install stable

MARKET DATA

use binance::api::*;
use binance::model::*;
use binance::market::*;
fn main() {     let market: Market = Binance::new(None, None);
// Order book at default depth     match market.get_depth("BNBETH") {         Ok(answer) => println!("{:?}", answer),         Err(e) => println!("Error: {}", e),     }
// Order book at depth 500     match market.getcustomdepth("BNBETH", 500) {         Ok(answer) => println!("{:?}", answer),         Err(e) => println!("Error: {}", e),     }
// Latest price for ALL symbols     match market.getallprices() {         Ok(answer) => println!("{:?}", answer),         Err(e) => println!("Error: {:?}", e),     }
// Latest price for ONE symbol     match market.get_price("BNBETH") {         Ok(answer) => println!("{:?}", answer),         Err(e) => println!("Error: {:?}", e),     }
// Current average price for ONE symbol     match market.getaverageprice("BNBETH") {         Ok(answer) => println!("{:?}", answer),         Err(e) => println!("Error: {:?}", e),     }
// Best price/qty on the order book for ALL symbols     match market.getallbook_tickers() {         Ok(answer) => println!("{:?}", answer),         Err(e) => println!("Error: {:?}", e),     }
// Best price/qty on the order book for ONE symbol     match market.getbookticker("BNBETH") {         Ok(answer) => println!(             "Bid Price: {}, Ask Price: {}",             answer.bidprice, answer.askprice         ),         Err(e) => println!("Error: {:?}", e),     }
// 24hr ticker price change statistics     match market.get24hprice_stats("BNBETH") {         Ok(answer) => println!(             "Open Price: {}, Higher Price: {}, Lower Price: {:?}",             answer.openprice, answer.highprice, 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(klines) => {                match klines {                 binance::model::KlineSummaries::AllKlineSummaries(klines) => {                     let kline: KlineSummary = klines[0].clone(); // You need to iterate over the klines                     println!(                         "Open: {}, High: {}, Low: {}",                         kline.open, kline.high, kline.low                     )                 }             }         },         Err(e) => println!("Error: {}", e),     } }

ACCOUNT DATA

use binance::api::*;
use binance::account::*;
fn main() {     let apikey = Some("YOURAPI_KEY".into());     let secretkey = Some("YOURSECRET_KEY".into());
let account: Account = Binance::new(apikey, secretkey);
match account.get_account() {         Ok(answer) => println!("{:?}", answer.balances),         Err(e) => println!("Error: {:?}", e),     }
match account.getopenorders("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),     }
match account.custom_order("WTCETH", 9999, 0.0123, "SELL", "LIMIT", "IOC") {         Ok(answer) => println!("{:?}", answer),         Err(e) => println!("Error: {:?}", e),     }
let orderid = 1957_528;     match account.orderstatus("WTCETH", orderid) {         Ok(answer) => println!("{:?}", answer),         Err(e) => println!("Error: {:?}", e),     }
match account.cancelorder("WTCETH", orderid) {         Ok(answer) => println!("{:?}", answer),         Err(e) => println!("Error: {:?}", e),     }
match account.cancelallopen_orders("WTCETH") {         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),     } }

ERROR HANDLING

Provides more detailed error information

You can check out the Binance Error Codes

use binance::errors::ErrorKind as BinanceLibErrorKind;
[...]
Err(err) => {     println!("Can't put an order!");
match err.0 {         BinanceLibErrorKind::BinanceError(response) => match response.code {             -1013i16 => println!("Filter failure: LOTSIZE!"),             -2010_i16 => println!("Funds insufficient! {}", response.msg),             _ => println!("Non-catched code {}: {}", response.code, response.msg),         },         BinanceLibErrorKind::Msg(msg) => {             println!("Binancelib error msg: {}", msg)         }         _ => println!("Other errors: {}.", err.0),     }; }

TESTNET AND API CLUSTERS

You can overwrite the default binance api urls if there are performance issues with the endpoints.

You can check out the Binance API Clusters.

The same is applicable for Testnet and Binance.US support. See example below:

let general: General = if use_testnet {
    let config = Config::default().setrestapi_endpoint("https://testnet.binance.vision");
                                  // .setwsendpoint("wss://testnet.binance.vision/ws")
                                  // .setfuturesrestapiendpoint("https://testnet.binancefuture.com/api")
                                  // .setfuturesws_endpoint("https://testnet.binancefuture.com/ws")
    Binance::newwithconfig(None, None, &config)
} else {
    Binance::new(None, None)
};

USER STREAM CONFIGURATION

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 listenkey = answer.listenkey;
match userstream.keepalive(&listen_key) {             Ok(msg) => println!("Keepalive user data stream: {:?}", msg),             Err(e) => println!("Error: {:?}", e),         }
match userstream.close(&listenkey) {             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)");     } }

USER STREAM

use binance::api::*;
use binance::userstream::*;
use binance::websockets::*;
use std::sync::atomic::{AtomicBool};
fn main() {     let apikeyuser = Some("YOUR_KEY".into());     let keep_running = AtomicBool::new(true); // Used to control the event loop     let userstream: UserStream = Binance::new(apikey_user, None);
if let Ok(answer) = user_stream.start() { 	let listenkey = answer.listenkey;
let mut web_socket = 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(()) 	});
websocket.connect(&listenkey).unwrap(); // check error 	    if let Err(e) = websocket.eventloop(&keep_running) { 		match e { 		    err => { 		        println!("Error: {:?}", err); 		    } 		} 	     } 	} else { 	    println!("Not able to start an User Stream (Check your API_KEY)"); 	} }

TRADES

use binance::websockets::*;
use std::sync::atomic::{AtomicBool};
fn main() {     let keep_running = AtomicBool::new(true); // Used to control the event loop     let agg_trade = format!("!ticker@arr"); // All Symbols     let mut web_socket = WebSockets::new(|event: WebsocketEvent| { 	match event {         // 24hr rolling window ticker statistics for all symbols that changed in an array. 	    WebsocketEvent::DayTickerAll(ticker_events) => { 	        for tickevent in tickerevents { 		    if tick_event.symbol == "BTCUSDT" { 			let btcusdt: f32 = tickevent.averageprice.parse().unwrap(); 			let btcusdtclose: f32 = tickevent.current_close.parse().unwrap(); 			println!("{} - {}", btcusdt, btcusdt_close); 		    } 		} 	    }, 	    _ => (),         };
Ok(())     });
websocket.connect(&aggtrade).unwrap(); // check error     if let Err(e) = websocket.eventloop(&keep_running) { 	match e { 	    err => { 	        println!("Error: {:?}", err); 	    } 	}      } }

KLINE

use binance::websockets::*;
use std::sync::atomic::{AtomicBool};
fn main() {     let keep_running = AtomicBool::new(true); // Used to control the event loop     let kline = format!("{}", "ethbtc@kline_1m");     let mut web_socket = WebSockets::new(|event: WebsocketEvent| {         match event {             WebsocketEvent::Kline(kline_event) => {                 println!("Symbol: {}, high: {}, low: {}", klineevent.kline.symbol, klineevent.kline.low, kline_event.kline.high);             },             _ => (),         };         Ok(())     });       web_socket.connect(&kline).unwrap(); // check error     if let Err(e) = websocket.eventloop(&keep_running) {         match e {           err => {              println!("Error: {:?}", err);           }         }      }      web_socket.disconnect().unwrap(); }

MULTIPLE STREAMS

use binance::websockets::*;
use std::sync::atomic::{AtomicBool};
fn main() {     let endpoints = ["ETHBTC", "BNBETH"]         .map(|symbol| format!("{}@depth@100ms", symbol.to_lowercase()));
let keep_running = AtomicBool::new(true);     let mut web_socket = WebSockets::new(|event: WebsocketEvent| {         if let WebsocketEvent::DepthOrderBook(depthorderbook) = event {             println!("{:?}", depthorderbook);         }
Ok(())     });
websocket.connectmultiple_streams(&endpoints).unwrap(); // check error     if let Err(e) = websocket.eventloop(&keep_running) {         println!("Error: {:?}", e);     }     web_socket.disconnect().unwrap(); }