Upcoming changes to the live API

On Sunday, April 26, 2026, we're rolling out two updates to the live API:

1. Slow reader behavior will default to skip for certain schemas
2. Symbol resolution errors will no longer terminate the session

These changes aim to reduce perceived latency and improve developer experience, but may introduce breaking changes for some customers. Details for each change are outlined below, including how to continue using the current behavior if preferred.

When a live client processes records more slowly than the gateway sends them—for example, during periods of high message throughput—the gateway detects that the session has fallen behind real time.

The slow_reader_behavior parameter determines how the gateway handles this and can be set to warn or skip when creating the client.

• warn: The gateway continues sending all records and periodically sends a SystemMsg with code = SlowReaderWarning (2) while the client is behind.
• skip: The gateway drops records until the session is current, then sends an ErrorMsg with code = SkippedRecordsAfterSlowReading (7) before continuing in real time.

Currently, the default behavior is warn for all schemas, which means the gateway buffers and sends stale records until the client catches up. This can increase observed latency, measured by the difference between the ts_out (send) and ts_recv (receive) timestamps.

This behavior is often undesirable for stateless schemas, where each update already reflects the latest state at that point in time (e.g., best bid and offer or aggregated depth). As a result, skipping stale records and returning to real time is typically preferred.

For these schemas, the default value of slow_reader_behavior will change from warn to skip: MBP-1, CMBP-1, MBP-10, BBO-1s/1m, and CBBO-1s/1m.

All other schemas are unaffected and will continue using warn as the default since dropping records may result in missed events or gaps in the data.

To continue using warn for the stateless schemas listed above, set the slow_reader_behavior parameter to warn when creating the live client. The following examples demonstrate this in Python, Rust, and C++.

Python

import databento as db

client = db.Live(slow_reader_behavior="warn")

Rust

use databento::{LiveClient, live::SlowReaderBehavior};

let client = LiveClient::builder()
    .key_from_env()?
    .slow_reader_behavior(SlowReaderBehavior::Warn)
    .build()
    .await?;

C++

#include <databento/enums.hpp>
#include <databento/live.hpp>

namespace db = databento;

auto client = db::LiveBlocking::Builder()
  .SetKeyFromEnv()
  .SetSlowReaderBehavior(db::SlowReaderBehavior::Warn)
  .BuildBlocking()

When subscribing to live data, each symbol specified in the symbols parameter is resolved (matched) to one or more instruments in the dataset. Currently, if any symbols don't exist, they fail to resolve, and the gateway closes the session.

Subscribing to an invalid symbol will no longer automatically terminate the session. The gateway will still send an ErrorMsg record for each symbol that fails to resolve, but any available symbols will be streamed. If none of the requested symbols resolve, the session will remain open, but no data will be received.

This has been a common request, especially for workflows involving weekly and daily options, where symbols change frequently as contracts are listed and expire.

To continue treating unresolved symbols as a failure, ensure your client terminates the session when an ErrorMsg with code = SymbolResolutionFailed (4) is received.