binance-rs

Unofficial Rust Library for the Binance API and Binance Futures API

Binance API Telegram

Risk Warning

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.

Usage

Add this to your Cargo.toml

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

Rust >= 1.41

rust rustup install stable

MARKET DATA
ACCOUNT DATA
ERROR HANDLING
USER STREAM CONFIGURATION
WEBSOCKETS

MARKET DATA

```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("BNBETH") {
    Ok(answer) => println!("{:?}", answer),
    Err(e) => println!("Error: {}", e),
}

// Current average price for ONE symbol
match market.get_average_price("BNBETH") {
    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),
}

} ```

ACCOUNT DATA

```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),
}

match account.custom_order("WTCETH", 9999, 0.0123, "SELL", "LIMIT", "IOC") {
    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),
}

} ```

ERROR HANDLING

Provides more detailed error information

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(response) => match response.code {
        -1013_i16 => println!("Filter failure: LOT_SIZE!"),
        -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),
};

} ```

USER STREAM CONFIGURATION

```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)");
}

} ```

USER STREAM

```rust extern crate binance;

use binance::api::; use binance::userstream::; use binance::websockets::*; use std::sync::atomic::{AtomicBool};

fn main() { let apikeyuser = Some("YOURKEY".into()); let keeprunning = 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 listen_key = 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(&keep_running) {
    match e {
        err => {
            println!("Error: {}", err);
        }
    }
     }
} else {
    println!("Not able to start an User Stream (Check your API_KEY)");
}

} ```

TRADES

```rust extern crate binance;

use binance::websockets::*; use std::sync::atomic::{AtomicBool};

fn main() { let keeprunning = AtomicBool::new(true); // Used to control the event loop let aggtrade: String = format!("!ticker@arr"); // All Symbols let mut websocket: WebSockets = WebSockets::new(|event: WebsocketEvent| { match event { // 24hr rolling window ticker statistics for all symbols that changed in an array. WebsocketEvent::DayTickerAll(tickerevents) => { for tickevent in tickerevents { if tickevent.symbol == "BTCUSDT" { let btcusdt: f32 = tickevent.averageprice.parse().unwrap(); let btcusdtclose: f32 = tickevent.currentclose.parse().unwrap(); println!("{} - {}", btcusdt, btcusdt_close); } } }, _ => (), };

    Ok(())
});

web_socket.connect(&agg_trade).unwrap(); // check error
if let Err(e) = web_socket.event_loop(&keep_running) {
match e {
    err => {
        println!("Error: {}", err);
    }
}
 }

} ```

KLINE

```rust extern crate binance;

use binance::websockets::*; use std::sync::atomic::{AtomicBool};

fn main() { let keeprunning = AtomicBool::new(true); // Used to control the event loop 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, kline_event.kline.high); }, _ => (), }; Ok(()) });

web_socket.connect(&kline).unwrap(); // check error
if let Err(e) = web_socket.event_loop(&keep_running) {
    match e {
      err => {
         println!("Error: {}", err);
      }
    }
 }
 web_socket.disconnect().unwrap();

}

```

MULTIPLE STREAMS

```rust extern crate binance;

use binance::websockets::*; use std::sync::atomic::{AtomicBool};

fn main() { let symbols: Vec<_> = vec!["ethbtc", "bnbeth"].into_iter().map(String::from).collect(); let mut endpoints: Vec = Vec::new();

for symbol in symbols.iter() {
    endpoints.push(format!("{}@depth@100ms", symbol.to_lowercase()));
}

let keep_running = AtomicBool::new(true);
let mut web_socket: WebSockets<'_> = WebSockets::new(|event: WebsocketEvent| {
    if let WebsocketEvent::DepthOrderBook(depth_order_book) = event {
        println!("{:?}", depth_order_book);
    }

    Ok(())
});

web_socket.connect_multiple_streams(&endpoints).unwrap(); // check error
if let Err(e) = web_socket.event_loop(&keep_running) {
    println!("Error: {}", e);
}
web_socket.disconnect().unwrap();

}

```

Other Exchanges

If you use Bitfinex check out my Rust library for bitfinex API

binance-rs

Binance API Telegram

Risk Warning

Usage

Rust >= 1.41

Table of Contents

MARKET DATA

ACCOUNT DATA

ERROR HANDLING

USER STREAM CONFIGURATION

USER STREAM

TRADES

KLINE

MULTIPLE STREAMS

Other Exchanges