You need to enable JavaScript to run this app

Click the "Customize" menu button in the top-right corner of the Chrome window

Select the Settings menu item

At the bottom, click Advanced

Under Privacy and security, click Site settings

Click JavaScript

Turn on Allowed (recommended)

Click the Safari menu

Click the Preference menu item

Click on the Security tab

Click the Enable Javascript checkbox

Close the Preferences window. JavaScript is now enabled

Open the "Easy Setup" menu In the top right corner of the Opera window

At the very bottom, click Go to browser settings

Search for Javascript

Click Site settings

Click JavaScript

Choose your JavaScript settings

Click into the Address Bar, type in about:config and press enter

Accept the warning about changing advanced settings

Type javascript into the search field

Find the javascript:enabled preference

Reset the JavaScript preference to default (enabled)

Select the Tools menu

Select Internet Options

Select the Security tab

Click the Custom level... button

Scroll down to the sub-section Active scripting under Scripting section, click Enable

Confirm the change

Build your first application

New user guides

Examples and tutorials

Core concepts

Schemas and data formats

Standards and conventions

Support

Quickstart

Set up Databento

You need an API key to request data from Databento. Sign up and you will automatically receive an API key. Each API key is a 32-character string starting with db-, that can be found from the API keys page on your portal.

Info
Every new account receives $125 in free data credits. These credits allow you to start receiving actual historical data immediately and verify your integration at no cost.

Choose a service

Databento provides two data services: historical and live. These two services are nearly identical, but we separate them due to licensing fees and the differences between response-request and real-time streaming APIs. You can choose to integrate just one or both services.

	Historical	Live	Reference
Coverage	Data from at least 24 hours ago.	Intraday historical data from within the last 24 hours and real-time data.	Historical with intraday updates.
Pricing	Usage-based or flat-rate. No monthly license fees.	Usage-based or flat-rate. Monthly license fees apply.	Dataset license fees apply.
Access	Client libraries (C++, Python, and Rust) and API (HTTP).	Client libraries (C++, Python, and Rust) and API (Raw).	Client libraries (Python) and API (HTTP).

Build your first application

Historical

Live

Reference

Select how you will be integrating Databento below to see installation instructions.

If you don't see an official client library for your preferred language, you can still integrate our historical service through its HTTP API.

HISTORICAL DATA

Client libraries

Python

C++

Rust

APIs

HTTP

git clone https://github.com/databento/databento-cpp.git

The easiest way of using our library is by embedding it with CMake FetchContent. The minimum required CMake version is 3.14. Create a CMakeLists.txt that looks like the following:

You'll also need to ensure the following dependencies are installed:

OpenSSL (minimum version 3.0)
Libcrypto
Zstandard (zstd)

PythonC++RustHTTP

      
    
# CMakeLists.txt
cmake_minimum_required(VERSION 3.24)

project(databento_historical_example)
include(FetchContent)

FetchContent_Declare(
  databento
  GIT_REPOSITORY https://github.com/databento/databento-cpp
  GIT_TAG HEAD
)
FetchContent_MakeAvailable(databento)

add_executable(example main.cpp)
target_link_libraries(example PRIVATE databento::databento)

A simple Databento application looks like this:

PythonC++RustHTTP

      
    
#include <databento/constants.hpp>
#include <databento/historical.hpp>
#include <iostream>

using namespace databento;

int main() {
  auto client =
      Historical::Builder().SetKey("YOUR_API_KEY").Build();
  auto print_trades = [](const Record& record) {
    const auto& trade_msg = record.Get<TradeMsg>();
    std::cout << trade_msg << '\n';
    return KeepGoing::Continue;
  };
  client.TimeseriesGetRange(
      "GLBX.MDP3", {"2022-06-10T14:30", "2022-06-10T14:40"},
      kAllSymbols, Schema::Trades, SType::RawSymbol,
      SType::InstrumentId, {}, {}, print_trades);
}

Copy this to a file named main.cpp in the same directory as the CMakeLists.txt, then compile and run the application.

This replays 10 minutes of trades of the entire CME Globex market event-by-event. You can modify this application to specify particular instruments, and schemas,

PythonC++RustHTTP

cmake -S . -B build            # configure
cmake --build build --parallel # build
./build/example                # run

Let's get ESM2 and NQZ2 data in 1-second OHLCV bars:

