Slippage, Price Impact and Minimum Received Explained
This article is part of our step by step DeFi learning series. If you would like to start from the beginning, you can access the first article here.
In the previous articles we explored the fundamental building blocks of DeFi step by step. In particular, in the last article we examined how decentralized exchanges (DEXs) work, the liquidity pools behind swap transactions, and the AMM mechanism.
Now we will focus on a very common question almost everyone encounters when using a DEX:
Why is the price I see on the screen different from the result I receive?
Why do I sometimes receive fewer tokens than expected after a 1000 dollar swap?
Why do transactions sometimes fail completely?
The answer to these questions usually lies in three concepts:
slippage, price impact, and minimum received.
Using a DEX without understanding these concepts means simply pressing buttons. To act with understanding, you need to learn not just how the price appears on the screen, but how it actually forms on chain.
Why this topic matters
For many users, the first real interaction in DeFi is a swap.
A wallet is connected, a token is selected, an amount is entered, and the user presses confirm.
That is the moment when theory becomes practice.
In practice, users often experience something like this:
- they see a number on the screen
- they approve the transaction
- the result is different from what they expected
As a result, users often think:
"The interface showed me the wrong price."
In most cases the problem is not that the interface lied. The problem is that the user confused the concepts of quote, liquidity, execution, and price movement.
The price you see on a DEX is not a fixed reality. That value can change depending on the pool state, the trade size, network conditions, and the time it takes before the transaction is written to the blockchain.
In other words, the number on a DEX screen is not a promise. It is an estimate.
Quote price and execution price are not the same thing
The first price you see on a swap screen is usually a quote.
It is an estimated result calculated from the current pool data.
For example, you enter 1000 USDC and the interface shows that you will receive approximately 0.5 ETH.
This value is close to the result you would get if the pool ratio stayed unchanged.
However after you confirm the transaction two things may happen:
- your transaction may be large enough to affect the pool
- other transactions may change the pool state before yours is executed
Because of this, the real result that appears on chain, called the execution price, may differ from the number you originally saw.
In short:
- quote price = estimated price before execution
- execution price = real price formed when the transaction executes
Understanding this difference is extremely important. One of the most common beginner mistakes is assuming the quote is guaranteed.
Why there is no single swap price
Someone familiar with traditional exchanges might imagine price as a fixed label.
But in a DEX system, price emerges from a dynamic balance.
In AMM based systems, price depends on the ratio of the assets in the pool.
If the balance changes, the price changes.
For that reason the word "price" in a DEX does not usually refer to a single number. A more accurate description is:
Price is an execution result that depends on the pool state and the trade size.
A small swap and a large swap may not receive the same execution quality.
Even for the same token pair, two users trading different amounts can receive different results.
What is price impact
Price impact is the effect your own trade has on the pool ratio.
The simplest way to imagine it is this:
Assume a pool contains 100 ETH and 200,000 USDC.
In that situation the implied price is roughly 2000 USDC per ETH.
If you buy a small amount of ETH, the pool ratio changes very little. The price barely moves.
But if you buy a large amount of ETH, a significant amount of ETH leaves the pool and a large amount of USDC enters it. Because the ratio changes, the price moves against you.
As you trade, you also change the balance of the market you are trading in.
That effect is called price impact.
This leads to an important principle:
Large trades do not only spend more capital. They also tend to receive worse execution.
Trade size and liquidity
One of the most important factors that determines price impact is the ratio between trade size and pool liquidity.
The same trade size can have very different results:
- in a deep pool the impact may be small
- in a shallow pool the impact may be large
For example a 1000 dollar swap:
- may execute easily in a pool with millions of dollars in liquidity
- may cause large slippage in a pool with only tens of thousands of dollars
This is why looking only at the token name is not enough.
Liquidity depth also determines execution quality.
Beginner users often assume:
"The token exists so it must be tradable."
But in practice the real question is:
How healthy is the market for this token?
If liquidity is weak, not only entering the position becomes harder, exiting may also become difficult.
This shows why low liquidity can be dangerous.
So how can a beginner evaluate whether a token market is healthy?
Before trading on a DEX it is useful to check several simple indicators:
- Total liquidity: how much value is locked in the pool? Pools with only a few thousand dollars are often fragile.
- 24 hour trading volume: is the token actively traded?
- Price impact indicator: if even a small trade shows high price impact, liquidity may be shallow.
- Pool distribution: is liquidity concentrated in one small pool or spread across multiple DEXs?
- Spread and price stability: if small trades move the price significantly the market may be weak.
A generally safer approach for beginners is:
Trade in markets with high liquidity, regular trading volume, and low price impact.
What is slippage
Slippage is the difference between the price you expect and the price that actually executes.
The important point is this:
Slippage does not simply mean that the price moved. It means that the execution result differs from the expected result.
Some users confuse slippage and price impact. They are related but not identical.
- Price impact is usually caused by your own trade moving the pool.
- Slippage is the difference between expected and actual execution.
Price impact can therefore be one cause of slippage, but not the only one.
Two main sources of slippage
Slippage usually comes from two main sources.
1. The trade is large relative to the pool
If your trade is large compared with pool liquidity, your transaction itself moves the price.
This directly reduces execution quality.
This is the price impact component.
2. The pool state changes before execution
After you press confirm the transaction is not final immediately.
It enters the mempool, validators select it, and eventually it is included in a block.
During that time other users may trade in the same pool.
The pool ratio may change.
As a result the pool state when you received the quote may differ from the pool state when the trade executes.
That difference creates slippage.
Sometimes the issue is not your trade size but the market changing while you wait.
What happens when markets move quickly
During calm periods prices move slowly and pool ratios remain relatively stable.
However during strong rallies or crashes prices can change dramatically within seconds. This directly affects DEX execution.
Imagine ETH rapidly increasing in price.
If a user swaps 100 USDC for ETH the trade is small and the pool is barely affected. Price impact is low. If the transaction enters a block quickly, the user may receive a result close to the quote.
But other users may also be sending buy orders at the same time. If your transaction waits in the mempool for a few seconds the pool ratio may change. Your execution price may be slightly worse than the original quote.
Now consider the same scenario with a larger trade.
If a user swaps 50,000 USDC for ETH two things can happen simultaneously:
- the trade itself changes the pool ratio significantly
- the market may also move while the transaction is waiting
The user experiences two effects at once:
- price impact from their own trade
- slippage caused by market movement
As a result the execution price can differ greatly from the original quote.
This is why large trades during volatile markets are harder to execute efficiently.
How slippage appears in real markets
In practice slippage becomes noticeable in three situations:
- the trade size is large relative to liquidity
- the pool liquidity is shallow
- the market is moving rapidly
Example 1 deep liquidity pool
A user wants to swap 100,000 USDC for ETH.
Assume the pool contains 30 million dollars of liquidity.
The swap interface may show approximately 33.3 ETH.
After execution the user may receive 33.1 ETH.
The difference is a small slippage which is normal for that trade size.
Example 2 shallow liquidity pool
Now imagine the same trade in a pool containing only 4 to 5 million dollars of liquidity.
The same trade now changes the pool ratio much more.
During execution:
- price impact rises
- the average purchase price increases
The user may receive a result several percent worse than the original quote.
Example 3 rapid market movement
Suppose ETH trades around 2000 dollars.
You send a swap transaction based on that price.
Before the transaction enters a block the price moves to 2020 dollars.
The trade now executes closer to the new price.
That difference appears as slippage.
These examples highlight an important point:
Liquidity, trade size, and market movement combine to determine execution results.
How centralized exchanges handle this
Centralized exchanges (CEXs) use a different market structure.
They rely on an order book where users place buy and sell orders at specific prices.
For example an order book may contain:
- sell orders at 2000 USDT
- buy orders at 1999 USDT
If you submit a market order the system matches your trade against existing orders.
Small trades only consume the best available orders.
Large trades consume multiple price levels which increases the average execution price.
So large trades can still receive worse execution, but the mechanism differs from AMM pools.
CEXs also differ in several ways:
- trades execute inside the exchange infrastructure
- execution usually happens within milliseconds
- there is no mempool delay
- trades rarely fail
However there is a trade off.
In a DEX the user retains custody of assets.
In a CEX the exchange holds custody.
Execution quality and custody therefore involve different trust assumptions.
Why slippage can occur even with stablecoins
Many beginners are surprised by this question:
"USDC and USDT are both stable. Why is there slippage?"
Because being a stablecoin does not guarantee perfect execution.
Several factors still apply:
- the peg is not perfectly fixed
- liquidity differs across networks
- stressed market conditions can create imbalances
- large trades can still move the pool ratio
Even stablecoin swaps can produce unexpected results during volatile periods.
What is slippage tolerance
DEX interfaces usually allow users to set slippage tolerance.
This value defines the maximum price movement you are willing to accept.
For example if you choose 0.5 percent tolerance the system behaves roughly like this:
"If the final execution is worse than this limit, reject the transaction."
This setting has two effects:
- low tolerance offers protection but increases the chance of failure
- high tolerance increases the chance of execution but exposes you to worse prices
Slippage tolerance is therefore a risk control parameter.
What minimum received protects
The minimum received value defines the worst acceptable outcome.
The logic works as follows:
- the system calculates a quote
- the slippage tolerance defines the acceptable lower bound
- if the result falls below that bound the trade fails
In simple terms:
minimum received is the lower limit that protects you from poor execution.
Can you guarantee the exact swap result
Many users ask:
"Can I guarantee receiving exactly what the interface shows?"
In a DEX environment the answer is usually no.
Swaps depend on pool ratios and real time market conditions.
However several practices can reduce differences:
- Use smaller trades
- Split large trades into parts
- Adjust slippage tolerance carefully
- Prefer deeper liquidity pools
These approaches help keep execution closer to the quote.
Why swaps sometimes fail
A failed transaction does not necessarily mean something broke.
A swap can fail for several reasons:
- slippage tolerance too low
- pool state changed
- insufficient liquidity
- route invalid
- network conditions changed
Even if a swap fails gas may still be consumed because the network executed computation to verify the transaction.
Gas fee swap fee and price impact are different
These are often confused.
Gas fee is the cost of executing a transaction on the blockchain.
Swap fee is the protocol fee distributed to liquidity providers.
Price impact is the market effect of your trade changing the pool balance.
Slippage is the difference between expected and actual results.
Understanding these differences helps users identify the true source of execution loss.
Why large trades often perform worse
Large trades move the pool balance more significantly.
As trade size increases relative to liquidity, price impact increases and execution worsens.
This leads to the next topic in the series.
Because making a large trade and making a large trade efficiently are not the same thing.
Whale influence in DEX markets
Large traders, often called whales, can influence DEX markets.
When a whale performs a large swap several things may happen:
- the pool ratio shifts rapidly
- price impact increases
- smaller traders may receive worse execution
In shallow pools this effect becomes even stronger.
Large players may also test liquidity by sending small trades first, sometimes called liquidity probing.
What is MEV and sandwich attack
Sometimes slippage is not only caused by market movement.
Transactions are visible in the mempool before they are finalized. Some bots monitor this activity.
If a large trade appears a bot may:
- buy just before the transaction
- allow the user's trade to push the price
- sell immediately afterward
This is called a sandwich attack.
As a result users may experience worse execution.
MEV bots do exist. Some are open source research tools while others are operated by professional teams.
In practice much of MEV activity is performed by teams with strong infrastructure, trading firms, or research groups.
Competition is intense. Many bots compete for the same opportunity, and the fastest one wins.
Milliseconds matter. Network latency and execution speed can determine which transaction enters the block first.
A similar competition exists in traditional finance with high frequency trading firms.
In DeFi the same race occurs between automated systems monitoring the mempool.
Multiple pools can exist for the same token
A token pair may exist in several pools.
For example ETH USDC may exist:
- with different fee tiers
- across multiple DEXs
This means the best execution may not always come from the first pool you see.
This leads to the concept of DEX aggregators which search multiple pools to find better execution.
Tools used to check liquidity
Experienced users often check data tools before trading.
Examples include:
- GeckoTerminal
- Dexscreener
- DEXTools
These tools show liquidity, trading volume, and pool structure.
Common beginner mistakes
Common mistakes include:
- assuming the quote is guaranteed
- confusing price impact and slippage
- mixing gas cost with execution loss
- trading large amounts in low liquidity pools
- assuming stablecoin swaps are always perfect
- ignoring the minimum received value
- setting slippage tolerance too high
- assuming failed trades cost nothing
Most of these mistakes come from treating the numbers on a DEX interface as fixed values.
In reality they are estimates influenced by liquidity, trade size, latency, and market conditions.
Quick pre swap checklist
Before executing a swap ask yourself:
- am I on the correct network
- is the token contract correct
- is this approval or swap
- do I understand the difference between quote and execution
- what is the price impact
- does the minimum received value make sense
- is liquidity deep enough
- should I test with a smaller trade
Why we focused so much on DEX
DeFi is much broader than DEX trading.
But many DeFi systems rely on DEX infrastructure:
- lending protocols
- liquidity providing
- yield strategies
- portfolio rebalancing
Understanding DEX mechanics is therefore fundamental to understanding DeFi.
Key terminology summary
- Quote price estimated output
- Execution price final price
- Liquidity available pool assets
- Price impact your trade moving the pool
- Slippage difference between expected and executed
- Mempool waiting area for transactions
- Gas fee network execution cost
- Swap fee protocol trading fee
- Slippage tolerance allowed price deviation
- Minimum received worst acceptable outcome
- Liquidity pool contract holding trading assets
- Routing path used to execute the swap
- State current pool balance
In DeFi price is not just a number.
It is the result of liquidity, trade size, and time.
Using a DEX is not only converting one token into another.
It is interacting with liquidity, execution mechanics, and network dynamics.
In the next article we will explore how to execute swaps more intelligently using aggregators and routing strategies.
Originally published on X · 2026-03-09
Post on X
Telegram