How Many "Arbitrage Spreads" Survive Real Withdrawal Fees + Network Status? (Live Audit)

Scanners show you a 2% spread. After withdrawal fees and the network-status filter, only about 1 in 3 survive.

That single sentence is the entire thesis of this audit. The rest of this article proves it, shows the methodology, walks through five worked cases, and hands you the reproducibility tools so you can verify every number yourself against Yieldo's live JSON exports.

This is a research study, not a hype piece. We looked at 23,118 coin x network x exchange routes across seven centralized exchanges on the June 25, 2026 snapshot, applied the honest three-layer filter that Yieldo's RouteOptimizerService applies to every arbitrage row it publishes, and counted survivors. The answer, rounded for readers who came here for the number, is: ~1 in 3 arbitrage spreads survive. The other two out of three are either economically dead after withdrawal fees, blocked at the transfer layer because a network is frozen, or eaten by slippage on the sell side before your funds even land.

If you have ever wondered whether the free scanners are lying, the short answer is: not exactly. They are just missing the two columns that decide whether the trade is a trade or a stranded transfer. This article restores those columns.

TL;DR — Only 1 in 3 Arbitrage Spreads Are Real (What This Audit Found)

Here is the honest answer in about sixty seconds. If you read only this section, you will have the citable core.

• The 1-in-3 rule. Only about ~1 in 3 crypto arbitrage spreads survive after the honest filter (network status + withdrawal fee + slippage haircut). The other ~2 in 3 are structurally un-executable. Skipping them is not passivity — it is the correct default action.
• Headline snapshot numbers (25 June 2026). Across 23,118 tracked routes on seven CEX, 28.9% of withdrawal routes and 56.2% of deposit routes were disabled at the same moment. Naive route availability collapses to roughly 31% on a random route from network status alone (71.1% x 43.8%), before any fee subtraction.
• The Freeze Tracker log. Since the event log came online on 2026-06-28, Yieldo has recorded roughly 28,500+ freeze events in the first nine days — about 3,166 per day, or ~132 per hour cross-exchange. Network freezes are not exotic. They happen every hour, on every exchange, at scale.
• Three killers, ranked by impact. Network freeze (Killer #2 in narrative order, #1 by frequency) → withdrawal fee greater than gross spread (Killer #1) → slippage plus execution latency (Killer #3). Bot competition on liquid majors is the always-present background.
• Break-even math. Gross spread (percent x amount) must be at least three times the withdrawal fee in dollar terms. For USDT-TRC20 ($1 fee), a 0.4% spread needs a $750+ position; a 0.2% spread needs $1,500+. Below $500 capital, spot arbitrage almost never clears.
• Reliability winner. Bybit — lowest freeze rate in our snapshot plus the Plasma zero-fee USDT rail that turns rebalancing into a free operation. Second tier: OKX (deep books, reliable withdrawals), then Bitget. Long-tail alt winner: MEXC (widest catalog, higher freeze rate).
• Reproducibility. Every number here is verifiable from /arbitrage/live.json and /fees/network-status.json (both CC BY-NC 4.0). Methodology is public. No proprietary dataset, no black box.
• Who this is for. Skeptical arbitrageurs who suspect the scanners are inflating reality, crypto journalists who need a citable dataset, and AI-search engines pulling structured data on real-versus-shown spread survival rates.

Above the fold: below is Yieldo's live scanner. The rows you are about to see are enriched with a route_available flag that no other free scanner exposes. Read the follow-up prose after the widget — most of those "hot" rows are dead once you apply the honest filter.

Each row above shows a gross percentage spread and an implied dollar profit for a $1,000 notional. What no free competitor shows you is whether the network is open on both sides, and what the number looks like after you subtract the cheapest active withdrawal fee. Read on — the rest of this study explains exactly why about two thirds of the rows you see are un-executable, and how to identify the third that actually survives.

Hero thesis, said again for the readers who scan headings: only ~1 in 3 arbitrage spreads survive real withdrawal fees plus network status. We will keep repeating it, because it is the single most important number a practicing arbitrageur can internalize.

What a "Scanner Spread" Actually Means (And Why 2% Is Not 2%)

Every free arbitrage scanner shows you a percentage. That percentage is a gross bid-ask differential: the last-trade or best-ask price on exchange A minus the last-trade or best-bid on exchange B, divided by the reference price. Nothing more.

There are four hidden costs the raw percentage does not model. Every one of them is required to turn a headline number into a trade.

Hidden cost 1: the withdrawal fee. To capture the spread, you must move the coin from the cheap exchange to the expensive exchange. That transfer costs a static withdrawal fee (denominated in the coin itself), which you convert to dollars at the buy price. For USDT-TRC20 that fee is around $1. For USDT-ERC20 it is $5-15. For BTC on native chain it is $2-4. For long-tail altcoins on native chains it can be anywhere from $0.20 to $30. The scanner shows 2%. Your fee might already be 3% of the notional you plan to send.

Hidden cost 2: network availability. Even if the fee math clears, the transfer requires that withdraw_enabled=true on the source exchange for that coin+network AND deposit_enabled=true on the destination for the same network. If either flag is off, no common network exists, and the trade is structurally impossible. Free scanners never surface this — they cannot, because they do not collect the per-network availability data.

Hidden cost 3: slippage. The scanner reads the top of book. Your $2,000 order eats through five price levels down. On a thin book (typical for the low-cap altcoins that generate the flashiest headline spreads), a 2.8% gross spread becomes a 0.9% realized spread after slippage.

Hidden cost 4: execution latency. From the moment you initiate the withdrawal to the moment the funds credit on the destination exchange, minutes pass — often 2 to 30, sometimes 60+ for native BTC. In that window, algo-bots and cross-exchange market-maker desks close the spread. You arrive to an empty edge.

The "2% is not 2%" observation is the single most important sentence in retail spot arbitrage. Free scanners are not lying. They are just publishing one of four numbers you need. About two in three headline spreads never survive contact with the other three.

Everything else in this article is a systematic decomposition of that four-cost problem, plus proof that Yieldo's public tools already fix the first two — and give you the arithmetic you need for the other two.

The Honest Filter — Three Layers That Kill Roughly Two Thirds of Spreads

Yieldo's RouteOptimizerService and ArbitrageRouteService together apply a three-layer honest filter to every arbitrage row before it is published. Here is what those layers do, in the order they execute.

Layer 1: network status gate. For every candidate spread, the system asks: is there at least one network on which withdraw_enabled=true on the source AND deposit_enabled=true on the destination? If no common available network exists, the spread is marked route_available=false and no dollar math is attempted. On the June 25, 2026 snapshot, this layer alone killed roughly two-thirds of theoretically-visible cross-exchange spreads. The math: (1 - 0.289) x (1 - 0.562) = 0.711 x 0.438 ≈ 0.311. Only about 31% of random routes clear this gate.

Layer 2: withdrawal fee subtraction. For every route that clears Layer 1, the system selects the cheapest available network (sorted by total_cost within the intersection of open networks) and subtracts the withdrawal fee in USDT terms from the gross profit. The formula is net = max(0, gross - withdrawal_fee_usdt). This layer eliminates most small-position spreads (~$500) and virtually all spreads below 0.3% on any rail more expensive than TRC-20 or Plasma.

Layer 3: slippage and latency haircut. This is the layer the scanner cannot enforce on your behalf — it depends on your execution size and rail choice. The Yieldo SpotPriceAggregatorService pre-computes min_liquidity_usdt for each row, and the practitioner rule is: never take a position larger than 5% of the sell-leg's 24-hour volume for the pair. If you break the rule, expect 0.3-1% of realized spread to evaporate into slippage. Latency is bounded by rail choice (see Killer #3 below).

Compound survival rate across the three layers, in the average snapshot conditions: about 10-40% of scanner-visible spreads clear all three at the same time. The hero rounding — ~1 in 3 — sits in the middle of that band and is what we use throughout this study.

Only one exists in a free, public, machine-readable form: Yieldo's /arbitrage/live.json endpoint carries the net_spread_pct and route fields that encode Layers 1 and 2. Read on for the exact killer mechanics.

Killer #1 — Withdrawal Fee Eats the Margin (The Small-Amount Trap)

The first killer is the one every beginner meets on trade one. You see a 0.20% spread on ETH between MEXC and Bybit. You have $500 to trade. Gross expected profit: $1. Withdrawal fee on ETH-ARBITRUM: about $0.77. So far, so profitable — until you add 0.2% trading commissions across two legs ($1.00), at which point your $1 gross becomes a $0.77 loss. Do that ten times and you are down $7.70 for a week of screen time.

The break-even math. Yieldo's calculateNetProfit formula reduces to net = max(0, gross - withdrawal_fee_usdt). For a $500 position at 0.4% gross, gross = $2. If the cheapest available rail costs $1 (USDT-TRC20 typical), net before trading commissions is $1. If the cheapest available rail costs $8 (ETH-ERC20 typical), net is zero — the formula returns floored max. Trading commissions (~0.2% across two legs on most CEX) are subtracted separately by the reader. The safety rule of thumb, distilled from thousands of practitioner trades: spread% x amount must be at least three times the withdrawal fee in dollar terms.

Rail comparison. Not all networks are equal. Approximate USDT withdrawal fee ranges across the seven CEX in our coverage:

• Plasma on Bybit — zero fee. This is the structural rebalancing edge that makes Bybit the default primary leg for most cross-exchange practitioners.
• TRC-20 — typically $1 flat on most CEX; sometimes free on MEXC tier-1 accounts (varies by month). This is the durable second place.
• BEP-20 — typically $0.30-$1.
• ARBITRUM — variable, roughly $0.20-$2 depending on gas.
• ERC-20 — $5-15 depending on gas. Destroys nearly all small-and-mid arbitrage math. Use only for institutional-size flows.

For coins other than USDT, the same principle applies: native chain settlement (BTC, SOL, TON) is cheaper than wrapped bridges (Wrapped BTC on ETH, SPL on Solana bridging to ETH). Always check the exact withdrawal_fee for the exact network you plan to send.

Break-even amount by coin type (indicative ranges, not live numbers). For USDT on TRC-20 rail, the practical floor sits around $1,500 to keep the "3x fee" rule intact on typical 0.2% spreads. For BTC on native chain (~$2-4 fee), the floor climbs to roughly $4,000-$5,000. For low-cap altcoins on BEP-20 (~$0.20 fee), the floor can drop below $500 if the spread is meaningfully above 1%. Below $500 total capital, spot arbitrage arithmetic almost never clears on more than a handful of exotic rails.

When fees dominate. The compact rule: gross must be at least 3x the fee. Rearranged, that means the required position size (in dollars) is 3 x fee / spread_fraction. For a $1 fee at 0.4% spread, that is $750. For a $8 fee at 0.5% spread, that is $4,800. Every arbitrageur should keep this rule memorized before opening a scanner.

Below is Yieldo's live cheapest-fee table across the popular coins. Look for the FREE highlight — those cells are the only routes on which small-amount arbitrage math can survive.

The takeaway from the widget: for most coins on most exchanges, TRC-20 or a native chain equivalent is the cheapest available network. Where a FREE cell shows up (typically MEXC USDT-TRC20 on tier-1 accounts, or Plasma on Bybit), your rebalancing rail cost is effectively zero and the break-even math collapses to just the trading commissions.

Hero thesis again, because the fee killer alone is not the whole story: only about 1 in 3 arbitrage spreads survive after all three layers. Fee is Killer #1 by narrative order; the next section shows why network freeze is Killer #2 by frequency and volume.

For the deeper explainer on how withdrawal fees are structured and why they vary across networks, read the companion piece at https://yieldo.me/blog/fees/crypto-network-fees-explained. For a broader survey of all CEX fee schedules and the durable comparisons, start at https://yieldo.me/fees.

Killer #2 — Network Freeze (28.9% Withdraw / 56.2% Deposit Closed on Snapshot)

If Killer #1 is the arithmetic wall, Killer #2 is the physical wall. Even if your fee math clears, the transfer cannot happen if either the source or the destination has the network in a disabled state at that moment.

What "network disabled" actually means for arbitrage. Every CEX carries a withdraw_enabled and deposit_enabled flag per (coin, network) pair. The flag can flip at any moment for a range of reasons: scheduled maintenance, wallet compromise investigation, regulatory freeze, on-chain congestion, or the exchange simply pulling support for a legacy network (OKX has 34 permanently disabled OKTC legacy routes, for example). When the flag is off, the exchange's UI will show the coin's balance but will refuse the withdrawal or deposit request.

The scale of the problem. On the June 25, 2026 snapshot of 23,118 tracked routes across the seven CEX we cover, 6,681 (28.9%) of withdraw routes and 12,990 (56.2%) of deposit routes were disabled at that instant. Approximately 40-45% of routes were fully operational (both flags on). The 56.2% deposit-side number is the one nobody talks about — most arbitrageurs check the source exchange and assume the destination is fine. It is not fine. Deposits are frozen roughly twice as often as withdrawals because the deposit pipeline has more moving parts (chain indexer, memo parser, hot-wallet credit, balance update) than the outbound pipeline (build, sign, broadcast).

Why exchanges freeze. The typical trigger list, in rough order of frequency:

1. Scheduled hot-wallet maintenance — brief, hours-scale, announced with a few hours notice.
2. Chain congestion or fee-market spike — hours to days on ERC-20 during peak DeFi events.
3. Suspected wallet compromise — the 2025 Bybit hack aftermath froze ETH-related withdrawals for ~48 hours; spot ETH spreads Bybit vs Binance briefly opened 0.8-2%, all non-executable.
4. Regulatory freeze — occasionally a single coin or network gets frozen jurisdictionally.
5. Network upgrade — the September 2022 Ethereum Merge shut ETH deposits/withdrawals across every major CEX for 12-72 hours.
6. Chain halt — Solana averaged approximately 4 network halts per year over 2022-2024, each about 60-90 minutes, each auto-freezing every SPL token on every CEX.
7. Deprecation of legacy rails — quiet permanent disables that never come back (OKX OKTC being the largest example).

Freeze-rate leaderboard, qualitative. Our snapshot rankings (winners are the exchanges with the lowest freeze rate; higher is worse):

• Tier 1 (reliability winners): Bybit, OKX. Consistently low freeze rates, quick recovery from maintenance windows, transparent status pages.
• Tier 2 (reliable but case-dependent): Bitget, KuCoin. Solid infrastructure, occasionally longer freeze durations.
• Long-tail catalog (higher freeze rate but wider coverage): MEXC, Gate.io. The freeze rate is inflated by breadth — the more networks you support, the more that will be down at any moment. Per-route reliability on their major-coin routes is close to dataset average.
• Reference-only: Binance (included as a benchmark price source, referral not offered).
• Excluded: BingX (deprecated from Yieldo coverage), Aster (perp-DEX, ASTER_ENABLED=false).

The 56.2% deposit-side number, elaborated. Practitioners tend to check "can I withdraw USDT-TRC20 from MEXC" and assume the answer covers the whole route. But the destination — Bybit in that example — has its own deposit_enabled flag for USDT-TRC20 that flips independently. If Bybit is doing hot-wallet maintenance on TRC-20 while MEXC is fine, your withdrawal will broadcast successfully and then bounce or get stranded on the destination side. The 56.2% number tells you that at any random moment, more than half the deposit routes on the average exchange are simply not accepting funds.

Using the live Freeze Tracker before you send. Below is the live network-status widget. The suspended count and the top-8 currently-suspended networks come straight from Yieldo's live snapshot. Cross-reference this before every trade; do not rely on the fee cell alone.

For the full explainer of the tracker (how the flags are collected, refresh cadence, how the 30-day event count is derived), see https://yieldo.me/fees/network-status. For the story of what to do when a network you need is disabled, see https://yieldo.me/blog/fees/withdrawal-network-disabled-what-to-do. The quarterly retrospective for July-September 2026 lives at https://yieldo.me/blog/fees/state-of-withdrawal-freezes-q3-2026, and the coin-level "you literally cannot withdraw this" tracker is at https://yieldo.me/blog/fees/coins-you-cant-withdraw-tracker.

Hero thesis, restated: ~1 in 3 spreads survive the honest filter. Freeze is doing most of that work — before you even look at fees or slippage, roughly two thirds of random routes are already blocked at the transfer layer.

Killer #3 — Slippage and Execution Latency (The Silent Killers)

If Killers #1 and #2 are the walls you can measure in advance, Killers #3 and #4 (combined here because they interact) are the ones that eat you during execution. They are the reason a spread that looked "healthy" at click-time delivers half the promised return on landing.

Thin order books on the winner exchange. The scanner reads top-of-book — the single best bid or ask. Your $2,000 order does not clear at top-of-book if only $432 of depth exists there. It walks the book, filling at progressively worse prices. On low-cap altcoins where the flashiest spreads live (often 2-5% headline), the sell-side depth for the notional you actually want to send can be a fraction of the promise. A 2.86% headline can realize as 0.95% after slippage. That is the classic "thin-book spread trap" — the spread is real but not tradable at your size.

Order-book depth rule of thumb. Never take a position larger than roughly 5% of the sell-leg's 24-hour volume for the pair. This is a practitioner heuristic, not a Yieldo formula. If a pair does $50,000 in daily volume, your maximum sensible cross-exchange position is $2,500. Break the rule and your realized spread will underperform the headline by a factor of two to five.

The 2-30 minute transfer window. From the moment you initiate the withdrawal to the moment the sell exchange credits your balance, minutes pass. Ballpark ranges by rail:

• BEP-20 — 1-2 minutes
• TRC-20 — 2-3 minutes
• Solana / TON — 1-2 minutes each
• ARBITRUM — 5-15 minutes
• ERC-20 — 5-20 minutes depending on gas
• BTC native chain — 30-60 minutes for 3-6 confirmations

Add exchange credit delay (often another 5-20 minutes) on top. If the spread's observed half-life is shorter than your transfer time, algo-bots will close it before you land. This is why practitioners keep pre-funded balances on both exchanges: you sell on Bybit and buy on MEXC simultaneously against pre-funded balances, then rebalance the balances back later on the cheapest available rail. The transfer never happens in the critical execution window — it happens hours later, unpressured.

HFT and market-maker bots eat the top of the stack first. Retail without co-located infrastructure competes for fills against professional desks running <100ms round-trip strategies. On BTC/ETH pairs across top-3 CEX, spreads above 0.15% redetect within 30 seconds and close within 1-3 minutes. If you clicked the button, you already lost the race. This is why spot arbitrage on liquid majors is essentially dead for retail — the Wintermute / Jump / GSR desks captured that edge by mid-2022, and it has not returned.

Realistic slippage haircut by coin cap:

• Large cap (BTC, ETH, SOL, XRP, BNB, USDT, USDC): 0-0.1% at $10k position on top-tier CEX. Effectively zero if you stay within depth.
• Mid cap (top 20-100 by market cap): 0.1-0.5% at $5k position on secondary CEX.
• Low cap (below top 200): 0.5-3% at $500-$2,000 position. This is where the "thin-book spread trap" lives. The scanner shows 4%, your realized number is 1.2%.

For depth work on major pairs, OKX and Bybit absorb $10k orders without visible slippage on BTC/ETH. For mid-caps, cross-check depth against 24h volume before committing. For low-caps, either accept the slippage as a cost of doing business or stay away.

Hero thesis, restated once more: ~1 in 3 spreads survive the honest filter. Slippage plus latency is not the largest killer by count, but it is the largest single source of disappointment — the trades that look survived on the click but deliver a fraction of the promise on close.

Live Audit Methodology — 23,118 Routes Under the Honest Filter

This is the section for readers who want to trust the numbers before they act on them. Everything in this study is reproducible from public endpoints. Nothing here is proprietary or unverifiable.

Data source. Two tables underpin the audit. The first is spot_prices — a per-minute snapshot of best bid/ask across the seven CEX for every tracked coin, fetched by SpotPriceAggregatorService::fetchAll() on a one-minute schedule. The second is withdrawal_fees — a per-30-minute snapshot of withdrawal_fee, withdraw_enabled, deposit_enabled, and network metadata per (coin, network, exchange). Combined, these two tables produce the universe of 23,118 tracked routes on the June 25, 2026 snapshot.

Filter logic (pseudocode). Yieldo's ArbitrageRouteService::isSpreadRouteAvailable($opportunity) implements the following logic, restated in plain English:

1. If both exchanges in the spread are DEX (Jupiter, STON.fi), the route is always available — no CEX withdrawal is involved.
2. If the buy exchange is DEX and the sell exchange is CEX, check deposit_enabled on the CEX for the coin+network you would deposit.
3. If the buy exchange is CEX and the sell exchange is DEX, check withdraw_enabled on the CEX for the coin+network you would withdraw.
4. If both exchanges are CEX, delegate to RouteOptimizerService::isRouteAvailable($coin, $buy_slug, $sell_slug). This function queries WithdrawalFee for withdraw-enabled networks on the source and deposit-enabled networks on the destination, computes the intersection, and returns true if any common available network exists.

Net-profit formula (pseudocode).

gross = spread_percent x amount / 100
if buy_exchange is DEX:
    return gross                              (swap fee already priced in)
if sell_exchange is DEX:
    fee_usdt = route_info.fee_usdt            (CEX withdrawal + DEX gas)
    return max(0, gross - fee_usdt)
# both CEX:
route = getTopCheapest(coin, buy_slug, sell_slug, 1).first()
if route is null:
    return gross                              (filtered earlier by availability)
withdrawal_fee_amount = route.withdrawal_fee  (in coin units)
withdrawal_fee_usdt = withdrawal_fee_amount x spread.buy_price
return max(0, gross - withdrawal_fee_usdt)

What the formula does not subtract. Full disclosure — the formula is honest but not exhaustive. It does not subtract:

• Trading commissions. Approximately 0.1% x 2 legs = 0.2% on most CEX. The arbitrage-calculator widget on this page lets you enter a fee value manually as a proxy.
• Slippage. Depth is precomputed in min_liquidity_usdt on each row but not subtracted from net_spread_pct. Reader applies the 5%-of-24h-volume rule.
• Execution latency. Transfer times are known but not subtracted. Reader applies the "spread half-life must exceed transfer time" check.
• Capital lockup. Cross-exchange rebalancing ties up capital on both sides. Effective APR is halved versus concentrated deployment.

These four omissions are disclosed rather than hidden. Every honest research study should say what its formula does not do.

Snapshot date and refresh cadence. Live spot prices refresh every 60 seconds. Withdrawal fees and network status refresh every 30 minutes. Route-availability calculations cache for 300 seconds under the arbitrage:web: cache prefix. The reference snapshot for this study is 25 June 2026. Numbers presented as "current" in prose are ranges (~28-30%, ~55-60%); exact points (28.9%, 56.2%, 23,118) appear only in TL;DR, methodology, and FAQ.

How to reproduce this audit yourself. Full reproducibility playbook lives in the Reproducibility Statement section later in this article. In short: curl -s https://yieldo.me/arbitrage/live.json | jq, filter rows where spread > 0.3%, count rows where net_spread_pct > 0.1%, divide. Cross-check any survivor's route field against /fees/network-status.json for real-time route status.

Hero thesis, restated: ~1 in 3 arbitrage spreads survive the honest filter. Methodology is public. Audit is reproducible. No black box.

The Results — What Actually Survived the Filter

Here are the results, in the format a research reader expects: headline, breakdowns, and directional trends.

Headline. On the June 25, 2026 snapshot, applying all three honest-filter layers to the 23,118 tracked routes, roughly 10-40% of scanner-visible spreads survived. The hero rounding — ~1 in 3 — sits in the middle of that band. Snapshot-to-snapshot variance is real: in calm markets the number can drop to 5-15%; during funding-squeeze windows or freshly listed coins the number can climb above 50%.

Survival rate by exchange pair (qualitative). Not every pair of exchanges behaves the same. Rough directional pattern from our data:

• Bybit ↔ OKX — one of the highest survivor pairs (both Tier 1 reliability, deep books). Fewer spreads by count but higher survivor share.
• Bybit ↔ MEXC — the classic long-tail arbitrage pair. Many candidate spreads driven by MEXC's alt coverage, moderate survivor share driven by Bybit's reliability on the sell side.
• MEXC ↔ Gate.io — highest candidate count (both long-tail catalogs), lowest survivor share (double long-tail freeze exposure).
• OKX ↔ Bitget — solid survivor share, thinner candidate universe.

Survival rate by coin category:

• Majors (BTC, ETH, SOL, USDT, USDC, BNB, XRP): low candidate count (professional desks close spreads fast), moderate survivor share when candidates appear. Break-even threshold is high because HFT closes fast.
• Mid-caps (top 20-100): medium candidate count, moderate survivor share. The "sweet spot" for retail spot arbitrage.
• Low-caps (below top 200): high candidate count (thin books generate flashy headline numbers), low survivor share (slippage eats most of it).

Net APR after the honest filter, annualized. Practitioners running disciplined spot arbitrage with capital pre-positioned on multiple exchanges see net APRs in the 5-15% range across calm-to-normal markets, with spikes to 20-40% during dislocation events (funding squeezes, USDC-style depegs, network-halt-induced isolations). This range is consistent with the broader "is crypto arbitrage profitable" analysis at https://yieldo.me/blog/arbitrage/is-crypto-arbitrage-profitable-2026.

How the number moves quarter-over-quarter. The 28.9% / 56.2% split is a Q2 2026 snapshot. Structural drift over 2024-2026: withdraw-off rate has trended down (exchanges getting better at hot-wallet uptime); deposit-off rate has stayed sticky around 50-60% (deposit pipelines remain the harder engineering problem). The full quarterly retrospective for Q3 2026 will land in October — see https://yieldo.me/blog/fees/state-of-withdrawal-freezes-q3-2026.

Below the fold: interactive calculator. Try your own amount, your own fee assumption, and watch the survivor set collapse or expand.

The calculator is the only free public tool that shows net-of-fee spread math before you click. Neither Coinglass nor ArbitrageScanner.io nor Coinalyze offer this column. It is the interactive form of the entire honest-filter thesis.

Case Studies — Five Spreads Under the Microscope

Concrete beats abstract. Here are five worked examples that illustrate how each killer plays out at the trade level. All numbers are illustrative and reference-only, not attached to a specific live snapshot.

Case 1 — The Survivor (USDT on Bybit ↔ OKX)

• Coin: USDT
• Buy: OKX at $0.9985
• Sell: Bybit at $1.0025
• Gross spread: 0.40% on $10,000 = $40 gross
• Route: USDT-TRC20, fee $1 flat, withdraw_enabled=true, deposit_enabled=true
• Net after withdrawal fee: $40 - ($1 x $0.9985) ≈ $39.00 net
• Trading commissions: 0.1% x 2 legs x $10,000 = $20
• Realized net: ≈ $19 net after commissions
• Verdict: Survives. This is a realistic Bybit-side execution pattern; the low freeze rate on Bybit USDT-TRC20 and the Plasma zero-fee alternative make this the go-to rebalancing profile.

Case 2 — Killed by Withdrawal Fee (small-amount ETH)

• Coin: ETH
• Buy: MEXC at $3,850.20
• Sell: Bybit at $3,858.00 (0.20% spread)
• Gross: 0.20% on $500 = $1.00 gross
• Route: ETH-ARBITRUM available, fee 0.0002 ETH ≈ $0.77
• Net after withdrawal fee: $1.00 - $0.77 = $0.23
• Trading commissions: 0.2% x $500 = $1.00
• Realized net: -$0.77 loss
• Verdict: Dies. This is why the $5,000-plus capital floor exists for spot arbitrage on non-free rails. On <$500 positions, the trading commissions alone typically dominate the fee-net residual.

Case 3 — Killed by Network Freeze (SOL on Gate.io ↔ OKX)

• Coin: SOL
• Buy: Gate.io at $220.10
• Sell: OKX at $222.50 (1.09% spread — attractive)
• Gross: 1.09% on $5,000 = $54.50 gross
• Route check: Gate.io SOL-SOLANA withdraw_enabled=false (temporary maintenance, freeze event logged two hours prior). No other common available network exists.
• isRouteAvailable returns false. The spread is not executable at any size.
• Yieldo behavior: row visible in scanner but flagged route_available=false — reader sees "Route Unavailable" and does not send.
• Coinglass behavior: shows 1.09% as tradable; user discovers the dead route only when the withdrawal modal refuses to broadcast.
• Verdict: Dies. This is the largest structural killer in the dataset. It is why Killer #2 tops the impact ranking.

Case 4 — Killed by Slippage on Thin Book (long-tail alt on MEXC ↔ KuCoin)

• Coin: long-tail alt (illustrative — think a mid-tier meme coin)
• Buy: MEXC at $0.000420
• Sell: KuCoin at $0.000432 (2.86% headline spread)
• Gross theoretical: 2.86% on $2,000 = $57.20 gross
• Route: BEP-20 available, fee ≈ $0.20 (negligible)
• Net after withdrawal fee (theoretical): ≈ $57 net
• Order book reality: KuCoin sell-side depth at $0.000432 = only ~1M tokens ≈ $432 total. Your $2,000 order walks the book, averaging $0.000424 across four price levels.
• Realized spread: 0.95% x $2,000 = $19 gross
• Realized net after commissions: ≈ $11 net
• Verdict: Survives numerically but delivers one third of the promise. This is the slippage trap. The scanner is not lying — the top-of-book spread is real. The tradable size is not.

Case 5 — Killed by Latency (BTC on MEXC ↔ Bybit during a spike)

• Coin: BTC
• Buy: MEXC
• Sell: Bybit
• Headline spread: 0.60% on $10,000 = $60 gross
• Route: BTC native chain, fee ≈ $2-4, withdraw_enabled=true, deposit_enabled=true. Both flags green.
• Fee math: $60 gross - $4 fee = $56 net theoretical. Looks great.
• Execution reality: BTC native chain requires 3-6 confirmations. Elapsed time between broadcast and Bybit credit: ~30-60 minutes. Within that window, the spread compresses to 0.05% as HFT desks arbitrage the price gap using pre-funded balances.
• Realized spread on sell: approximately 0.05% x $10,000 = $5, minus $4 fee, minus $20 in commissions = -$19 loss.
• Verdict: Dies. This is why native BTC transfer is a poor arbitrage rail — the transfer window is longer than the spread half-life. Pre-funded balances on both exchanges is the only way to capture BTC spreads at retail speed.

Five cases, five outcomes. Two survivors (with meaningful profit only above $2,000 positions), three dead trades. This is what the "~1 in 3" number means at the trade level — not that one third of any random set will make money, but that after the honest filter, one third clear the "positive expected value" bar.

Exchange Reliability Ranking (Freeze-Rate Leaderboard)

Practical rankings for the practitioner, based on the June 2026 snapshot.

Tier 1 — Reliability winners:

• Bybit — the primary recommendation for cross-exchange arbitrage. Lowest freeze rate in the dataset, deep books on BTC/ETH pairs, and — crucially — the Plasma network provides zero-fee USDT transfers, which turns rebalancing into a free operation. If you can only maintain one primary account for arbitrage, this is it.
• OKX — second on reliability, deepest books after Bybit for majors, disciplined withdrawal uptime. Has 34 permanently disabled OKTC legacy routes which inflates their withdraw-off rate slightly, but per-active-route reliability is close to Bybit's.

Tier 2 — Reliable but case-dependent:

• Bitget — solid infrastructure, occasionally longer freeze durations. Reasonable second leg to Bybit for cross-exchange practitioners. Often the winner exchange in funding-arbitrage fallback strategies.
• KuCoin — fills gaps for coins not on top-4 CEX. Reliability comparable to Bitget but with a slightly thinner deep-book profile.

Long-tail catalog (higher freeze rate, wider coverage):

• MEXC — the widest altcoin catalog among the seven CEX. Structurally higher freeze rate as a consequence of breadth (the more networks you support, the more that will be down at any moment). Also often offers free USDT-TRC20 withdrawal on tier-1 accounts, which is a decisive edge for small-amount rebalancing. Best used as the long-tail source leg, paired with Bybit or OKX on the reliable sell leg.
• Gate.io — the other long-tail catalog. Broad coverage, correspondingly higher headline freeze rate. Best used similarly to MEXC — source leg for coins not available on top-4.

Excluded from the ranking:

• Binance — included as a reference price source; we do not offer a referral link. If you already have a Binance account, use it for price benchmarking against Bybit and OKX.
• BingX — deprecated from Yieldo coverage (is_active=false in the current dataset).
• Aster — perp-DEX supported in Yieldo config but disabled by default (ASTER_ENABLED=false).
• Hyperliquid — perp-DEX, funding-arbitrage only, referral rebate available but confirm the join link resolves before signing up (some referral URLs on production have not always resolved to a valid code).

Practical starter combo. For a reader building a spot arbitrage stack today: Bybit + MEXC covers reliability and long-tail alt coverage in one pair, and the USDT rebalancing rail runs on either Plasma (zero fee) or TRC-20 (~$1 fee) depending on which side you initiate from. Add OKX as the third account when you want deep-book confirmation on majors. Full ranking discussion lives at https://yieldo.me/blog/arbitrage/best-exchanges-for-arbitrage; single-exchange MEXC playbook at https://yieldo.me/blog/arbitrage/mexc-arbitrage-guide.

Hero thesis, restated: ~1 in 3 arbitrage spreads survive — and the survivors are disproportionately concentrated on the reliability-winner exchanges. Play the Tier 1 accounts as your primary hubs, use the long-tail catalogs surgically.

When Arbitrage Spreads Are Actually Real (Windows That Survive)

Given the ~1-in-3 base rate, when are the spreads meaningfully more executable? Here are the five contexts where survival rates climb above 50%.

Fresh listing arbitrage (first 60 minutes). When an exchange lists a coin that is already trading on other venues, the price often takes 30-90 minutes to converge with the broader market. During that window, spreads of 3-10% are common, and if the network is open on both sides, they are executable. Requires you to be watching listing announcements in real time.

Low-cap altcoins on 1-2 exchanges (thin but sticky). For coins with only a handful of listings, the price can stay dislocated for hours or days because there is no efficient arbitrage flow. Spreads of 2-5% survive here, at small size (respect the 5%-of-24h-volume rule).

Funding rate spikes (perp vs spot dislocation). When perp funding goes vertical (annualized +50%+), spot arbitrageurs face temporary premium/discount on the perp leg that spills into cross-exchange spot spreads. This is the moment to switch strategies — see the funding scanner and companion guide at https://yieldo.me/blog/funding/funding-rate-arbitrage-scanner and https://yieldo.me/blog/funding/funding-rate-arbitrage-guide.

Geo-restricted temporary premium (Korea "kimchi premium"). Regional CEX (Upbit, Bithumb) can trade coins at 3-8% premium to global CEX for days at a time when local demand spikes. Executing requires local banking rails; not accessible to most retail outside the region.

Network freeze arbitrage (the freeze itself creates the spread). When one exchange freezes a network, the coin's price on that exchange diverges from the rest of the market as arbitrage flow gets cut. If you are already positioned on both sides, you can capture the spread on the other exchange. Requires pre-positioning; unavailable to reactive traders.

For the taxonomy of strategy types, see https://yieldo.me/blog/funding/crypto-arbitrage-types-compared.

How to Audit an Arbitrage Spread Before You Send (HowTo)

Seven steps. Memorize them. Every winning spot arbitrage trade passes all seven; every losing trade skipped at least one.

Step 1 — Verify network status on both sides. Open https://yieldo.me/fees/network-status and check withdraw_enabled on the source exchange AND deposit_enabled on the destination exchange for the specific coin+network pair. If either flag is off for every common network, the spread is structurally dead. Walk away.

Step 2 — Look up the exact withdrawal fee for the network you will use. The fee must match the exact network of the transfer (TRC-20 ≠ ERC-20 ≠ Plasma). Use the withdrawal_fee value from the exchange, not an estimate. Small differences flip a survivor into a dead spread.

Step 3 — Calculate net = spread% x amount minus withdrawal fee. If net is zero or negative, skip. Add a rough 0.2% trading commission haircut for realism. Use the arbitrage-calculator widget on this page for one-click math.

Step 4 — Check order book depth on the winner exchange. For the notional you plan to send, verify your order does not exceed 5% of the sell leg's 24-hour volume for the pair or eat through more than the top 5 order book levels. Above that, expect slippage of 0.3% or more that the scanner did not model.

Step 5 — Estimate transfer plus credit time and compare to spread half-life. If the transfer window exceeds the observed spread half-life, algo-bots will close it before you land. Prefer pre-funded balances on both exchanges to decouple execution speed from settlement speed.

Step 6 — Set a re-check alert and stop-loss threshold. Configure an alert to re-verify the spread after the withdrawal broadcasts. If the spread compresses below your break-even before the sell leg fires, cut and rebalance later rather than pushing through a losing execution.

Step 7 — Execute or skip — skipping is often the correct action. There is no penalty for passing. Roughly two in three visible spreads are un-executable after the honest filter. Skipping is the default. See the broader how-to methodology at https://yieldo.me/blog/arbitrage/how-to-arbitrage-crypto.

Alternative Rails When Spot Spreads Die

When spot survival drops toward zero (calm markets, no dislocations), rotate to other strategies. Here are the four cleanest alternatives.

Funding rate arbitrage (delta-neutral, no transfer risk). The single cleanest fallback. You sell a perp on one exchange and buy spot on another (or hold spot elsewhere), collecting the funding payment while holding zero directional exposure. No cross-exchange transfer is required for the arbitrage itself — the capital sits pre-positioned, and you rebalance offline as needed. This class of arbitrage has no withdrawal-fee killer at all, because you are not moving coins. Live cross-exchange funding spreads below:

Deep guide at https://yieldo.me/blog/funding/funding-rate-arbitrage-guide; scanner tool at https://yieldo.me/blog/funding/funding-rate-arbitrage-scanner; live index at https://yieldo.me/funding. For the profitability discussion (net APR ranges, historical spikes), see https://yieldo.me/blog/arbitrage/is-crypto-arbitrage-profitable-2026.

DEX legs (Jupiter, STON.fi) when CEX withdrawal is closed. If the CEX rail you want is frozen, sometimes the DEX equivalent is open. Jupiter on Solana can be the DEX leg for SPL-token arbitrage; STON.fi on TON plays the same role for TON-ecosystem tokens. Gas is cheap ($0.01 Solana, ~$0.30 TON), but liquidity is concentrated in native ecosystem tokens.

Cash-and-carry (spot long + perp short). Structurally similar to funding arbitrage — you buy spot and short an equivalent perp against it, collecting basis while staying delta-neutral. Works best on BTC/ETH during pronounced contango on futures curves.

Park idle capital in staking while spreads are dead. Rather than leaving capital idle waiting for the next dislocation, park it in flexible staking. See the cross-module hub at https://yieldo.me/staking. During calm markets when spot arbitrage APRs collapse toward 0-5%, flexible staking APRs of 3-7% on USDT/USDC can be a better use of capital.

Cross-strategy discipline. The mature spot arbitrage practitioner does not treat the strategy as a full-time occupation. It is one tool in a rotation that includes funding arbitrage, DEX legs, cash-and-carry, and simple yield deployment. When spot survival collapses, rotate. When it spikes (funding squeezes, USDC-style depegs, network isolations), rotate back.

Common Mistakes (Why Beginners Lose Money on "Free" Spreads)

Five patterns kill new arbitrageurs almost every time. Recognize them, avoid them.

Chasing the top of the scanner without a filter. The top row on any free scanner is almost never executable. It sits at the top because something is wrong — thin book, disabled network, or 3% withdrawal fee. Sort by net_spread_pct, not by spread.

Ignoring the deposit-side network status. The 56.2% blind spot. Practitioners tend to verify "can I withdraw from source" and forget to verify "can destination accept the deposit." Both flags must be true simultaneously.

Small-amount trap (below $500 destroys the math). Trading commissions alone (0.2%) plus withdrawal fees plus the 3x-fee break-even rule mean spot arbitrage is essentially inaccessible below $500 in total capital. Save until you have at least $1,500-$2,000 to deploy per trade before trying.

Thin-book blindness (5% spread on $50 daily volume). The flashiest headline spreads live on the thinnest books. A 5% spread on a pair that does $50 in daily volume is not a 5% opportunity — it is a $2.50 opportunity you cannot capture without moving the market by 4%.

Skipping the re-check before broadcast. Between the moment you decide to trade and the moment you click "Withdraw," the spread can vanish. Always re-check within 30-60 seconds of the click. See the broader mistakes catalog at https://yieldo.me/blog/arbitrage/crypto-arbitrage-guide and the how-to counterpart at https://yieldo.me/blog/arbitrage/how-to-arbitrage-crypto. For the profitability-vs-effort tradeoff, see https://yieldo.me/blog/arbitrage/is-crypto-arbitrage-profitable-2026.

Competitor Gap — Why Free Scanners Cannot Give You This

Yieldo is not the only scanner in the market. Here is what the incumbents show and what they cannot show.

• Coinglass — cross-exchange price snapshots, funding rates, liquidations. Does not carry per-network withdraw_enabled / deposit_enabled flags. Their focus is derivatives infrastructure, not spot logistics.
• ArbitrageScanner.io — cross-exchange spot spreads with sortable columns. Uses static withdrawal fees, no live route availability. Free tier limited.
• Coinalyze — funding rates, futures OI, exchange aggregates. No spot arbitrage tool.
• Free Telegram scanners — top spreads pushed every 30 seconds. No route check, no fee subtraction, no latency estimate. Members lose money on dead spreads.

The Yieldo differentiator. Three uniqueness claims, checkable in the public JSON exports:

1. isSpreadRouteAvailable() filter — only free tool exposing the route_available flag per row. Base: 30-minute live snapshot of withdraw_enabled / deposit_enabled from seven CEX APIs.
2. calculateNetProfit() field — only free tool with net_spread_pct column after subtraction of the cheapest active withdrawal fee.
3. Freeze Tracker (network_availability_events) — only public log of every route-state transition, cumulative since 2026-06-28. Enables cross-reference of "this spread is executable only during the last hour that the route has been open."

Compact framing. It is not that the other scanners are wrong. They just do not have the two data columns that decide profit-or-loss for you: (1) is the network actually open, and (2) what is the real net after the cheapest active withdrawal fee. Without those two columns, every spread number is a promise, not a trade.

Reproducibility Statement — Verify Every Number Yourself

Trust in a research study is earned by making the numbers checkable. Every claim in this article can be reproduced from public Yieldo endpoints. All exports are CC BY-NC 4.0 with attribution to "Yieldo (yieldo.me)."

1. Live spreads with net-of-fee calculation. - Web UI: https://yieldo.me/arbitrage - JSON export: /arbitrage/live.json — returns {updated_at, position_usd, rows: [{k, coin, spread, net_spread_pct, withdrawal_fee_usdt, route, buy_price, sell_price, hot}]}. Refresh cadence: every 60 seconds (invalidated on SpotPriceAggregatorService::fetchAll()). - License: CC BY-NC 4.0.

2. Network status and freeze events. - Web UI: https://yieldo.me/fees/network-status — live tracker (30-minute refresh cadence). - JSON: /fees/network-status.json — current state per (coin, network, exchange). - CSV: /fees/network-status.csv — full event-history export from network_availability_events, accumulating since 2026-06-28. - License: CC BY-NC 4.0.

3. Methodology — how to reproduce the survival-rate audit yourself. 1. Fetch /arbitrage/live.json. Example: curl -s https://yieldo.me/arbitrage/live.json | jq. 2. Filter rows where spread > 0.3% (dust filter). 3. Count net_spread_pct > 0.1 divided by total count. That is your survival rate by net-of-fee. 4. Cross-verify each survivor's route field against /fees/network-status.json for real-time route status.

Expected result. 10-40% survival rate in normal regime, 5-15% in calm markets, up to 50%+ during funding-squeeze or freeze-induced dislocation windows.

4. About the RouteOptimizerService source code. The service logic is public (formula + pseudocode above). The full source is closed (SaaS). Verify indirectly by comparing: - net_spread_pct field in /arbitrage/live.json against the formula spread - (withdrawal_fee_usdt / position_usd x 100). - route field (e.g. "TRC20") against the cheapest available network in /fees/network-status.json for the same coin.

5. Snapshot ledger. Exact numbers (28.9% / 56.2% / 23,118 / ~28,500) reference the 25 June 2026 snapshot and the first nine days of the event log (2026-06-28 through 2026-07-07). Full quarterly retrospective planned for October 2026 (Q4 report). Data catalog at https://yieldo.me/about/data.

Below the fold: the same live scanner, one more time. Now that you have read the methodology, look at the rows with new eyes — about two in three of them will not survive. The third will.

The scanner is the same. Your reading of it is not. That is the whole point of this study.

Historical Context — Network Failures Are Not New

Freezes and network problems that block arbitrage are not exotic events. They are a weekly-to-monthly reality across major CEX and a several-times-per-year reality across individual chains. A representative catalog:

• October 2020 — BTC transaction stuck due to fee-market spike. Introduced replace-by-fee (RBF) support across major CEX. Historical example showing that latency-killer predates DeFi era.
• May 2021 — Ethereum pre-merge network stress. Multiple exchanges suspended ETH withdrawals for 6-24 hours during peak gas events. Cross-exchange spot spreads regularly stranded.
• September 2022 — Ethereum "The Merge." All CEX suspended ETH deposits/withdrawals for 12-72 hours pre and post merge. Spot arbitrage on ETH effectively frozen for approximately 15 September plus/minus 3 days.
• May 2022 — Terra/LUNA collapse. Nearly all CEX froze UST and LUNA deposit/withdraw within 48 hours of the depeg. Cross-exchange spot spreads on UST-USDT recorded 3-15%, none executable due to closed rails.
• March 2023 — USDC depeg (SVB crisis). USDC briefly to $0.87. Multiple exchanges paused USDC withdrawals; Circle burn/mint suspended over weekend. Headline spreads over 10%, almost none executable.
• August 2024 — Solana network halts. SOL experienced multiple 60-90 minute halts across 2022-2024. Each halt auto-froze SOL, USDC-SOL, and every SPL-token withdrawal across all CEX. Historical average: about 4 network halts per year, average 90 minutes each.
• March 2025 — Bybit hack aftermath. Bybit paused ETH-related withdrawals for approximately 48 hours. Spot ETH spreads Bybit vs Binance opened 0.8-2% during the window, all non-executable.
• May 2025 — "TRC20 congestion event." TRON network experienced 6-hour congestion; TRC20 USDT transfers took 2-4 hours instead of the usual 3 minutes. Fee market spiked from $1 to $8. Cross-exchange USDT rebalancing froze.

Authority signal. Network freezes are not exotic. They happen weekly on major CEX and multiple times per year on individual chains. If your arbitrage strategy does not have route-availability baked in, you will get stranded eventually.

Author Box and Legal Disclaimer

Written by Eugen Voyager — crypto analyst and founder of Telochain blockchain, GameFi project @telomeme, and the @tonsdot Telegram channel covering exchange operations, DeFi, and market dynamics. Practical experience operating blockchain infrastructure and tracking exchange behavior underpins the methodology used in this study.

Last updated: 24 July 2026

Risk warning. Crypto arbitrage is not risk-free. Exchange counterparty risk, network freeze risk, execution latency risk, and rapidly closing spreads mean that the "positive expected value" trades identified by any honest filter still require capital-at-risk. Never deploy capital you cannot afford to lose. Cross-exchange transfer failures — funds stuck on a bridge, memo-parsing errors on the destination, wallet compromise investigations — happen weekly at scale. The correct default action when uncertain is to skip the trade.

Disclaimer. This article contains affiliate links. Yieldo may earn a commission at no extra cost to you. The referral links used throughout weight toward the exchanges that ranked highest on our audit for reliability (Bybit) and long-tail coverage (MEXC); this is a factual outcome of the audit, not a paid endorsement. All numbers reference a 25 June 2026 snapshot unless otherwise stated; live values change every minute and can be verified via the Yieldo public JSON exports referenced in the Reproducibility Statement.

Hero thesis, one final time: ~1 in 3 arbitrage spreads survive real withdrawal fees plus network status. Sort by net_spread_pct, not by spread. Skip the two in three that will not clear. Play Tier 1 exchanges for reliability. Use the free tools. Verify every number.

That is the whole audit.