databento-rs

The official Rust client library for Databento. The clients support fast and safe streaming of both real-time and historical market data through similar interfaces. The library is built on top of the tokio asynchronous runtime and Databento's efficient binary encoding.

You can find getting started tutorials, full API method documentation, examples with output on the Databento docs site.

Installation

To add the crate to an existing project, run the following command:

cargo add databento

Feature flags

• historical: enables the historical client for data older than 24 hours
• live: enables the live client for real-time and intraday historical data

By default both features are enabled and the historical client uses OpenSSL for TLS. To use rustls, disable default features for both the databento crate and reqwest.

databento = { features = ["historical"], default-features = false }
reqwest = { features = ["rustls-tls"], default-features = false }

Usage

Historical

Here is a simple program that fetches 10 minutes worth of historical trades for E-mini S&P 500 futures from CME Globex:

use std::error::Error;

use databento::{
    dbn::{decode::DbnMetadata, Dataset, SType, Schema, TradeMsg},
    historical::timeseries::GetRangeParams,
    HistoricalClient,
};
use time::macros::{date, datetime};

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let mut client = HistoricalClient::builder().key_from_env()?.build()?;
    let mut decoder = client
        .timeseries()
        .get_range(
            &GetRangeParams::builder()
                .dataset(Dataset::GlbxMdp3)
                .date_time_range((
                    datetime!(2022-06-10 14:30 UTC),
                    datetime!(2022-06-10 14:40 UTC),
                ))
                .symbols("ES.FUT")
                .stype_in(SType::Parent)
                .schema(Schema::Trades)
                .build(),
        )
        .await?;
    let symbol_map = decoder
        .metadata()
        .symbol_map_for_date(date!(2022 - 06 - 10))?;
    while let Some(trade) = decoder.decode_record::<TradeMsg>().await? {
        let symbol = &symbol_map[trade];
        println!("Received trade for {symbol}: {trade:?}");
    }
    Ok(())
}

To run this program, set the DATABENTO_API_KEY environment variable with an API key and run cargo bin --example historical.

Live

Real-time and intraday replay is provided through the Live clients. Here is a simple program that fetches the next E-mini S&P 500 futures trade:

use std::error::Error;

use databento::{
    dbn::{Dataset, PitSymbolMap, SType, Schema, TradeMsg},
    live::Subscription,
    LiveClient,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let mut client = LiveClient::builder()
        .key_from_env()?
        .dataset(Dataset::GlbxMdp3)
        .build()
        .await?;
    client
        .subscribe(
            Subscription::builder()
                .symbols("ES.FUT")
                .schema(Schema::Trades)
                .stype_in(SType::Parent)
                .build(),
        )
        .await
        .unwrap();
    client.start().await?;

    let mut symbol_map = PitSymbolMap::new();
    // Get the next trade
    while let Some(rec) = client.next_record().await? {
        if let Some(trade) = rec.get::<TradeMsg>() {
            let symbol = &symbol_map[trade];
            println!("Received trade for {symbol}: {trade:?}");
            break;
        }
        symbol_map.on_record(rec)?;
    }
    Ok(())
}

To run this program, set the DATABENTO_API_KEY environment variable with an API key and run cargo run --example live

License

Distributed under the Apache 2.0 License.