What is a lot in forex? Standard, mini, and micro lot sizes with position value math

What is a lot in forex? A lot is the standardized unit of quantity for a currency position. One standard lot is 100,000 units of the base currency of the pair, and the smaller denominations scale down in powers of ten: a mini lot is 10,000 units, a micro lot is 1,000. The convention exists because currency prices move in tiny increments, so quoting quantity in fixed blocks keeps position sizes, pip values, and account arithmetic comparable across pairs.

The word describes quantity and nothing else. It says nothing about price, margin, or direction. Everything else in position arithmetic, including notional value and pip value, derives from two inputs: the lot size in base-currency units and the current price of the pair. That makes lot math a good candidate for a small utility function fed by a live quote, which is what the code further down builds.

One framing note before the numbers: this post is pure arithmetic. It explains how position values are computed, the way a post on compound interest explains a formula. Nothing here recommends trading any pair at any size.

Standard, mini, and micro lot sizes#

Two things about this table matter in practice. First, the units are always base currency, the first currency in the pair symbol. For EURUSD a standard lot is 100,000 euros; a dollar figure only appears after multiplying by the price. For USDJPY a standard lot is 100,000 US dollars. Second, the nano row is the least standardized of the four: 100 units is the common definition, but plenty of platforms don't offer nano lots at all. Standard, mini, and micro are consistent across the industry.

Position sizes are also written as decimal lots. A size of 0.25 lots means 25,000 units of base currency, which reads equally as 2.5 mini lots or 25 micro lots. The units column is the ground truth; the lot labels are shorthand on top of it.

Position value: what one lot of EURUSD is worth#

The notional value of a position, expressed in the quote currency, is one multiplication:

notional (quote currency) = lot units × price

Take a EURUSD quote with a mid price of 1.16934. One standard lot is 100,000 EUR, so its notional in US dollars is 100,000 × 1.16934 = 116,934.00 USD. Scaling down:

The result lands in the quote currency because a forex price is defined as quote units per one base unit. If your account is denominated in something else, one more multiplication by the relevant conversion rate finishes the job, using a second pair's quote.

A JPY-quoted example shows why keeping the currencies straight matters. Suppose USDJPY prints a round 150.00. One standard lot is 100,000 USD of base currency, and its notional is 100,000 × 150.00 = 15,000,000 JPY. The number looks enormous next to the EURUSD result, but that's only because one yen is a small unit. The arithmetic is identical.

Notional also differs from cost. Lot size describes the exposure of a position, the amount whose value moves with the exchange rate. What a trader posts upfront is margin, a broker-side concept that a market data API has no visibility into and this post doesn't cover.

Pip value follows directly from lot size#

Once lot units are fixed, pip value comes from the same pattern:

pip value (quote currency) = pip size × lot units

For EURUSD the pip size is 0.0001, so a standard lot moves 10 USD per pip, a mini lot 1 USD, and a micro lot 0.10 USD. A 12-pip move against a micro lot position is 12 × 0.10 = 1.20 USD. For JPY-quoted pairs the pip size is 0.01, which puts a standard lot at 1,000 JPY per pip. The full derivation, including fractional pips and converting pip values into other account currencies, is covered in a separate post on pip value.

Computing position value from a live quote#

The numbers above hard-code a price. In real code the price comes from a live quote endpoint:

curl -H "X-API-Key: $SIFTING_KEY" \
  "https://api.sifting.io/v1/last/quote/forex/EURUSD"

The response carries the current best bid and ask as the fields b and a, and the prices come back as strings, so cast them before doing arithmetic. The mid is a reasonable reference for valuation; bid or ask individually matter when you care about which side a conversion would actually happen on. A small Python script turns the quote into the full lot table:

import requests

resp = requests.get(
    "https://api.sifting.io/v1/last/quote/forex/EURUSD",
    headers={"X-API-Key": "sft_your_key"},
    timeout=5,
)
resp.raise_for_status()
quote = resp.json()

# snapshot fields are single letters and prices come back as strings:
# b/B = bid price/size, a/A = ask price/size, t = epoch ms
bid, ask = float(quote["b"]), float(quote["a"])
mid = (bid + ask) / 2

LOT_UNITS = {"standard": 100_000, "mini": 10_000, "micro": 1_000, "nano": 100}
PIP_SIZE = 0.0001  # 0.01 for JPY-quoted pairs

for name, units in LOT_UNITS.items():
    notional = units * mid
    pip_value = units * PIP_SIZE
    print(f"{name:>8}: {units:>7,} EUR = "
          f"{notional:>12,.2f} USD, pip = {pip_value:.2f} USD")

At a mid of 1.16934 the output reproduces the table from the previous section, one line per lot type. If the valuation needs to stay current rather than run once, subscribe to the fx product on the WebSocket stream at wss://stream.sifting.io/ws/v1 and recompute on each tick instead of polling this endpoint in a loop.

Common pitfalls#

Mixing up which side of the pair the units are in. The 100,000 in a standard lot is base currency, and the notional after multiplying by price is quote currency. For EURUSD that's euros in, dollars out. Reading both numbers as dollars misstates the position's size by the exchange rate, and the error is invisible when the rate is near 1, then glaring on a pair like USDJPY.

Applying the 0.0001 pip size to a JPY pair. JPY-quoted pairs use a pip size of 0.01, so a pip-value function with 0.0001 baked in will be wrong by a factor of 100 on USDJPY, EURJPY, GBPJPY, and AUDJPY. Key the pip size off the quote currency rather than a constant.

Treating snapshot prices as numbers. The quote fields b, B, a, and A are returned as strings, so arithmetic on them without a float() or Number() cast concatenates instead of adding. Cast at the boundary, the way the script above does.

Valuing against a quote that's no longer live. If the freshest data for a symbol is older than the API's freshness threshold, the quote endpoint returns a 503 with error code stale_snapshot. Handle that status explicitly rather than silently reusing the last number your process saw, and check the epoch-millisecond t field on the snapshot if your valuation is time-sensitive.

Every number in this post reduces to lot units times a price, and the live price is one authenticated GET away. The EURUSD quote endpoint used here works on the free tier with no credit card. Start building free.