CME Market Data Pricing 2026: Exchange Fees, the NYMEX Fee Schedule, MDP Premium & $19/mo APIs

Updated July 2026 with current fee ranges.

Market data pricing is one of those corners of finance that seems designed to be confusing, and not by accident. Between exchange fees, vendor markups, “non-display” surcharges and per-message billing, two providers can quote wildly different numbers for what is, underneath, the same stream of trades. This is a plain-English breakdown of what CME market data actually costs in 2026, where the money goes, and how a developer gets a real-time futures feed without an enterprise budget.

CME market data price list (2026)

The numbers people actually search for, in one table. Ranges are what you’ll realistically see as of mid-2026; exact figures vary by broker, platform and your professional-status declaration:

What	Non-professional	Professional
Real-time top-of-book, per exchange (CME, CBOT, NYMEX, COMEX each)	~$10–15 / mo	~$100–135 / mo
All four exchanges, top-of-book	~$45–60 / mo	~$400–540 / mo
Market depth (Level 2), per exchange	extra, tens of $/mo	substantially more
Direct MDP 3.0 feed (connectivity + infra + fees)	—	thousands / mo
Bloomberg / terminal seat	—	~$2,000–2,500 / mo
Developer API (redistributed, normalized)	$19–100 / mo flat	same
Delayed tier	$0	$0

Two things jump out. First, the same bytes cost wildly different amounts depending on who you are (professional vs non-professional) and how you consume them (display vs non-display, direct vs redistributed). Second, the developer-API row exists precisely because every other row was priced for someone who isn’t building software alone at night.

CME market data fees, explained layer by layer

The price you pay is rarely one charge. It’s a stack:

1. Exchange data fees. CME licenses each of its four exchanges separately — CME, CBOT, NYMEX, COMEX — and the professional/non-professional gap is large. Same bytes, very different invoice, based on who you are and a form you signed.

2. Connectivity and infrastructure. A direct feed isn’t a URL you curl. CME’s native MDP 3.0 is a binary multicast protocol that assumes colocation, feed handlers and redundancy. That’s a serious infrastructure commitment before you’ve parsed a single tick — it’s also where the real latency budget lives.

3. Vendor markup. Most people don’t take the direct feed; they buy from a vendor who built the infrastructure once. The vendor adds their costs and margin. Fair enough — but the billing model they choose matters more than the markup (see the per-message trap below).

4. Per-user and non-display fees. The one that surprises people: many vendors and the exchange itself levy extra fees when data feeds an algorithm rather than a human’s screen, and per additional user or application. A setup that looks cheap for one analyst balloons when it powers an automated system.

CME exchange fees by exchange — CME, CBOT, NYMEX, COMEX

A detail that surprises almost everyone the first time: CME Group licenses market data per exchange, not as one product. The Nasdaq-style “one subscription” mental model does not apply. If you trade ES (CME), ZN (CBOT), CL (NYMEX) and GC (COMEX), you are carrying four separate data entitlements:

Exchange	Flagship products	NP top-of-book (typical, via broker)	Professional	Depth (L2)
CME	ES, NQ, currencies, SOFR	~$10–15 / mo	~$100–135 / mo	separate entitlement
CBOT	ZN, ZB, ZC, ZS (rates, grains)	~$10–15 / mo	~$100–135 / mo	separate entitlement
NYMEX	CL, NG, RB, HO (energy)	~$10–15 / mo	~$100–135 / mo	separate entitlement
COMEX	GC, SI, HG (metals)	~$10–15 / mo	~$100–135 / mo	separate entitlement

Ranges are what retail brokers and platforms typically pass through as of mid-2026; the authoritative numbers live in CME Group’s official market data fee schedule and change roughly yearly, so treat any third-party table — including this one — as orientation, not gospel.

Two structural notes worth more than the exact dollars. First, the professional/non-professional declaration dominates everything: the same four entitlements that cost a hobbyist ~$50/month cost a professional the better part of $500, for identical bytes. The definitions hinge on how you use the data (personal vs business capacity), not on how good you are — read the declaration carefully rather than guessing. Second, “exchange fees” means two unrelated invoices: the per-contract fees added to every fill (a trading cost, set per product) and the monthly data fees discussed here. Search results mix them freely; your broker’s commission page covers the former.

The NYMEX fee schedule, specifically

