Slippage and Price Impact: Why Big Trades Pay More

You’ve seen the magic equation: x·y=k, and the rule that a swap walks the curve — the bigger your trade, the worse the price. That’s nice in the abstract. But you’re a trader now, you’ve got real money in your wallet, and the interface just flashed two scary words at you: “Price impact: 11%” and “Slippage tolerance: 0.5%”. They sound like the same thing. They are not. One is a tax you can calculate before you click. The other is a surprise the blockchain springs on you between signing and mining.

This lesson untangles the two, shows you the arithmetic of why a whale pays more than a minnow for the exact same token, and arms you with the one setting — slippage tolerance — that stands between you and getting your face eaten by a bot. Let’s get specific.

Spot price vs execution price: the quote is a lie for big orders

Open any swap interface and it shows you a spot price — say ETH is $2000. That number is the marginal price: what one infinitesimally small slice of ETH costs right now. On a constant-product pool it’s just the ratio of reserves, $\text{spot} = y/x$. Buy a single wei of ETH and yes, you pay almost exactly $2000 for it.

But you’re not buying a wei. You’re buying 10 ETH. And here’s the catch: as you pull ETH out of the pool, x shrinks, y grows, and the price y/x climbs while your own order is filling. Each successive slice of your ETH costs more than the last. The price you actually end up paying — averaged over your whole order — is the execution price (also called the average price):

$\text{execution price} = \frac{\text{total Y paid}}{\text{total X received}}$

Spot is the price for a hypothetical zero-size trade; execution is the price for your trade. For a tiny order they’re nearly identical. For a big one, they diverge hard — and execution is always the worse of the two.

Price impact: the tax you can compute before you click

Price impact is exactly how far your own trade drags the price away from spot. Define it as the gap between spot and your execution price, as a fraction of spot:

$\text{impact} = \frac{\text{spot} - \text{execution}}{\text{spot}}$

The beautiful (and brutal) thing: it’s deterministic. Given the pool’s reserves and your trade size, the impact is fixed by arithmetic. No randomness, no other traders — just x·y=k. Let’s grind the numbers.

The pool. 100 ETH and 200,000 USDC, so $k = 100 \times 200000 = 20{,}000{,}000$. Spot price = 200000 / 100 = $2000 per ETH.

The whale buys 10 ETH. You’re taking ETH out, so x drops to 90. To keep k constant, the USDC reserve must rise to:

$y' = \frac{k}{x'} = \frac{20{,}000{,}000}{90} \approx 222{,}222$

So you must put in 222,222 − 200,000 ≈ 22,222 USDC to get 10 ETH. Your execution price is 22,222 / 10 ≈ $2222 per ETH — versus a spot of $2000. Price impact:

$\frac{2222 - 2000}{2000} \approx 11\%$

And the pool’s new spot price afterward is 222222 / 90 ≈ $2469 — you pushed the price up nearly 25% just by trading. (Your execution price of $2222 sits between the old spot $2000 and the new spot $2469, which makes sense: you filled across that whole range.)

The minnow buys 0.1 ETH. Same pool. Now x' = 99.9, and:

$y' = \frac{20{,}000{,}000}{99.9} \approx 200{,}200$

You pay about 200 USDC for 0.1 ETH → execution ≈ $2002 per ETH, impact ≈ 0.1%. Essentially the quoted price.

Same token, same pool, same instant — the whale pays $2222 and the minnow pays $2002. The only difference is size relative to the pool. That’s price impact in one table:

Watch the curve bite

Drag the trade-size slider and watch price impact climb as your order grows from a sliver to half the pool. Then flip the depth preset and see the same trade do far less damage to a deeper pool.

Slippage is NOT price impact: the surprise vs the tax

People mash these two words together constantly. Keep them apart — they have different causes:

• Price impact is the expected move from your own trade size. You know it the instant you type the amount, because it’s baked into the pool’s reserves. It’s the tax you agreed to.
• Slippage is the difference between the price you expected when you hit submit and the price you actually got when the trade mined — caused by the pool changing between quote and confirmation. It’s the surprise.

Why would the pool change in those few seconds? Because on-chain, time passes between signing and mining. Your transaction sits in the mempool waiting for a block. In that window, other people’s trades can land first — each one shifts the reserves — or the block is simply delayed while the market moves. By the time your swap executes, the spot price isn’t what the interface quoted. The extra gap, beyond the price impact you signed up for, is slippage.

