What 1 point is on NAS100
NAS100 (also US100 or USTEC) is a CFD on the Nasdaq-100, priced in US dollars. Profit = index points × contract size × lots. Capital.com, BlackBull Markets and Purple Trading all publish a contract size of 1, so 1.00 lot = $1 per index point.
MetaTrader's point is not the index point: it's the smallest price step, 0.1 at BlackBull and 0.01 at Purple Trading. An 80-point stop in index terms is 800 or 8,000 MT5 points. And the futures behind the index (E-mini Nasdaq-100) are worth $20 per point: that multiplier has nothing to do with a CFD lot.
NAS100 point value per lot
Value of one point (1.00 in price): 1 × 1 = $1 per 1.00 lot, with a contract size of 1.
| Position | 1 point | 80 points (80.00) |
|---|---|---|
| 1.00 lot | $1.00 | $80.00 |
| 0.10 lot | $0.10 | $8.00 |
| 0.01 lot | $0.0100 | $0.80 |
Worked example: 1% of $10,000
- Risk: 1% × $10,000 = $100.00.
- Stop: 80 points = 80.00 in price.
- Value of 1 point per 1.00 lot: $1.00.
- Lot size = $100.00 ÷ (80 × $1.00) = 1.2500, rounded down to the 0.01 step: 1.25 lots.
With $1 per point per lot, the lot size is simply the risk in dollars divided by the stop in points.
Contract size and tick value in MT5
In MetaTrader 5, right-click NAS100 in Market Watch and choose Specification: it shows Contract size, Digits, Profit currency and the volume limits. Tick size and tick value are what MQL5 reads with SYMBOL_TRADE_TICK_SIZE and SYMBOL_TRADE_TICK_VALUE; the script below prints them for your account.
| Contract size | 1 at the three brokers below (some brokers use other sizes) |
|---|---|
| Digits | 1 or 2 depending on the broker (price step 0.1 or 0.01) |
| Tick size (SYMBOL_TRADE_TICK_SIZE) | 0.1 or 0.01 |
| Profit currency | USD |
| Tick value, 1.00 lot (SYMBOL_TRADE_TICK_VALUE) | contract size × tick size: $0.10 or $0.01 with a contract size of 1 |
| Value of 1 index point per lot | contract size × $1 |
Published values, checked on 2026-11-12. Specifications change and can differ by account type: your own Specification window is the reference.
| Source | Symbol there | Contract size | Price step |
|---|---|---|---|
| Capital.com | US100 | 1 | 1 digit |
| BlackBull Markets | NAS100 | 1 | 0.1 |
| Purple Trading | US100 | 1 | 0.01 |
MQL5: lot size from a money risk
A script that sends no order: it reads the contract size, tick size, tick value and volume limits your broker sets for NAS100, then prints the lot size that risks 1% of the balance at the stop. The stop is a price distance (80.00), so the result is the same on 2-, 3- or 5-digit quotes. Save it as MQL5/Scripts/LotSize_NAS100.mq5 and compile it in MetaEditor (F7): 0 errors, 0 warnings.
//+------------------------------------------------------------------+
//| LotSize_NAS100.mq5 |
//| Lot size that risks a % of the balance at a given stop distance|
//+------------------------------------------------------------------+
#property script_show_inputs
input string InpSymbol = "NAS100"; // Symbol, exactly as in Market Watch
input double InpRiskPercent = 1.0; // Risk per trade, % of balance
input double InpStopDistance = 80.00; // Stop-loss distance in price (80.00 = 80 points)
// Lots that lose about riskMoney at the stop, rounded down to the volume step.
// Returns 0 when even the minimum volume would risk more than riskMoney.
double LotsForRisk(const string symbol, const double riskMoney, const double stopDistance)
{
double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE); // 1.00 lot, one tick, account currency
double step = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
if(tickSize <= 0.0 || tickValue <= 0.0 || step <= 0.0 || stopDistance <= 0.0)
return 0.0;
double lossPerLot = stopDistance / tickSize * tickValue; // money lost by 1.00 lot at the stop
double lots = MathFloor(riskMoney / lossPerLot / step + 1e-9) * step;
if(lots < minLot)
return 0.0;
int volumeDigits = (int)MathMax(0.0, MathCeil(-MathLog10(step) - 1e-9));
return NormalizeDouble(MathMin(lots, maxLot), volumeDigits);
}
void OnStart()
{
if(!SymbolSelect(InpSymbol, true))
{
PrintFormat("%s not found: use the exact name from Market Watch (some brokers add a suffix)", InpSymbol);
return;
}
int digits = (int)SymbolInfoInteger(InpSymbol, SYMBOL_DIGITS);
double point = SymbolInfoDouble(InpSymbol, SYMBOL_POINT);
double contract = SymbolInfoDouble(InpSymbol, SYMBOL_TRADE_CONTRACT_SIZE);
double tickSize = SymbolInfoDouble(InpSymbol, SYMBOL_TRADE_TICK_SIZE);
double tickVal = SymbolInfoDouble(InpSymbol, SYMBOL_TRADE_TICK_VALUE);
string currency = AccountInfoString(ACCOUNT_CURRENCY);
double risk = AccountInfoDouble(ACCOUNT_BALANCE) * InpRiskPercent / 100.0;
double lots = LotsForRisk(InpSymbol, risk, InpStopDistance);
PrintFormat("%s: contract size %g, %d digits, tick size %s, tick value %g %s per lot",
InpSymbol, contract, digits, DoubleToString(tickSize, digits), tickVal, currency);
PrintFormat("Stop %s = %.0f points. Risk %.2f %s",
DoubleToString(InpStopDistance, digits), InpStopDistance / point, risk, currency);
if(lots > 0.0)
PrintFormat("Lot size: %g", lots);
else
Print("Even the minimum volume risks more than that: widen the risk or tighten the stop");
}
The key line is stopDistance / tickSize * tickValue: the money one lot loses at the stop, already converted to your account currency by the terminal. Dividing the risk by it and flooring to SYMBOL_VOLUME_STEP gives the volume to pass to CTrade::Buy() or CTrade::Sell().
Pine Script v6 equivalent
The same sizing on a TradingView chart, from syminfo.pointvalue (money per 1.0 of price per unit) and syminfo.mintick (the chart's tick). Checked by Edgoro Pine Check; paste it into TradingView's Pine Editor to add it to a chart.
//@version=6
indicator("NAS100 lot size for a money risk", overlay = true)
riskMoney = input.float(100.0, "Risk per trade (account currency)", minval = 0.01)
accountCcy = input.string("USD", "Account currency")
stopDistance = input.float(80.00, "Stop-loss distance (price)", minval = 0.0)
contractSize = input.float(1.0, "Units per 1.00 lot at your broker", minval = 0.0)
// One unit of the symbol gains or loses syminfo.pointvalue (in syminfo.currency) per 1.0 of price
fx = request.currency_rate(syminfo.currency, accountCcy)
lossPerUnit = stopDistance * syminfo.pointvalue * fx
units = lossPerUnit > 0 ? riskMoney / lossPerUnit : na
lots = contractSize > 0 ? math.floor(units / contractSize * 100) / 100 : na
var table info = table.new(position.top_right, 2, 3, bgcolor = color.new(color.gray, 80))
if barstate.islast
table.cell(info, 0, 0, "Stop")
table.cell(info, 1, 0, str.tostring(stopDistance / syminfo.mintick, "#") + " ticks of " + str.tostring(syminfo.mintick))
table.cell(info, 0, 1, "Units")
table.cell(info, 1, 1, str.tostring(units, "#.####"))
table.cell(info, 0, 2, "Lots (rounded down)")
table.cell(info, 1, 2, str.tostring(lots, "#.##"))
On a CFD chart syminfo.pointvalue is usually 1, so units is the number of index units: set the contract size input to your broker's value. On a futures chart, syminfo.pointvalue already includes the contract multiplier, so units are contracts and the contract size input should be 1.
Common mistakes on NAS100
- MT5 points as index points. A stop of "80 points" typed into an EA that works in MT5 points is 8.0 or 0.80 index points: the EA then sizes ten or a hundred times too large.
- The futures multiplier. $20 per point is the E-mini contract, $2 the Micro. A CFD lot is the broker's contract size, often $1 per point; see the futures tick value calculator for the exchange contracts.
- Assuming every broker uses 1. Contract sizes are set by each broker, sometimes per account type. Check Contract size in the Specification window, or enter the point value in the index CFD point value calculator.
- Minimum volume. BlackBull lists a minimum trade size of 0.1 lot on NAS100: with $1 per point, the smallest position risks $10 per 100-point stop.
Lot size sets how much a trade loses if the stop is hit at its price. It doesn't make a trade a good one, and gaps or slippage can make the loss larger. Trading involves substantial risk of loss and is not suitable for every investor. Edgoro is a software tool, not a broker or financial adviser: nothing it produces is investment advice, and past or backtested performance does not guarantee future results.