NYMEX shows up in searches on its own because energy traders often only need NYMEX — and then discover they are paying for an entitlement structure designed around all four exchanges.

The data side is simple once you see the pattern above: NYMEX is one of the four CME Group exchanges, so its market data fee schedule is structurally identical — a monthly per-exchange fee split by professional status, depth as a separate line, delayed data free or nearly free. If you only need CL and NG top-of-book as a non-professional, a single NYMEX entitlement through your broker is the cheapest display path, typically in the same ~$10–15/month band as the other exchanges.

What NYMEX searchers usually actually want to know is the per-contract side: exchange fees on a crude or natural-gas fill. Those are set per product and membership tier in CME Group’s trading fee schedule, appear inside your broker’s commission breakdown, and have nothing to do with the data subscription. If your all-in commission on CL looks high, the exchange fee component is the same for every broker — the spread between brokers is in their own commission and routing fees.

And if what you need is NYMEX data in code rather than on a screen: redistributed developer APIs don’t price per exchange. Our own futures feed carries CL, NG and the rest of the energy complex in the same flat plan as the index futures — one subscription, all four exchanges’ products.

MDP Premium and the direct feed: what “just take it from CME” involves

Searches for “CME MDP premium” usually come from someone who has found CME’s own data offerings and is wondering whether to skip vendors entirely. Here is what the direct path actually is.

MDP 3.0 is CME’s native Market Data Platform protocol: binary (Simple Binary Encoding), multicast, delivered at the exchange. Taking it directly is not an API signup — it is a licensing and infrastructure project:

• A distributor-level agreement with CME Group — application, conformance, ongoing license fees, and an audit trail for how you use and (if applicable) redistribute the data.
• Connectivity — colocation in Aurora or a licensed extranet circuit. This is physical infrastructure with a monthly invoice, not a WebSocket URL.
• Feed handlers — software that speaks SBE multicast, handles A/B feed arbitrage, gaps and recovery. You build it, buy it, or hire it.
• Non-display and application fees where the data feeds algorithms rather than screens.

Realistic all-in for the smallest serious direct setup starts in the thousands per month — before a single line of strategy code. That price buys something real: exchange-edge latency measured in microseconds. If your model does not monetize microseconds, the direct feed is a category error, and the redistributed path below delivers the same trades for two orders of magnitude less. For the physics of what latency is actually achievable per path, see our latency breakdown.

CME non-display fees — the line that catches developers

Of every fee on this page, non-display is the one people discover after the invoice arrives. It is worth its own section because it is not a surcharge on the data; it is a separate licence for a different activity.

The distinction CME draws is not about how much data you take. It is about what the data touches. Data that reaches a human’s screen is display use. Data that feeds a program which acts, prices, values or decides — without a person reading it — is non-display use, and it is licensed separately even when it is the identical stream.

CME’s licensing guidelines group usage into categories, with Category C covering non-display, itself split into sub-categories spanning risk management, research and analysis, fund administration, portfolio management, and a catch-all. Fees are applied on the total number of applications within each category rather than per user or per seat. (CME Group data licensing policy guidelines, retrieved 2026-08-28.)

That counting rule is the trap. A developer’s intuition is that one person running one strategy is the cheapest possible case. Under a per-application count, the question is not how many people you are — it is how many distinct programs touch the data and what each of them does with it. A backtester, a live execution service and a risk monitor can be three applications doing three licensable things, and none of them ever draws a chart.

Two practical consequences:

• “I’m just one guy” is not a licensing category. Non-professional status affects display fees. It does not make an algorithm a screen.
• The answer depends on your specific use, and CME determines it. Anyone who tells you categorically that your bot is or is not non-display — including us — is guessing at a determination that is not theirs to make. If your application does anything beyond showing numbers to you, write to [email protected] and get it in writing before you scale.

The reason this section exists at all is that the fee lists describe categories, not scenarios, and the gap between the two is where the surprise lives.

CME API pricing

If what you searched for was “CME API pricing”, the honest answer is that CME itself does not sell a developer API in the modern sense — there is no REST endpoint with a self-serve key on cmegroup.com. What exists is the direct MDP path above, and a tier of licensed redistributors who consume it once and resell normalized access.

