FXMacroData vs Databento: Tick-Level Market Data vs FX Macro Release Data

This comparison is for quant developers, FX futures traders, and research teams who are deciding how to build an event-study or release-trading stack: do you need tick-level market data, macro release data, or both? Databento and FXMacroData are often mentioned in the same breath because both are self-serve, developer-first data APIs, but they answer different halves of the same question.

The core finding is simple. Databento sells normalized, nanosecond-timestamped market data (CME Globex futures including the FX futures such as 6E and 6J, US equities, options, and other venues) with usage-based historical pricing and flat-rate subscriptions. FXMacroData sells the macro side: official-source release values for 22 currencies, each with a second-level announcement_datetime, plus the release calendar, FX context, and MCP access. For a release study you usually want Databento for the price reaction and FXMacroData for the event clock, and FXMacroData is the lower-cost, purpose-built choice for the macro half.

Decision snapshot

Choose Databento when

You need trades, top-of-book, depth, or full order-book (MBO) history and live feeds for CME futures, equities, or options, timestamped to the nanosecond.

Choose FXMacroData when

You need the macro event itself: CPI, payrolls, policy rates and 700+ other series across 22 currencies, with the exact second each value was published.

Quick answer

They are complements, not substitutes. Join Databento 6E ticks to FXMacroData release timestamps and you have a clean event study. FXMacroData Individual costs $50/month; Databento's CME Standard plan is $199/month*.

Takeaway: Databento tells you what the market did; FXMacroData tells you what was released and exactly when.

Pricing and access

Both companies publish prices, which already puts them ahead of most institutional vendors. Databento's model has two layers. Historical data is pay-as-you-go, billed by the uncompressed size of the data you request, with CME history advertised from $0.50/GB*. Live data and bundled history come through flat-rate plans; for the CME Globex MDP 3.0 dataset those are Standard at $199/month, Plus at $1,750/month (annual contract, license fees apply), and Unlimited at $4,500/month (annual contract, license fees apply)*. New accounts receive $125 in free credits*, which expire six months after signup. Other venues are priced separately; Databento's June 2026 pricing update lists US Equities at $4,000/month and several ICE datasets at $2,500/month*.

FXMacroData publishes one price list for all 22 currencies. The Always Free tier needs no key and covers USD data only, at 100 requests/day with USD announcements delayed 15 minutes. Individual is $50/month or $500/year with a 14-day trial and 1,000,000 requests/month. Business is $250/month or $2,500/year for companies and teams of up to 10 people, with the same allowance and priority support. Enterprise is by custom agreement, and a self-serve Commercial Redistribution add-on costs $10/month per block of up to 100 measured users.

Monthly list price, USD

FXMacroData plans in mint; Databento CME Globex MDP 3.0 plans in cyan. Hover a bar for the exact price.

Takeaway: The products price different data, so this is not a like-for-like contest; it shows the monthly budget for each layer. Adding FXMacroData Individual to a Databento Standard plan raises the stack cost by about a quarter.

FXMacroData Individual

$50/month

22 currencies, 700+ macro series, release calendar, FX rates, COT, MCP. 14-day trial; free USD tier with no key.

Databento usage-based

From $0.50/GB*

Historical CME data, pay per volume requested, no subscription. $125 signup credit*.

Databento CME Standard

$199/month*

Live CME data with license fees included, 16+ years of L0 history, 1 year L1, 1 month L2/L3.

Takeaway: A solo researcher can start both for well under $300 a month; deeper order-book history on Databento is where costs climb.

* Competitor pricing retrieved from their public pricing page on October 2026.

Side-by-side comparison

* Competitor pricing retrieved from their public pricing page on October 2026.

What each dataset actually covers

Databento's flagship futures dataset is CME Globex MDP 3.0, which spans every future and option on CME, CBOT, NYMEX and COMEX. That includes the currency futures FX researchers care about: Euro FX (6E), Japanese yen (6J), British pound (6B), Australian dollar (6A) and the rest. Schemas range from daily OHLCV bars through trades and top-of-book (MBP-1) to ten-level depth (MBP-10) and full market-by-order (MBO). Each event carries up to four timestamps, which matters when you are measuring reactions that play out in milliseconds.

