Skip to main content

​
Overview

KrakenClient is the primary interface for streaming market data. It manages connections, orderbook state, and event distribution.

​
Creation

use kraken_sdk::prelude::*;

let client = KrakenClient::builder(vec!["BTC/USD".into()])
    .with_depth(Depth::D10)
    .with_book(true)
    .connect()
    .await?;
See Builder Configuration for all options.

​
Methods

​
Market Data

MethodReturnDescription
best_bid(symbol)Option<Decimal>Highest bid price
best_ask(symbol)Option<Decimal>Lowest ask price
spread(symbol)Option<Decimal>Ask minus bid
mid_price(symbol)Option<Decimal>(Bid + Ask) / 2
orderbook(symbol)Option<OrderbookSnapshot>Full orderbook
// Query prices
if let Some(spread) = client.spread("BTC/USD") {
    println!("Spread: {}", spread);
}

if let Some(bid) = client.best_bid("BTC/USD") {
    println!("Best bid: {}", bid);
}

​
State

MethodReturnDescription
is_synced(symbol)boolOrderbook valid
is_connected()boolWebSocket open
if client.is_synced("BTC/USD") && client.is_connected() {
    // Safe to use orderbook data
}

​
Events

let mut events = client.events();

while let Some(event) = events.recv().await {
    // Handle event
}
events() can only be called once. It takes ownership of the receiver.

​
Lifecycle

// Graceful shutdown
client.shutdown();

​
Thread Safety

KrakenClient is Send + Sync. Safe to share across threads: 
use std::sync::Arc;

let client = Arc::new(client);
let client_clone = client.clone();

tokio::spawn(async move {
    loop {
        let spread = client_clone.spread("BTC/USD");
        // ...
    }
});
Reads are lock-free. Multiple threads can query simultaneously without blocking.

​
Full Example

use kraken_sdk::prelude::*;
use std::sync::Arc;
use tokio::signal;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Arc::new(
        KrakenClient::builder(vec!["BTC/USD".into(), "ETH/USD".into()])
            .with_depth(Depth::D10)
            .with_book(true)
            .connect()
            .await?
    );

    // Spawn price monitor
    let client_monitor = client.clone();
    tokio::spawn(async move {
        loop {
            for symbol in ["BTC/USD", "ETH/USD"] {
                if let Some(spread) = client_monitor.spread(symbol) {
                    println!("{}: {}", symbol, spread);
                }
            }
            tokio::time::sleep(Duration::from_secs(1)).await;
        }
    });

    // Wait for shutdown
    signal::ctrl_c().await?;
    client.shutdown();

    Ok(())
}