Put crudely: price impact is what your order does to the price; slippage is what everyone else’s orders (and time) do to the price before yours lands. A tiny trade has near-zero price impact but can still suffer slippage if the market lurches while it’s pending.

Slippage tolerance: the guardrail you set

Since slippage is unpredictable, the swap contract lets you cap it. You set a slippage tolerance — say 0.5% — and the contract converts it into a hard floor called the minimum amount out:

$\text{min out} = \text{quoted out} \times (1 - \text{tolerance})$

If, at execution time, the pool would give you less than that minimum, the transaction reverts — it fails, you keep your tokens (minus gas), and nothing trades. It’s a stop-loss against nasty fills.

Worked example. The interface quotes you 10 ETH out for your USDC, tolerance 0.5%. Then min out = 10 × (1 − 0.005) = 9.95 ETH. If, by the time your swap mines, the pool can only hand you 9.96 ETH, fine — that’s within tolerance, the trade fills. If it can only manage 9.9 ETH, the contract sees that’s below 9.95 and reverts the whole thing. You’d rather not trade than overpay by that much.

The setting is a balance, and both extremes hurt:

The right number depends on the pool: deep, calm pools tolerate a tight 0.1–0.5%; thin or fast-moving pairs need more room. Just know that every bit of slack you grant is a bit a bot is allowed to steal.

Pool depth: why a $100k trade is nothing — or everything

Here’s the cleanest fact in this whole lesson: on a constant-product pool, price impact depends on your trade size as a fraction of the reserves, not on the dollar amount alone. Buy 10% of the ETH in any pool and you’ll get roughly the same price impact, whether the pool holds 100 ETH or 100,000.

So depth — the size of the reserves, i.e. a bigger k — is the trader’s best friend. Deeper pool ⇒ your fixed-dollar trade is a smaller slice of it ⇒ less price impact:

• A $100,000 swap into a $100,000,000 pool is 0.1% of the reserves — barely a ripple, impact in the low basis points.
• That same $100,000 swap into a $200,000 pool is half the reserves — a catastrophe, double-digit impact, you’ll move the price violently and pay through the nose.

Same trade, wildly different outcomes, purely because of depth. This is why blue-chip pairs on big pools feel almost like a centralized exchange, while a thin meme-coin pool punishes anything but dust. When you’re sizing a trade, the question isn’t “how many dollars?” — it’s “what fraction of this pool am I?”

Splitting and routing: how pros dodge the impact

If price impact comes from being a big fraction of one pool, the fix is obvious: don’t be. Traders split a large order into smaller pieces spread across time (let the pool recover between slices, often via arbitrage) or across multiple pools and routes (take some ETH from the Uniswap pool, some from another, some through an intermediate token), so no single pool absorbs the whole shock. Aggregators and routers (1inch, Uniswap’s own router, CoW Swap) do this automatically — they shatter your order across the deepest available liquidity to minimize total price impact, then hand you the best blended execution. You typed one swap; under the hood it became a dozen.

Sandwich attacks: why “too loose” gets you robbed

Remember that loose slippage tolerance invites trouble? Here’s the predator. Your swap sits in the public mempool, visible to everyone, before it mines. A sandwich bot sees it coming and wraps it in two transactions of its own — this is a flavor of MEV (maximal extractable value):

1. Front-run: the bot buys the same token just before you, pushing the pool’s price up.
2. Your trade fills at that worse, inflated price — eating right up to whatever your slippage tolerance allows.
3. Back-run: the bot immediately sells into the price your trade just pushed even higher, pocketing the difference.

You’re the filling; the bot’s two trades are the bread. The profit it skims comes straight out of your pocket — and the amount it can steal is capped by your slippage tolerance. Set tolerance to 5% and you’ve told the bot, in writing, “you may worsen my price by up to 5% and I’ll still accept it.” Set it to 0.5% and the attack is barely worth the gas. This is the whole reason a tight, sensible tolerance matters, and it’s a preview of an entire later topic on MEV and transaction ordering — for now, just know: your slippage tolerance is the bot’s allowance.

Key Takeaways

Next up: impermanent loss — you’ve seen how trades cost the trader; now flip sides and meet the hidden cost of being a liquidity provider, where simply holding the pool can leave you worse off than holding the tokens.