Lots, Cents and lotSize: What 0.15 Lots Actually Sends to cTrader
By the TradeAon team · Published · Updated · 8 min read
On MetaTrader you send 0.15 and mean 0.15 lots. cTrader's Open API has no notion of a lot in its order message: it takes an integer volume in cents, and the number of cents in one lot is a property of each individual symbol. Getting that conversion wrong does not throw an error — it opens a position of the wrong size. This guide works through the conversion against a real broker's symbol table, including the two places where the size you asked for is not the size you get.
- The order field is an integer in cents. One lot equals that symbol's
lotSize— it is not a constant, and on the broker examined here it takes 10 distinct values spanning 100 to 100,000,000. - The tempting shortcut
minVolume × 100agrees withlotSizeon only about half a real symbol list — 180 of 351 disagreed, the worst by 10,000×. - Volume is aligned to the symbol's step by rounding down, never to nearest, because rounding up trades more than you asked for.
- Two clamps can still change your size: the broker's minimum raises it and the maximum caps it. Both are logged; neither is a bug you can configure away.
- At 0.15 lots across 351 symbols the split was 182 exact, 147 raised to a broker minimum, 22 floored to a step, 0 oversized (section 06).
Two platforms, two units
A lot is a unit of contract quantity, and MetaTrader exposes it directly: request.volume = 0.15 means 0.15 lots, and the terminal resolves what that means for the instrument. The number you type is the number the platform reasons about.
cTrader's Open API works the other way round. The order message carries a volume as an integer, expressed in hundredths of a unit — "cents" in the API's own vocabulary — and each symbol declares how many of those units make up one lot. Fractional values do not exist at the protocol level, so every size has to be converted and then made to land exactly on a legal integer.
This matters for automation specifically. A human clicking in the cTrader interface never sees the integer, because the interface does the conversion. A webhook or a copied trade arrives carrying lots, because that is what TradingView alerts and MetaTrader master accounts speak, and something has to translate. If that translation uses the wrong factor, the API accepts the order — the number is a valid integer, after all — and fills a position at a size nobody chose.
What a symbol table actually contains
On connecting, the full symbol list for the account is fetched once and cached, along with each symbol's volume specification. The table below is taken verbatim from a live cache of 351 symbols — a snapshot of one broker's list, not a hand-made example.
| Symbol | 1 lot (cents) | Min | Step | Max |
|---|---|---|---|---|
EURUSD | 10,000,000 | 100,000 | 100,000 | 10,000,000,000 |
XAUUSD | 10,000 | 100 | 100 | 1,000,000 |
US500 | 100 | 10 | 10 | 25,000 |
BTCUSD | 100 | 1 | 1 | 1,000 |
XRPUSD | 100 | 10,000 | 1 | 100,000 |
Read the first column again: one lot is 10,000,000 cents of EURUSD and 100 cents of US500. There is a factor of a hundred thousand between two rows of the same table, which is why no single constant can convert lots to volume. The conversion has to be per symbol, and it has to come from the broker's own declaration.
The last three columns are just as consequential, and they are independent of each other. XRPUSD is the clearest case in this list: its step is 1 cent, so it is finely divisible, yet its minimum is 10,000 cents — which is 100 lots. A perfectly reasonable 0.15-lot order is nowhere near legal on that symbol, and no amount of rounding will make it so.
The shortcut that misprices half the list
There is an appealing piece of folk knowledge in cTrader integrations: since the minimum volume is usually 0.01 lot, one lot must be minVolume × 100. It is appealing because it is true often enough to survive testing. Check it against EURUSD, USDJPY, XAUUSD and BTCUSD — the symbols anyone reaches for first — and all four agree.
Run it across the whole table and it falls apart. Comparing each symbol's declared lotSize against minVolume × 100 on the 351-symbol cache above:
total symbols 351 lotSize != minVolume x 100 180 (51%) agree exactly 171 worst disagreements (old form / true value) ENSUSD 1 lot = 1,000 shortcut said 10,000,000 10,000x PUMPUSD 1 lot = 100,000 shortcut said 1,000,000,000 10,000x AVXUSD 1 lot = 100 shortcut said 1,000,000 10,000x KSMUSD 1 lot = 100 shortcut said 1,000,000 10,000x
The assumption breaks precisely where minVolume is not 0.01 lot. ENSUSD has a minimum of 100 lots, so the shortcut inflates one lot by four orders of magnitude — and it inflates every order placed on that symbol by the same factor. Nothing rejects it. The volume is a legal integer within the symbol's range, so the broker fills it.
The correct factor is the one the symbol declares: volume = lots × lotSize, both sides already in cents. The shortcut is kept only as a fallback for the case where a cached table is incomplete and lotSize is missing, so a partial cache degrades to the old behaviour rather than refusing to trade at all.
The general lesson travels beyond cTrader. A conversion that is verified against the four instruments everyone tests with is not verified. It is worth running any unit conversion across the broker's entire list once, because the disagreements cluster exactly in the instruments nobody samples.
Step alignment always rounds down
Multiplying by lotSize rarely lands on a legal value by itself, because volumes must be a multiple of the symbol's step. Something has to round, and the direction is a risk decision rather than a numerical one.
Take US500 from the table: one lot is 100 cents and the step is 10.
0.15 lot x 100 = 15 cents not a multiple of 10 round to nearest -> 20 cents = 0.20 lot (33% MORE than requested) round down -> 10 cents = 0.10 lot (33% less than requested)
Rounding to nearest is the mathematically neutral choice and the wrong one here. It means that on some symbols a strategy sized at 0.15 lots silently takes a third more exposure than its author intended, and it does so without any signal that a decision was made. Rounding down can only ever give you less risk than you asked for, so alignment floors — with a tiny epsilon added first, so a value that is already an exact multiple is not pushed a step lower by floating-point error.
The practical consequence is worth internalising: on a symbol with a coarse step relative to your size, your effective position will be smaller than your configured size, and the smaller your order, the larger that gap is in percentage terms. If a strategy depends on precise sizing, check the step before assuming the platform honoured your number exactly.
The two clamps that change your size
After alignment, the value is clamped into the symbol's legal range. Both clamps change your position size, in opposite directions, and both are worth knowing about before they happen rather than after.
The minimum raises your order. If the aligned volume is below minVolume, it is lifted to the minimum, because the alternative is an order the broker rejects outright. But this is the one direction that gives you a position larger than the one you requested, so it is never done silently — every occurrence is written to the log with both numbers. Four real cases from the same broker at 0.15 lots:
AUS200 asked 15 cents -> 100 cents (1 lot) Wheat_H6 asked 60 cents -> 100 cents BRENT asked 1,500 cents -> 10,000 cents XNGUSD asked 150,000 cents -> 500,000 cents
On AUS200 the broker's minimum is a whole lot, so a 0.15-lot instruction becomes a 1-lot position — roughly 6.7× the intended exposure. That is a real constraint of the instrument, not a defect to be configured away, and the only defence is to know it applies before you point a strategy at that symbol.
The maximum shrinks your order. BTCUSD in the table has a maximum of 1,000 cents, which is 10 lots. A copied 50-lot master position therefore lands as 10 lots on the follower, and the account carries one fifth of the intended exposure. Under-exposure is less dangerous than over-exposure, but for a copy relationship it is a correctness problem: the follower is no longer mirroring the master, and a divergence that nothing announces is one you find out about at the worst moment. So the cap is logged too, in explicit terms — that this leg will not mirror the master's size.
The asymmetry between these two is deliberate. Rounding, which happens on every order, goes in the safe direction. Clamping, which cannot be avoided without rejecting the trade, is allowed to move the size in either direction but never without a record.
Checking this on your own account
None of the above needs to be taken on faith. Running the real conversion across all 351 symbols in the cached table, at a request of 0.15 lots, produces this distribution:
exact, no adjustment 182 raised to the broker's minimum 147 floored to the symbol's step 22 oversized beyond the request 0
The third number is the reassuring one and the second is the surprising one. Nearly 42% of this broker's instruments cannot accept 0.15 lots at all, and would open a larger position than requested. That is not visible from the platform interface, and it is not something a strategy's own risk settings can see.
Three checks are worth doing before you let a strategy size positions automatically on cTrader:
- Look up the minimum for the specific instruments you trade, expressed in lots rather than cents. Anything above your intended size means every order on that symbol will be enlarged.
- Compare your intended size against the step. If your size is not a whole multiple of it, you will trade slightly less than you configured, on every single order.
- Place one small order on demo and read back the filled volume rather than the requested one. The requested value proves that your configuration parsed; only the fill proves the conversion was right.
The wider point is that "0.15 lots" is not a portable instruction. It is meaningful relative to one instrument on one broker, and moving it across platforms — from a TradingView alert to cTrader, or from an MT5 master to a cTrader follower — is a unit conversion with real money on the other end. Treat a size that arrives from somewhere else as a request rather than a fact, and check what it turned into.