CS2 Trade-Up Contracts: The Math Behind Them
How ten skins become one tier higher, how the output float is calculated, what knife crafting changed, and why most contracts lose money.
A trade-up contract exchanges ten skins of one tier for a single skin one tier higher. The mechanic looks like a way to build something expensive out of cheap parts, and occasionally it is — but by default a contract is a lottery with negative expected value, just slightly less obvious than a case.
How the contract works
- You put in ten skins of the same tier (Consumer, Industrial, Mil-Spec, Restricted, Classified).
- You get one skin a tier higher, from the collection of one of the inputs.
- StatTrak trades for StatTrak, normal for normal; you cannot mix them.
On October 23, 2025 a second form arrived: five Covert skins produce a knife or gloves from the collection of one of the inputs (five StatTrak Coverts give a StatTrak knife). That update is what crashed knife prices and lifted cheap Coverts — the details are in the piece on investing in skins.
The hardest hit landed on the most liquid knives — the ones this contract produces most often:
The output float comes from a formula
This is the one real difference from a case: the wear of the result is predictable. It is derived from the average float of the inputs, mapped onto the range of the output skin:
output_float = (average_input_float) × (output_max − output_min) + output_min
What follows in practice:
- feed in low-float copies and the result lands near the bottom of its own range;
- if the output skin has a narrow range (min 0.10, say), no average will ever produce Factory New;
- this is exactly what "low-float contracts" are built on: collect cheap inputs with minimal wear and produce a rare FN in a place where the market has barely seen one.
What is not predictable: which skin drops (the chance is proportional to how many inputs come from each collection) and what the paint seed will be. So a contract aimed at a pattern does not work — the seed is always random.
🔧Trade-up calculatorfree, no sign-upWhy most contracts lose money
The expected-value formula is the same as for cases: the sum of "price of each outcome × its probability". Three things work against you:
- The cost of ten inputs is often higher than the median outcome. The market priced the popular contracts long ago, and the obvious ones are picked clean.
- The selling fee — the result still has to become money, and that costs 2–8% on third-party marketplaces or 15% of the seller's total on Steam.
- Condition spread. The skin you pull can land in a condition worth half of what you were counting on.
Contracts that do work usually live in narrow spots: a condition that is hard to get from drops, or a collection that no longer drops at all. That is manual searching, not a strategy of "buy any ten".
The order of magnitude shows up in live prices. Here is the bottom of Mil-Spec, the tier most inputs are assembled from:
Live prices: the list is built when the page opens
And here is the bottom of Restricted, the tier such a contract outputs into:
Live prices: the list is built when the page opens
Compare the scale rather than individual rows: the input is ten items from the first list, the output is one item from the second, and a fee still comes out of it before you see any money. Both lists are live and show the floor of each tier, not the median outcome of a specific contract — your own contract still has to be worked out on its own collection.
How to price a contract before you build it
- Add up the real cost of entry: ten skins at what you actually pay, not at the lowest listing.
- List every possible outcome with its probability (proportional to the collections of your inputs).
- Compute the output float from the formula — the condition, and therefore the price, follows from it.
- Subtract the selling fee from every outcome.
- Compare the sum of "price × probability" against your cost of entry. If the gap is under a couple of dozen percent, the contract pays for neither the risk nor your time.
Where trade-ups do make sense
Most contracts losing money does not make them useless. There are three cases where building one is justified, and all three share a trait: you are not hoping for luck, you are exploiting a property of the mechanic.
Collections with a narrow output. If the input collection has only one or two items on the next tier, the result is almost fully predictable. That is no longer a lottery but an exchange of ten cheap items for one specific one — and the question reduces to arithmetic: is assembling the input cheaper than buying the output.
An expensive float from a cheap input. The output float is the average of the inputs, mapped onto the output skin's range. Collect ten items with very low floats and you can land an output in a condition that trades noticeably above the average. Here you are paying for search effort, not for luck.
Clearing out illiquid stock. Small items nobody will buy individually because of fees become inputs in a contract. Even an output priced at the sum of its inputs beats a position you cannot sell at all.
What a contract will never do
It does not create value out of nothing: across the whole market the total value of outputs is always below the total value of inputs, because part of it is lost to variance and to the fees paid buying the inputs. Any strategy of "build contracts continuously and sell the outputs" converges to a loss over distance — exactly like opening cases.
And separately: a contract is irreversible. Ten items disappear, the output is issued immediately, and there is no undo. Check the composition and the floats before you press, not after.