Crate squalo[][src]


🦈 Minimal, elegant, fast, async Kraken exchange WebSockets API client | Written in Rust


squalo library aims to interface your software with the Kraken exchange WebSockets API in no time.


The Kraken exchange allows WebSockets API interaction with both public and private data.

Only for the private one, you need to issue an API-Key and an API-Secret to the squalo library, in order to generate authentication token for signed subscriptions on WebSockets endpoints.

If you are not familiar with, please have a look at WebSockets API - FAQ for a general overview, or at WebSockets API document.


Add this to your Cargo.toml:

squalo = {version = 0.1.6}

and then add this to your code:

use squalo;



Description: prints crate information (name, description, version, author and repository).

squalo::set_kraken_api_credentials(api_key: String, api_secret: String);

Description: sets Kraken API credentials for private data access.


  • api_key: String
  • api_secret: String

Description: retrieves a WebSockets API token with a signed request from a Kraken REST API endpoint.

Output: returns a WebSockets API token in the String format.


Description: returns a couple of objects, an UnboundedSender (tx) and an UnboundedReceiver (rx) both used for bidirectional interoperation with the WebSocket client.

squalo::attach_websockets_stream(callback: fn(String), stream_type: String, receiver: UnboundedReceiver<Message>);

Description: spawns a thread which initializes a WebSocket client (accordingly with the stream_type). The receiver bridges the gap with the incoming data stream and the callback.


  • callback: fn (eg: fn callback(data: String) { println(“data: {}”, data); })
  • stream_type: String (eg “public” or “private”)
  • receiver: UnboundedReceiver<Message> (retrieved from the squalo::create_communication_channel() method)

Output: any incoming message forwared from the WebSockets stream to the issued callback comes in stringified JSON format (parse accordingly with the outcome shape).

squalo::send_message(transmitter: UnboundedSender<Message>, payload: String);

Description: fowards a message to the spawned thread handling the WebSocket client that will write the payload to the stream.


The example below shows how easy is to implement squalo from zero knowledge.

use squalo;
fn callback(data: String) {
    println!("data: {}", data);
async fn main() {
    // printing crate information
    // enveloping payload pointing at public endpoint
    let payload1 =
        r#"{"event":"subscribe", "subscription":{"name":"trade"}, "pair":["XRP/EUR", "ETH/USD"]}"#
    // creating communication channel for the websockets client
    let (tx1, rx1) = squalo::create_communication_channel();
    // attaching websockets to the public data stream
    squalo::attach_websockets_stream(callback, "public".to_string(), rx1);
    // transmitting payload to the websockets client
    squalo::send_message(tx1.to_owned(), payload1);
    // issuing credentials that enables private data interaction
    // requesting a websockets token
    let token = squalo::get_websockets_token().await;
    // enveloping message pointing at a private endpoint
    let payload2 = format!(
        r#"{{"event":"subscribe", "subscription":{{"name":"ownTrades", "token":"{}"}}}}"#,
    // creating communication channel for the websockets client
    let (tx2, rx2) = squalo::create_communication_channel();
    // attaching websockets to private data stream
    squalo::attach_websockets_stream(callback, "private".to_string(), rx2);
    // transmitting payload to the websockets client
    squalo::send_message(tx2.to_owned(), payload2);
    // enveloping the "ping" payload
    let ping = r#"{"event":"ping"}"#.to_string();
    // holding the main thread execution
    loop {
        // sleeping thread for 1 second
        // transmitting ping payload to the first client (public)
        squalo::send_message(tx1.to_owned(), ping.to_owned());
        // transmitting ping payload to the second client (private)
        squalo::send_message(tx2.to_owned(), ping.to_owned());


This software comes without any kind of warranties.

I will not be liable for any damages related to the use or the misuse of this software.

You are the sole responsible.