A DEX dump is a large on-chain sell that walks the AMM curve down and craters the token's price in the pool below its price elsewhere (on a CEX or in another pool). Someone offloads a position straight into a thin pool, the x·y=k curve reprices instantly, and for minutes to tens of minutes a gap opens: the token is $0.30 in the pool while a market-maker bid on Bybit is still $0.50. Dump arbitrage is capturing exactly that gap - buy the crashed pool, sell where the price is still intact. Below: why the gap appears, how an on-chain route is computed, the executability checks specific to on-chain, and why most extreme "-90%" prints aren't tradeable at all.
What a DEX dump is
On a centralized exchange, price moves through the order book: to crater the price 50% you have to clear the entire bid side down to that level. In a pool on a DEX, price is moved by the trade itself. A pool is two piles of tokens (x and y), and the price is their ratio. One large swap changes that ratio immediately: sell a lot of token X into the pool and there's now more X in it, so X's pool price drops. No "clearing the book" - the curve reprices in a single transaction.
That's why a dump in a thin pool looks catastrophic: a $50k sell into a pool with $200k of depth walks the price down tens of percent in one block. On a CEX the same token still sits at the old price - the market maker hasn't reacted yet, or it's simply a different, deeper market. The arbitrage window lives in the gap between "the pool is already at the bottom" and "the CEX price is still intact."
The mirror case is an over-pump: someone buys a thin pool up and the pool price flies above the market. Same mechanics, opposite direction.
Where the gap comes from
The gap isn't driven by "news" - it's driven by liquidity structure. Three typical causes:
- Thin pool liquidity. The smaller the
k, the more any swap moves the price. In a $100k-deep pool, a $30k sell is already −20–30%. The same size on a CEX with a deep book is barely noticeable. The depth mismatch is what creates the gap. - A whale exit. A large early holder dumps a position into the only liquid pool. They don't go to a CEX (no token there / limits / KYC) - they sell on-chain, and the curve collapses under their size.
- A fresh listing. A token was just deployed, the pool is small, and the price jumps on every trade. On fresh pools, gaps against a CEX (if the token is already quoted somewhere) or against another pool are routine.
The key point: the gap is wider and lives longer the more expensive and risky it is to close. Closing it requires on-chain execution, gas, and MEV risk - so arb bots don't flatten the price instantly, and the window lives minutes, not seconds.
What the arbitrage is
The logic is the same as any arbitrage route, except the buy leg (or sell leg) lives in an on-chain pool:
- Dump: the pool price fell below the market → buy the crashed pool, sell where the price is intact (another CEX book or another pool). When the market "catches down" to the pool's floor, both legs converge - profit is the price difference, not direction.
- Over-pump: the pool price flew above the market → the reverse: sell high into the pool (or short a CEX perp), buy back cheap on the market.
The cleanest way to play the gap against a CEX is long DEX + short perp: buy the crashed token in the pool and simultaneously open a short of the same size on a CEX perp. The perp doesn't require holding the token on the exchange (you just bought it into your wallet), executes instantly, and closes at index price once the CEX book catches down to the pool floor. A walk-through of one real fire: SFUND −99.3%.
Executability checks - what's specific to on-chain
A visible "-90% in the pool" is a raw print, like any gross spread. On top of the standard route checks (fees, D/W, depth), on-chain adds its own:
1. Gas. Each leg is a transaction. On Ethereum a swap can cost $5–30, on Base / BSC / Solana - cents. Gas is subtracted from the gap exactly like a CEX fee. A small gap on an expensive network is eaten by gas entirely.
2. MEV / sandwich risk. Your buy of the crashed pool is visible in the mempool. A bot can jump in front of you (front-run), buy cheaper and sell to you dearer - your entry price drifts. On dumps this hurts especially: every bot is staring at the same anomaly. The defense is a private mempool / Flashbots-style submission and a sane slippage limit.
3. Slippage on a thin pool. The same thin pool that created the dump also moves under you. A $2k buy into a $200k pool will itself lift your entry price. The thinner the pool, the more you move the price against yourself - the gap must be computed against the real curve for your size, not against the last swap price.
4. Wrapped vs native. The pool may trade a wrapped token (bridged USDC, wrapped X) while the CEX lists the native one. These are different contracts with different liquidity: you bought the wrapped cheap but can't sell it at the native price. Always reconcile the pool contract against the CEX listing contract.
5. The pool actually has depth to fill your size. The most important and most common "no". A "-90%" can be printed by an $80 swap that leaves $300 of liquidity behind. There's physically nothing to buy with $1k there - your own purchase pushes the price right back. Executability is computed against the pool's real reserves (balanceOf of both tokens), not the virtual L·√P depth, which overstates by tens of times: in a real case the virtual estimate gave $49M against the actual $2.1M of reserves - a ~23× overstatement.
Why most "-90%" prints aren't tradeable
This is the central, honest point. The most extreme on-chain prints are almost always phantoms. Reasons:
- No liquidity. The pool is empty after the dump - nothing to buy (see check #5).
- One-sided / rug. It's not a dump, it's a liquidity pull: the developer yanked the entire pool (
Burn→ empty). The "-99%" price exists, but there's nothing to trade - the other side is zero. - Wash / fake amounts. The swap shows a giant notional that's physically larger than all of the network's reserves. A real case: a single swap of "78,492 WETH" while the entire V4 family on Base held 7,750 WETH - i.e. the amounts are fake (flash-accounting / custom hooks netting notional deltas). The "dump" price is painted, and you can't execute it.
- A stale print. The "floor" price has already bounced, but the aggregator shows the old value.
An important technical nuance here: old anti-fake heuristics built for aggregators (DexScreener/CEX) don't work on-chain. They false-flag quiet but real pools and simultaneously pass wash swaps through. Honest filtering of on-chain dumps needs its own signals: validating swap amounts against real reserves (|amount| ≤ reserves) and cross-pool coherence (a real token's pool-to-pool spread is <1.05×, while the ZORA wash case was 235M–1.67B× - caught instantly).
Reading rule for an on-chain dump: gross pool gap → minus gas → minus slippage on real reserves → check wrapped/native → check MEV risk → filter the phantom (rug/wash/empty pool). A dump is tradeable only if the pool floor actually has depth for your size.
Example: a thin pool + gas + slippage
Hypothetical alt DUMP traded at $1.00. A whale sells into a BSC pool, the pool price craters to $0.60 (−40%), while a Bybit perp is still quoting around $0.95. Raw gap - ~58%. Let's compute the real route on $2000 with the on-chain specifics.
BSC pool after the dump: price $0.60, real reserves ~$120k Bybit perp: index $0.95 (book hasn't caught down) Raw gap: ~58% (phantom number) Long DEX: buy into the pool, $2000 slippage on the $120k pool (we push the price up) ~$0.63 avg → 3175 DUMP at $0.63 avg BSC swap gas −$0.40 Short Bybit perp $2000 @ $0.95 taker 0.05% −$1.00 After ~8 minutes the Bybit book caught down to the pool floor: close the short at ~$0.66 short profit ≈ +$610 sell DUMP into the pool at ~$0.66 (bounce) ≈ +$95 over entry BSC gas + closing taker −$1.40 ────────────────────────────────────────────────────── Net ≈ +$700 (slippage and gas cut the ~58% gross to a real ~35% net)
This is the favorable scenario, with real pool depth. If reserves were $800 instead of $120k (the classic "-90% on an $80 swap"), slippage would lift the entry price back toward $0.95 within the first thousand - net zero, a phantom. The whole difference between "saw −58%" and "read a dump" is the real depth at the floor.
How an on-chain pool scanner helps
You can't monitor this by hand: you'd need to read swaps across all pools on dozens of networks at once, compute the price from each, keep real reserves on hand, and filter rug/wash on the fly. One token is doable, the whole market isn't.
A scanner that reads on-chain pools directly (subscribing to new blocks + decoding swaps across all AMM families), computes price from sqrtPriceX96 / executed amounts, pulls real reserves and filters phantom dumps, hands the operator a finished signal: symbol, chain, the pool contract next to the CEX listing contract (defense against ticker collisions), the real floor depth, and the recommended leg. That's what Finder's DEX-Dump channel does: per-pool emission (not a median - otherwise a real single-pool dump gets lost behind the "average" price), real reserves instead of virtual depth, anti-wash validation - and a push at the moment of the event, not after the fact. Full mechanics and checklist: the CEX–DEX arbitrage section.
FAQ - dump arbitrage
What is a DEX dump in simple terms?
A large sell straight into a DEX pool that, via the AMM curve, drops the token's price in that pool below its price elsewhere (on a CEX or another pool). A gap opens that you can arbitrage: buy the crashed pool, sell where the price is still intact.
How much can you make on dumps?
A typical DEX-dump window is 20–40% over a 5–15 minute horizon, with an average net on $1k around $200–500. Catastrophic events (−60%+) happen once every several weeks or months and pay multiples more (see SFUND ×30), but they're outliers, not a flow. Real outcomes are cut by gas, slippage and MEV.
Why do I see "-90%" but can't make money?
Because the extreme print is almost always a phantom: the pool is empty after the dump (nothing to buy), it was a rug (a liquidity pull, not a sell), a wash with fake amounts, or a stale price. Executability is computed against the real reserves at the pool floor, not against the last swap price.
How is on-chain arbitrage harder than ordinary cross-exchange arbitrage?
It adds gas (subtracted from the gap), MEV/sandwich risk (a bot jumps in front of your trade), slippage on a thin pool (your own buy moves the price) and the wrapped vs native trap (different contracts). The route-reading logic is the same, but there are more executability checks.
How do you tell a real dump from a rug and a wash?
A real dump: cheap + real depth + buyable (reserves are there). A rug: a Burn follows the dump - liquidity is pulled, the other side is zero. A wash: the swap amounts are physically larger than the pool's real reserves, plus an absurd pool-to-pool spread. What separates them is validation against real reserves and Burn events, not the price by itself.
This is not investment advice. A pool "dump" is a raw number. Real profit depends on gas, slippage at the real depth, MEV risk and a matching contract/network. Half the "dumps" in the wild are the start of a real collapse or a rug, not a bounce. The anti-fake filter on the signal is the first line of defense. Verifying the contract (GoPlus / honeypot.is) is the second.
Next: what an arbitrage route is and how to read it, CEX–DEX arbitrage, cross-chain arbitrage. The big picture - the pillar guide Crypto arbitrage. Live routes and DEX dumps across 20+ exchanges and 30+ networks, net of network and D/W - in the web dashboard.