FXMacroData does not try to be a tick database. Its /v1/forex/{base}/{quote} endpoint gives FX spot rates for context, but the product centre is the macro release: US CPI, Non-Farm Payrolls, the Fed policy rate, unemployment, the ECB deposit rate, PMIs, retail sales, trade and wages across 22 currencies. Around that sit CFTC COT positioning for the major currency futures, government bond yields, commodities, central-bank press releases from the Federal Reserve, ECB, Bank of Japan and Bank of England, and FX session context.

In other words, Databento covers the reaction surface and FXMacroData covers the catalyst. Neither replaces the other.

Timestamps and latency

The two companies talk about latency in different units because they measure different things. Databento's figures describe how quickly an exchange event reaches your application: 42 microseconds at the 90th percentile over a cross-connect, 590 microseconds over the internet. That is transport latency for market data that already exists in machine form at the exchange.

FXMacroData's timing problem starts earlier. A statistics agency or central bank publishes a number on its own website or feed, and someone has to capture it, parse it, and stamp it. FXMacroData records a second-level announcement_datetime on every release row, makes releases typically available within seconds of official publication, and publishes the measured record on /release-speed, including the share of releases available within one second of publication by source and every release that took longer.

One NFP release, two clocks

T0: publication

The agency publishes payrolls. FXMacroData stamps the row with announcement_datetime to the second.

T0 + ms: first prints

6E trades and book updates hit CME Globex; Databento records each with nanosecond timestamps.

T0 + seconds: value usable

The structured value and change are available from FXMacroData, typically within seconds.

Research: join

Align ticks to T0, measure the move over 1s, 1m and 15m windows, condition on the surprise.

Takeaway: The event-study anchor is the publication second, which only a release dataset provides; the reaction is measured from market data, which Databento provides.

A daily calendar date is not good enough for this work. If your macro dataset only records that payrolls came out on a Friday, every intraday window you compute is a guess. A second-level stamp from the release record lets you slice Databento data precisely around the event, including on days when a release slipped or an emergency decision landed off-schedule.

Joining Databento 6E ticks to FXMacroData releases

Here is the practical pattern. First pull the release history with a header-authenticated request:

curl -H "X-API-Key: YOUR_API_KEY" "https://api.fxmacrodata.com/v1/announcements/usd/non_farm_payrolls"

Example response (abridged; the September 2026 payrolls row, released 2 October 2026 at 12:30 UTC):

{
  "data": [
    {
      "date": "2026-09-30",
      "val": 159044000,
      "change": 29000,
      "pct_change_mom": 0.02,
      "source": "BLS",
      "announcement_datetime": 1790944200
    }
  ]
}

Then fetch 6E trades from Databento around each release and align them. This sketch uses Databento's Python client and pandas; it keeps the ten minutes either side of each payrolls print:

import databento as db, pandas as pd, requests

rel = requests.get(
    "https://api.fxmacrodata.com/v1/announcements/usd/non_farm_payrolls",
    headers={"X-API-Key": "YOUR_API_KEY"}).json()["data"]
events = pd.to_datetime([r["announcement_datetime"] for r in rel], unit="s", utc=True)

client = db.Historical("YOUR_DATABENTO_KEY")
windows = []
for t0 in events[-12:]:
    trades = client.timeseries.get_range(
        dataset="GLBX.MDP3", schema="trades",
        symbols=["6E.c.0"], stype_in="continuous",
        start=t0 - pd.Timedelta("10min"), end=t0 + pd.Timedelta("10min"),
    ).to_df()
    trades["secs_from_release"] = (trades.index - t0).total_seconds()
    windows.append(trades.assign(release=t0))

study = pd.concat(windows)  # one frame, every trade keyed to its release second

From FXMacroData

• announcement_datetime: the T0 for every window.
• val and change: the inputs for a surprise or change measure, with source for provenance.

From Databento

• Nanosecond trade timestamps on the front-month 6E contract.
• Optional MBP-10 or MBO depth to study liquidity withdrawal before the print.

Takeaway: One timestamp column from FXMacroData turns a raw tick download into a labelled event study, and the same loop extends to USD/JPY via 6J or to GBP/USD via 6B.

Because Databento bills historical data by volume, tight windows around known release times also keep the tick bill small. Pulling twenty minutes around each of twelve payrolls prints is a fraction of the cost of downloading a full year of 6E trades, and the release timestamps are what make that targeting possible.

API and developer experience