PythonC++RustHTTP

      
    
#include <databento/dbn.hpp>
#include <databento/historical.hpp>
#include <databento/symbol_map.hpp>
#include <iostream>

using namespace databento;

int main() {
  auto client =
      Historical::Builder().SetKey("YOUR_API_KEY").Build();
  TsSymbolMap symbol_map;
  auto decode_symbols = [&symbol_map](const Metadata& metadata) {
    symbol_map = metadata.CreateSymbolMap();
  };
  auto print_trades = [&symbol_map](const Record& record) {
    const auto& trade_msg = record.Get<TradeMsg>();
    std::cout << "Received trade for "
              << symbol_map.At(trade_msg) << ": " << trade_msg
              << '\n';
    return KeepGoing::Continue;
  };
  client.TimeseriesGetRange(
      "GLBX.MDP3", {"2022-06-10T14:30", "2022-06-10T14:40"},
      {"ESM2", "NQZ2"}, Schema::Trades, SType::RawSymbol,
      SType::InstrumentId, {}, decode_symbols, print_trades);
}

Rebuild and run the application with:

PythonC++RustHTTP

cmake --build build --parallel
./build/example

You have successfully written your first historical data application with Databento! Here are shortcuts to some of the next steps you can take:

To download a large amount of data to disk, see how to do a batch download of data files.
To get another dataset, just swap the dataset. You can get a list of datasets and their names from our metadata.
You can use our symbology API to find other instrument IDs.
You can also find dataset names and instrument IDs interactively from our search.

To learn more, read the full documentation for our historical service under API reference - Historical.

Let's get ESZ5 and ESZ5 C6000 data in 1-second OHLCV bars. We'll also handle unexpected messages and errors in case something goes wrong. Since we're handling more messages, it makes sense to change to a switch statement based on the rtype or record type field in the header of each record.

Rebuild and run the application with:

PythonC++RustHTTP

      
    
#include <chrono>
#include <databento/live.hpp>
#include <databento/symbol_map.hpp>
#include <iostream>
#include <string>
#include <thread>

using namespace databento;

int main() {
  PitSymbolMap symbol_mappings;

  auto client = LiveThreaded::Builder()
                    .SetKey("YOUR_API_KEY")
                    .SetDataset("GLBX.MDP3")
                    .BuildThreaded();

  auto handler = [&symbol_mappings](const Record& rec) {
    if (auto* trade = rec.GetIf<TradeMsg>()) {
      std::cout << "Received trade for "
                << symbol_mappings[trade->hd.instrument_id]
                << ':' << *trade << '\n';
    } else if (auto* mapping = rec.GetIf<SymbolMappingMsg>()) {
      std::cout << "Received symbol mapping: " << *mapping
                << '\n';
      symbol_mappings.OnSymbolMapping(*mapping);
    } else if (auto* system_msg = rec.GetIf<SystemMsg>()) {
      if (!system_msg->IsHeartbeat()) {
        std::cout << "Received system msg: " << system_msg->Msg()
                  << '\n';
      }
    } else if (auto* error_msg = rec.GetIf<ErrorMsg>()) {
      std::cerr << "Received error from gateway: "
                << error_msg->Err() << '\n';
    } else {
      std::cerr << "Received unknown record with rtype "
                << std::hex
                << static_cast<std::uint16_t>(rec.RType())
                << '\n';
    }
    return KeepGoing::Continue;
  };

  client.Subscribe({"ESZ5", "ESZ5 C6000"}, Schema::Trades,
                   SType::RawSymbol);
  client.Start(handler);
  std::this_thread::sleep_for(std::chrono::seconds{10});
  return 0;
}

PythonC++RustHTTP

cmake --build build --parallel
./build/example

New user guides

What's a schema?

See fields and columns included with each schema.

Symbology

How to interpret instrument IDs, symbols, and definitions.

Normalization format

Learn more about our data normalization.

DBN files and encoding

Save and read our data in DBN, our lightning-fast binary format.

Equities

Get started on equities data like Nasdaq TotalView-ITCH.

Equity options

Get started on equity options data like OPRA.

Futures

Get started on futures data like CME Globex MDP 3.0.

Options on futures

Get started on options on futures data.

Quickstart

Set up Databento

Choose a service

Build your first application

Getting historical data

Getting live data

New user guides