CS2 Trade-Up Guide

CS2 Trade-Up Edge Cases: How Float Compression Multiplies Returns

What is a CS2 trade-up edge case?

The CS2 skin market does not price wear tiers continuously. It prices them in steps. A Field-Tested AK-47 Vulcan at 0.1501 float and a Minimal Wear AK-47 Vulcan at 0.1499 float are visually indistinguishable, but they sit on opposite sides of the 0.15 wear boundary — and the MW typically sells for 1.8–2.4× the FT price. That gap is a price cliff.

An edge case trade-up is a contract whose output float is engineered to land on the cheap side of one of these cliffs, capturing the next-tier-up price while paying the current-tier-down input cost. Done correctly, a single edge case can deliver 30–80% ROI on a contract that, without the cliff, would be barely break-even.

Where the price cliffs are

There are four major boundaries in CS2 and the price-multiplier gap across each:

• 0.07 (FN ↔ MW): Usually 1.5–3× gap. Largest gap on popular skins like the M4A4 Asiimov.
• 0.15 (MW ↔ FT): Usually 1.5–2.5× gap. The most exploited cliff because output floats from contracts cluster around 0.15.
• 0.38 (FT ↔ WW): Usually 2–4× gap. Huge for Battle-Scarred input contracts.
• 0.45 (WW ↔ BS): Usually 1.3–2×. Matters most on AWPs and knives.

The float compression effect

Here is the key insight. The CS2 trade-up output float formula is:

output_float = (avg_input_float × range) + output_min

If the output skin has a tight range (e.g. min 0.00 / max 0.50, range = 0.50), the output float is compressed relative to the input float average. An input average of 0.30 produces an output float of 0.15 — landing exactly on the MW/FT boundary.

The compression ratio is (1 ÷ range). A skin with a 0.50 range compresses 2×; a skin with a 0.20 range compresses 5×. Skins with tight wear ranges are edge-case factories.

Worked example: an MW edge contract

Suppose we want to output a Minimal Wear AK-47 Aquamarine Revenge (min 0.00 / max 0.50, MW price $80, FT price $32). We need the output float to land below 0.15.

output_float ≤ 0.15
0.15 ≥ (avg_input_float × 0.50) + 0.00
avg_input_float ≤ 0.30

Any input average up to 0.30 puts us in MW. But here is the catch — only one of the possible outputs from our input pool will be the Aquamarine Revenge. Other outputs from the same input collection might have wider wear ranges and need different float targets to land in MW. The contract is only edge-favorable if the weighted average of all possible MW vs. FT outcomes still beats input cost.

The "highlighted output" pattern

In practice, the most profitable edges happen when one specific output in the pool has both:

1. A large MW vs. FT (or FN vs. MW) price gap.
2. A high probability in the output distribution (5+ of your 10 inputs come from its collection).

That single output dominates the EV calculation. We call this the highlighted output on TradeUpTarget's scanner — the one skin whose boundary-landing carries the contract. The scanner flags it automatically on every edge contract.

Why generic calculators miss CS2 edge cases

Generic calculators compute the output's expected wear tier using rough averages:

// Generic, wrong:
expected_wear = avg(possible_output_wears)
ev = expected_wear.price × probability

This ignores the entire mechanism. The actual float is deterministic given the inputs, and "average wear" is meaningless when the price distribution is discontinuous at boundaries. The correct math:

// Correct:
for each possible_output:
  output_float = compute_float(avg_input, output_min, output_max)
  output_wear = float_to_wear_tier(output_float)
  output_price = market_price(output_skin, output_wear)
  ev += probability × output_price × (1 − fee)

This is what gets float-edges right.

How to find CS2 trade-up edge cases yourself

1. Identify pairs where an output skin has both a tight wear range (e.g. max 0.50 or less) and a high MW/FT or FN/MW price gap.
2. Compute the input float average that puts that output within 0.01 of the boundary.
3. Verify input prices at that float exist on the market — many tight-float listings are thin.
4. Run EV including all output collection pulls, not just the targeted skin.
5. Check post-fee profit, not pre-fee.

Realistically, this is computationally heavy. TradeUpTarget's edge case detector runs the full calculation against the live market on every refresh and surfaces the ones whose math currently works. Most CS2 edge windows last 30 minutes to a few hours before someone executes them or the market shifts.

Common edge-case mistakes

• Trusting the "tight range = edge" heuristic blindly. A tight-range output is only an edge if the MW vs. FT (or relevant boundary) price gap is large. Some tight-range skins have flat pricing.
• Ignoring liquidity on the cheap side of the cliff. If the MW version of your target skin has 2 listings on Steam and you output one, you have to sell into a thin bid — your realized price may be 20% below the listing.
• Targeting too close to the boundary. A 0.149 target sounds safe, but Valve's float math has tiny rounding noise. Aim for at least 0.005 of margin away from the boundary.
• Forgetting StatTrak boundaries. StatTrak prices have their own gaps, often wider, but with thinner liquidity.

Frequently Asked Questions