Both products are built for developers rather than terminal users. Databento offers one API for historical and live data, a binary DBN encoding for speed with CSV and JSON available at no extra charge, client libraries in Python, C++ and Rust, and batch downloads for large pulls. Symbology handles continuous contracts and parent symbols, which removes much of the roll-management pain in futures research.

FXMacroData uses plain REST JSON with an OpenAPI schema and X-API-Key header auth, an SSE stream for release events, GraphQL, and Python and JavaScript SDKs. It also runs an official MCP server, so an assistant in Claude, ChatGPT or Cursor can query the latest release, the next calendar event, or COT positioning directly. For anyone building AI-assisted trading research, that is a meaningful difference: the macro context arrives as a tool call rather than a scraping job. Integration guides cover MetaTrader, TradingView and NinjaTrader as well.

Where Databento is genuinely stronger

Databento is the stronger product for anything that depends on prices and order flow:

• Exchange-grade market data across CME futures and options, US equities, OPRA and several European venues, normalized into one schema family.
• Full order-book (MBO) and depth history, which FXMacroData does not offer at all.
• Nanosecond, multi-timestamp events and published microsecond-level live latency figures.
• Usage-based historical billing that lets a researcher pay only for the slices they need, plus $125 of starting credit.
• Transparent licence handling, with exchange fees passed through and distribution rights available at higher tiers.

If your question is about fills, slippage, queue position, or how liquidity behaves in 6E during the minute after a release, Databento is the right tool and FXMacroData is not a substitute.

Where FXMacroData is stronger

FXMacroData is stronger wherever the macro event is the object of study. It covers 22 currencies of official releases in one schema, with source metadata per series and a release calendar that tells you what is coming next. It costs $50/month for an individual, includes a free USD tier with no key, and adds the FX-specific layers (COT for the major currency futures, yields, commodities, central-bank press releases, pair dashboards such as EUR/USD and AUD/USD) that a macro-driven FX desk uses daily.

FXMacroData pros

• Second-level release timestamps with a public speed record.
• 22 currencies, 700+ official series, calendar, COT, yields.
• $50/month entry, free USD tier, MCP and REST.

FXMacroData tradeoffs

• No tick, depth or order-book data.
• FX spot rates are context, not an execution feed.
• Focused on FX-relevant macro, not every market.

Databento pros

• Full CME depth including 6E, 6J and 6B since 2010.
• Nanosecond timestamps, low published latency.
• Pay-per-GB history and $125 starting credit.

Databento tradeoffs

• No macro release values or release calendar.
• Flat-rate plans priced per venue; Plus and Unlimited need annual contracts.
• No MCP server listed on the pages reviewed.

Takeaway: The weaknesses of each product are the strengths of the other, which is why event-study teams commonly run both.

Decision matrix

Recommendation

If you are an FX trader or developer whose edge comes from macro releases, start with FXMacroData. It gives you the event, the exact second it happened, and the FX context around it at a fraction of the cost of any market-data subscription. Check the plans, read the API reference, and look at the release-speed record to see how quickly each source lands.

If your research also needs to see how 6E, 6J or other contracts traded tick by tick around those releases, add Databento. Its usage-based historical billing pairs well with release timestamps, because you only download the windows you need. For a broader view of the futures side, see how FXMacroData compares with CME DataMine; for spot FX tick history, see the Dukascopy comparison.

Bottom line: Databento is the stronger market-data API; FXMacroData is the stronger FX macro release API. For release trading research, the clean architecture is FXMacroData for the event clock and Databento for the price reaction, joined on announcement_datetime.

Takeaway: Buy the layer you are missing; most FX event-study teams are missing the release timestamps first.

Sources checked

Databento figures come from its public pricing, dataset and announcement pages, retrieved in October 2026. Where a figure was not publicly listed, this page says so.

Databento pricing

Usage-based, Standard, Plus and Unlimited plans; $125 credit.

View source

Databento pricing update

June 2026 changes to CME, US Equities and ICE plans.

View source

CME Globex MDP 3.0 dataset

Coverage, timestamps, latency figures, history and per-GB pricing.

View source

FXMacroData

Plans, API reference and the measured release-speed record.

View documentation

Takeaway: Both vendors publish prices and specifications openly, so every figure above can be checked against its source.

Related reading

• FXMacroData vs CME DataMine
• FXMacroData vs Dukascopy historical data
• Best economic indicator feeds for algo trading
• Best macroeconomic data APIs in 2026