That redistribution tier is where developer pricing lives, and the market has settled into recognizable bands as of 2026: flat $19–100/month for real-time CME futures over WebSocket/REST at the indie tier (tickstream sits here — current plans, delayed tier free), usage-billed APIs that can be cheap at prototype volume and expensive at production volume, and institutional vendors quoting hundreds to thousands with deeper catalogs. The provider-by-provider comparison walks through who fits whom.

The per-message trap

Beyond the stack, watch the billing model. A pricing page advertising a low rate “per message” or “per gigabyte” is quoting you the calm-market price — and markets are not calm on the days that matter.

The math is brutal during volatility. A liquid futures contract that ticks a few times a second overnight fires thousands of messages per second at the cash open or on a CPI surprise. Usage billing means your data bill spikes exactly when your system is busiest and your attention is elsewhere. Flat pricing makes a wild day cost the same as a quiet one. For anything automated, flat-rate isn’t a nicety; it’s risk management.

What each path costs, honestly

Path	Rough cost (2026)	Best for
Direct CME feed	Thousands/mo + infra	Latency-critical firms, HFT
Bloomberg / terminal	~$2,000–2,500/mo per seat	Analysts who live in the terminal
Legacy data vendor	Hundreds–thousands/mo, often usage-billed	Institutions, established desks
Retail platform data add-ons	~$45–60/mo (NP, all four exchanges) + platform fee	Discretionary traders on charts
Developer market-data API	~$19–100/mo flat	Builders, indie quants, apps
Delayed / free tier	$0	Research, prototypes

The point isn’t that the cheap option is always right — a colocated HFT shop genuinely needs the direct feed and the microseconds it buys. The point is that most developers are massively over-served by the expensive paths. If you’re building an app, a bot, a dashboard or a research pipeline, you need clean data over a clean API, not a $24k/year terminal you’ll use 5% of. For a side-by-side of the actual vendors in this space, see our CME data feed provider comparison.

Why developer APIs can be so much cheaper

It’s not magic or a worse product. A developer-focused provider takes the licensed feed once, builds the hard infrastructure once, normalizes everything into friendly JSON, and amortizes that cost across many customers. You get the same underlying CME trades over a WebSocket and REST API you can integrate in minutes, at a price that reflects shared infrastructure rather than a bespoke direct feed.

The trade-off is real but usually acceptable: you don’t get colocated microseconds (here’s what latency is physically realistic over the internet), and you don’t get a terminal’s analytics and chat. What you do get is the data, normalized and reliable, at a price that doesn’t require a budget meeting.

What to look for at the developer tier

• Flat pricing, no per-message fees. Non-negotiable for anything automated.
• Real-time and historical from one source, identically normalized, so backtest and production agree. (Our historical tick archive is the same feed the live API streams — including a free 2-month sample to verify against.)
• The full surface — futures, Level 2 depth, and options — under one key, so you’re not stitching three vendors together.
• A free or delayed tier to prototype on before you pay.
• Honest latency you can verify, rather than adjectives.

tickstream was built squarely for this tier: real-time CME futures, options and Level 2 over a dead-simple API, flat plans from $19/month with no per-tick fees, a free 15-minute delayed tier, and the same normalized feed for live and historical. The feed originates from licensed CME Group distribution — which is also why we can run public backtests and live track records on it.

Two questions this page deliberately does not answer

This article is about what CME data costs. Two neighbouring questions keep arriving here and are answered properly elsewhere, because trying to serve all three on one page is how a page ends up serving none of them well:

“How fast is it, really?” Latency is not a pricing question and the honest answer involves numbers, not adjectives — what a retail stack can actually achieve, where the milliseconds go, and which of them you can buy back. That is low-latency CME market data: what is realistic.

“Which provider should I use?” A price list cannot answer that, because the right choice depends on coverage, delivery and what you are building. We compare the field — including the cases where somebody else is the better fit — in CME data feed providers compared.

If you came here for either of those, follow the link. This page will still be here.

The honest framing

Market data is expensive at the top of the stack for real reasons — exchange fees, infrastructure, segmented pricing — and those reasons matter if you’re a latency-sensitive firm. But if you’re a developer, you’re probably being quoted a price built for someone you’re not. The modern answer is a shared-infrastructure API: the same CME data, normalized and flat-priced, for tens of dollars instead of thousands. Start on a free delayed tier, confirm the data and latency hold up, and only pay for what your application actually needs. That’s how you get real-time futures data without enterprise pricing — and without the surprise invoice on the one day the market actually moves.