CS2 Trade-Up Guide

CS2 Trade-Up Output Float Formula: A Step-by-Step Calculator Guide

Published July 9, 2026 · Updated July 9, 2026 · 4 min read
TL;DR

The standard CS2 trade-up calculation first normalizes every input within that skin's own allowed float range: normalized input = (raw float − input minimum) ÷ (input maximum − input minimum). Average those normalized values, then calculate each possible result as output float = output minimum + average normalized input × (output maximum − output minimum). A raw input-float average is not a valid substitute when skins have restricted or different ranges.

What is the CS2 trade-up output float formula?

Normalize each exact input float before averaging. Every input uses its own skin-specific minimum and maximum:

Normalized input_i = (raw float_i − input min_i) / (input max_i − input min_i)
Average normalized = (normalized_1 + ... + normalized_N) / N
Output float = output min + average normalized × (output max − output min)

Do not use an input wear label or the raw arithmetic mean as a shortcut. A raw 0.04 input from a 0.00–0.08 skin is 0.50 normalized; a raw 0.04 input from a 0.00–1.00 skin is only 0.04 normalized. When a basket mixes input skins, normalize every item separately before taking the mean.

How do you calculate output float step by step?

Assume all 10 inputs use the same restricted range of 0.00–0.08 and their exact raw floats average 0.0096. Because the range is identical for every input, normalize that raw average:

Average normalized = (0.0096 − 0.00) / (0.08 − 0.00)
                   = 0.12

For a possible output with a permitted range of 0.00–0.50:

Output float = 0.00 + 0.12 × (0.50 − 0.00)
             = 0.12 × 0.50
             = 0.06

A 0.06 result is Factory New because it is below the 0.07 boundary. But another output in the same contract might have a 0.10 to 0.70 range:

Output float = 0.10 + 0.12 × (0.70 − 0.10)
             = 0.172

That outcome is Field-Tested. One input basket can therefore create different wear tiers across the output pool.

What are the CS2 wear boundaries?

WearGlobal float interval
Factory New0.00 to below 0.07
Minimal Wear0.07 to below 0.15
Field-Tested0.15 to below 0.38
Well-Worn0.38 to below 0.45
Battle-Scarred0.45 to 1.00

A skin's own minimum and maximum can remove some of these wears. If its minimum is 0.10, it cannot exist in Factory New even though the global FN interval starts at zero.

How do you find the maximum normalized input average?

First solve for the maximum average normalized input position when you know the output wear you need:

Maximum average normalized = (target boundary − output min) / (output max − output min)

For an output ranging from 0.00 to 0.50, the normalized average required to stay below the 0.15 Minimal Wear/Field-Tested boundary is:

(0.15 − 0.00) / (0.50 − 0.00) = 0.30

Your true normalized average must be slightly below 0.30, not exactly on it. Translate that limit through each input skin's range:

Raw input target = input min + normalized target × (input max − input min)

For inputs restricted to 0.00–0.08, a 0.30 normalized cap means a raw average below 0.024. For inputs restricted to 0.10–0.70, it means a raw average below 0.28. A mixed-skin basket has no single universal raw cap; validate the average of all per-item normalized values.

How much safety margin should you use near a boundary?

Use exact inspected floats and target an average normalized position comfortably under the calculated cap. A fixed raw-float margin is not equally useful across different input or output ranges, so judge the safety margin in output-float terms. If one wear-tier step destroys the contract's EV, a tiny theoretical saving on inputs is not worth boundary risk.

The best check is to normalize every selected input, calculate every outcome at the exact basket average normalized position, and flag the smallest distance to 0.07, 0.15, 0.38, or 0.45. Read our float compression and edge-case guide for why those small distances can create large price changes.

Can one expensive low-float input rescue the average?

Yes, mathematically. Each standard-contract input contributes one tenth of the normalized average. If nine selected items total 1.80 normalized units and your target average normalized position is 0.19, the tenth input can contribute at most:

Maximum normalized total = 0.19 × 10 = 1.90
Maximum tenth normalized value = 1.90 − 1.80 = 0.10

Convert 0.10 back through the tenth skin's own range. For a 0.00–0.08 input, its raw float must be at most 0.008; for a 0.10–0.70 input, it can be at most 0.16. This is useful when optimizing cost, but always validate the complete basket's normalized arithmetic.

What float-calculation mistakes are most common?

Once output float is known, combine its wear-specific sale price with the probability of that outcome. That produces the input for an accurate EV calculation.

Frequently Asked Questions

Do CS2 input floats get normalized before averaging?
Yes. For every input, calculate (raw float − that skin's minimum) divided by (that skin's maximum − minimum). Average those normalized values, then map that average onto each possible output skin's range.
Should I round the average input float?
No. Keep full precision for each raw float, each per-input normalized value, and their average. Only round for display after calculating every output, especially near 0.07, 0.15, 0.38, and 0.45.
Can the same contract produce different output wear tiers?
Yes. The basket has one average normalized input position, but each possible output has its own minimum and maximum. Mapping the same normalized average through those different ranges can produce Factory New for one skin and Field-Tested for another.
What average float do I need for Factory New?
First solve the output's normalized cap as (0.07 − output minimum) divided by (output maximum − output minimum). Then translate that cap through each input skin's own range; mixed input skins must be normalized individually, so there is no universal raw average-float target.
CS2FloatCalculator

Stop calculating contracts by hand

TradeUpTarget ranks opportunities found within each timestamped, bounded CS2 scan, with normalized float math, post-fee modeled EV, and execution state kept separate.

Open the Scanner →