Migrate from Databento

This guide is for developers who use the Databento Historical or Live API and want to move some or all of that work to Massive. It maps each common schema to the Massive endpoint that replaces it, and lists the differences that change your results. To compare the two products before you switch, see Massive vs Databento.

You do not need to move everything. Massive currently doesn't have L2 or L3 order book data, but new data and features ship often, so check the product roadmap for what's planned. If you use mbp-10 or mbo, keep Databento for that work and use Massive for longer stock history, options, forex, crypto, and fundamentals.

Before you start

• Sign up and copy your API key from the dashboard.
• Pick a plan for each market you use on the pricing page.
• Read the REST quickstart for the response shape that every endpoint shares.

Using AI?

Paste this into Claude Code, Cursor, Codex, or any coding agent that can read files and fetch a URL:

Find every place my project calls Databento.
Switch those calls to the Massive REST API, except for order book schemas such as mbp-10 and mbo.
Read https://massive.com/docs/migration/guides/databento.md for the endpoint map and the differences to handle.
Read https://massive.com/docs/llms.txt for the rest of the API.
Read the API key from the MASSIVE_API_KEY environment variable.
Keep my function signatures and data shapes the same, and list anything Massive does not cover.

To let the agent check real responses while it works, connect the Massive MCP server. Massive also publishes skills and plugins for coding agents.

The request

Databento has one call, timeseries.get_range, and the dataset and schema pick the data. Massive has one path per data type.

Databento's end is exclusive, so a range that ends on October 3 sets end="2025-10-04":

import databento as db

client = db.Historical("YOUR_API_KEY")
df = client.timeseries.get_range(
    dataset="EQUS.SUMMARY",
    schema="ohlcv-1d",
    symbols=["AAPL"],
    start="2025-10-01",
    end="2025-10-04",
).to_df()

Massive's to date is inclusive, so the range ends on October 3:

from massive import RESTClient

client = RESTClient("YOUR_API_KEY")
bars = list(client.list_aggs("AAPL", 1, "day", "2025-10-01", "2025-10-03", adjusted=False))

curl "https://api.massive.com/v2/aggs/ticker/AAPL/range/1/day/2025-10-01/2025-10-03?adjusted=false" \
  -H "Authorization: Bearer YOUR_API_KEY"

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/massive-com/client-go/v3/rest"
	"github.com/massive-com/client-go/v3/rest/gen"
)

func main() {
	c := rest.NewWithOptions("YOUR_API_KEY", rest.WithPagination(true))
	ctx := context.Background()

	params := &gen.GetStocksAggregatesParams{
		Adjusted: rest.Ptr(false),
		Sort:     "asc",
	}

	resp, err := c.GetStocksAggregatesWithResponse(ctx, "AAPL", 1, "day", "2025-10-01", "2025-10-03", params)
	if err != nil {
		log.Fatal(err)
	}
	if err := rest.CheckResponse(resp); err != nil {
		log.Fatal(err)
	}

	iter := rest.NewIteratorFromResponse(c, resp)
	for iter.Next() {
		fmt.Printf("%+v\n", iter.Item())
	}
	if err := iter.Err(); err != nil {
		log.Fatal(err)
	}
}

import { restClient } from '@massive.com/client-js';

const rest = restClient('YOUR_API_KEY', 'https://api.massive.com');

const response = await rest.getStocksAggregates({
  stocksTicker: "AAPL",
  multiplier: "1",
  timespan: "day",
  from: "2025-10-01",
  to: "2025-10-03",
  adjusted: "false"
});

import com.massive.client.apis.DefaultApi
import com.massive.client.apis.DefaultApi.TimespanGetStocksAggregates
import com.massive.client.infrastructure.*

fun main() {
    ApiClient.apiKey["apiKey"] = "YOUR_API_KEY"

    val bars = DefaultApi().getStocksAggregates(
        stocksTicker = "AAPL",
        multiplier = 1,
        timespan = TimespanGetStocksAggregates.day,
        from = "2025-10-01",
        to = "2025-10-03",
        adjusted = false
    )
    println(bars)
}

• Auth. Databento uses HTTP Basic with the key as the username. Massive takes the key in an Authorization: Bearer header.
• Long ranges. Databento streams the whole range in one response. Massive returns a next_url when there is more data. The Python client follows it for you.
• Cost. Massive plans are a flat monthly price, so you can remove calls to metadata.get_cost.

The response

Massive returns JSON, with one object per bar:

{
  "results": [
    {
      "t": 1759291200000,
      "o": 255.04,
      "h": 258.79,
      "l": 254.93,
      "c": 255.45,
      "v": 48713940,
      "vw": 256.004,
      "n": 535581
    }
  ]
}

• Daily bars. Databento ohlcv-1d uses UTC dates. Massive daily bars use Eastern Time sessions.
• Trades and quotes. Massive trades and quotes use nanosecond timestamps, like Databento.
• Futures bars. Futures Aggregates keep Databento's field names, such as open and high, and put a nanosecond timestamp in window_start.
• Quotes. Massive stock quotes are the consolidated NBBO. Databento mbp-1 on a venue dataset, such as XNAS.ITCH, is that venue's top of book, so prices and sizes differ.

Symbols

Prices

• Databento sells adjustment factors as a separate dataset. Set adjusted=false on Massive when you compare the two.
• EQUS.SUMMARY daily bars come from the Nasdaq summary, which includes post-market volume, so volume and close can differ.

Sources: Databento quickstart, timeseries.get_range, symbology, OHLCV schema.

Endpoint map

This map covers the most common calls. It is not a full list. To find the Massive endpoint for another call, search these docs.

Massive adds data that Databento does not sell: fundamentals, news, forex, and crypto.

Streaming

The Databento Live API is a raw TCP connection to one gateway per dataset, with DBN or JSON records. Massive streams JSON over WebSockets, with one connection per asset class:

• Stocks: wss://socket.massive.com/stocks, with trades, quotes, second bars, and minute bars.
• Options: wss://socket.massive.com/options, with trades and quotes.
• Futures: wss://socket.massive.com/futures, with trades and quotes.

This is a rewrite of the transport, not a port. Massive has no intraday replay, so use the REST endpoints to backfill after a reconnect. See the WebSocket quickstart.

Bulk history

Databento's batch.submit_job builds files for you to download, billed per GB. Massive flat files are already built and included in every paid plan. Download them over S3 from https://files.massive.com. Each file holds one day of one data type, such as stock trades, stock quotes, or options daily bars.

SDKs

Sources

Databento details were checked against the Databento documentation on October 29, 2026. Databento is a trademark of its owner. Massive is not affiliated with Databento.