Futures tick value and point value explained: ES, NQ, GC, CL, DAX

What point value and tick value actually measure

Point value is the dollar or euro amount that one full point move in the price represents for a given futures contract. It is set by the exchange that lists the contract, not by the broker.

The tick is the smallest price increment the exchange allows for that contract. Tick value follows directly from the two: it equals point value multiplied by tick size. That single figure is what decides the gain or loss on every minimum price move, per contract.

Two contracts built on the same index or commodity can still carry very different tick values depending on their size — that is exactly what separates a standard contract from its micro version, covered in detail further down.

Where to read these figures on an official contract page

Every exchange publishes a specification page for its contracts. On CME Group’s site, the two rows to look for are "Contract Unit" (the point value) and "Minimum Price Fluctuation" (the tick size, with its currency value). On Eurex, the same information sits in the "Contract values and price gradations" table.

The exact label can vary slightly from one exchange to another, but the figure it points to is always the same: the currency amount that the smallest allowed price move represents for that specific contract.

These specifications can change when an exchange revises a contract. Before using them to size a position, the official page remains the only source worth checking — the links are in the Sources section at the end of this article.

Tick value of the main E-mini and micro contracts

According to CME Group’s and Eurex’s official specifications, some of the most watched E-mini / micro pairs give:

• S&P 500: ES, 0.25-point tick, $50 point value, i.e. $12.50 per tick. Micro version MES: same 0.25-point tick, $5 point value, i.e. $1.25 per tick.
• Nasdaq-100: NQ, 0.25-point tick, $20 point value, i.e. $5 per tick. Micro version MNQ: same tick, $2 point value, i.e. $0.50 per tick.
• Gold: GC, 0.10-ounce tick, $100 point value, i.e. $10 per tick. Micro version MGC: same tick, $10 point value, i.e. $1 per tick.
• WTI crude oil: CL, $0.01-per-barrel tick, $1,000 point value, i.e. $10 per tick. Micro version MCL: same tick, $100 point value, i.e. $1 per tick.
• DAX index (Eurex): FDAX, 1-point tick, €25 point value, i.e. €25 per tick, per Eurex’s official specification — a contract where a point and a tick share the same value, unlike the CME contracts listed above.

Why this is the first figure to know before sizing a position

Stop distance in ticks, multiplied by tick value, gives the currency risk for a single contract directly. That is the base calculation behind any risk management on futures, before even choosing a number of contracts.

Two contracts that look similar on a chart — an ES and an MES, for instance — carry a very different impact on an account: at the same stop distance, MES tick value is ten times smaller than ES tick value.

Adding up risk across several contracts at once

When a position combines several contracts in parallel — an ES and a GC held at the same time, for instance — total risk cannot be read off a single chart: it comes from working out each contract’s risk separately, from its own tick value, then adding the resulting amounts together.

That step is easy to forget when the positions sit on markets with no obvious link between them. It becomes essential the moment total account risk, across every open position, needs to stay under a limit set in advance, regardless of how many contracts happen to be open at the same time.

That sum treats each contract’s risk independently, which is the right approach for the currency amount at stake per contract. It does not, however, capture how closely two markets might move together: two positions on correlated markets can lose value at the same time, even though their tick-value calculations remain entirely separate from one another.

What tick value does not measure

Tick value says nothing about the spread shown on screen, or the margin a broker requires to open a position: those are separate figures, driven respectively by current market conditions and by each broker’s own rules. The official contract page only covers what the exchange itself sets — point, tick, expiries, settlement method.

Mixing up tick value and required margin is a common source of confusion: margin can run to several thousand dollars for an E-mini contract, while the risk tied to a stop a few ticks wide sits, by contrast, in the tens or low hundreds of dollars. The two figures answer different questions: margin is what needs depositing to open the position; risk in ticks is what a given price move costs — and neither one can be substituted for the other in any calculation.

Checking a figure before trusting it

Three habits catch nearly every mistake: confirm the symbol matches the intended contract, since an E-mini and its micro version carry different codes (ES versus MES, for instance); read the "Minimum Price Fluctuation" row, or its Eurex equivalent, rather than relying on a remembered figure that might predate a revision; and cross-check the result with a simple manual calculation, like the one above, before feeding it into a tool.

That check takes under a minute and prevents most position-sizing mistakes, which almost always trace back to a mistyped tick value rather than a wrong calculation. A quick way to confirm nothing has changed recently is to compare the current figure against the one used the last time that contract was traded — any mismatch is worth investigating before an order goes in.

What can change, and how to stay current

An exchange can revise a tick size or list a new version of an existing contract. Such changes are announced on that exchange’s own site, and nowhere else first.

Before entering a stop or a risk figure into a calculator, the most reliable habit is to check the numbers against the contract’s official specification page. This matters most for contracts traded regularly: a value copied once from memory can quietly go stale after a revision, while checking the official page each time removes that risk entirely.