The Basic Idea
Arbitrage exploits price differences between markets. If Bitcoin is $50,000 on Exchange A and $50,200 on Exchange B, you buy on A and sell on B. That $200 difference is your profit—minus fees, slippage, and transfer times that often eat into it.
Crypto is particularly good for arbitrage because exchanges are fragmented, prices update at different speeds, and markets never close. The catch: opportunities usually last seconds, which is why most arbitrage is done by bots, not humans clicking buttons.
Real example: SOL is $150 on Exchange A and $160 on Exchange B. Buy 10 SOL on A, sell 10 SOL on B. You gross $100—but after trading fees, network fees, and slippage, your actual profit might be $30. Or negative.
Section 1
Arbitrage Strategies
1. Spatial (Cross-Exchange) Arbitrage
You maintain accounts and balances on multiple exchanges, buy the coin on the cheaper exchange and sell it on the more expensive one, ideally at nearly the same time.
2. Triangular (Intra-Exchange) Arbitrage
All trades happen on one exchange; you cycle through three pairs (for example BTC → ETH → USDT → BTC) to end up with more of the starting coin if the cross-rates are inconsistent.
3. Statistical Arbitrage ("Stat-Arb")
You use quantitative models and bots to trade baskets or pairs of coins whose prices normally move together, going long the underpriced asset and short the overpriced one until prices converge.
4. Practical Path for Retail Traders
A practical path for a retail trader is usually small-scale cross-exchange or simple triangular arbitrage with tight, pre-defined rules and automation.
Section 2
Basic Workflow Step-by-Step
Scan for Spreads
Use scanners or build a bot that monitors multiple exchanges or trading pairs and flags when the price difference exceeds your minimum profitable spread (for example, 0.7–1.0% above expected total costs).
Pre-fund Exchanges
Keep fiat or stablecoins plus some crypto inventory on each exchange to avoid blockchain transfer delays; move size only when spreads routinely justify it.
Execute Fast
When a signal triggers, place market or aggressive limit orders to buy low and sell high nearly simultaneously; focus on liquid pairs like BTC, ETH, and top-20 alts where spreads are small but frequent.
Reconcile
After each cycle, compute realized profit after trading fees, funding rates (if using derivatives), transfer costs, and slippage; refine filters so you only trade high-quality setups.
For those with scripting experience, this often means writing a Python or JS bot using exchange APIs (CCXT, native REST/WebSocket) plus a database or message queue for events.
Section 3
Profit Drivers and Key Risks
Edge comes from speed, low fees, and good tooling: faster APIs, co-located servers (if possible), low-latency logic, and fee discounts via VIP tiers or market-making programs.
Net profitability per trade is typically small (fractions of a percent), so you rely on high turnover and disciplined risk limits rather than big directional bets.
Main Risks You Must Manage:
Transfer and Execution Risk
Price can equalize while you're moving funds or waiting for orders to fill, turning an apparent profit into a loss.
Fees and Slippage
Trading, withdrawal, and network fees, plus order-book impact, can erase most small spreads; you generally ignore any spread smaller than your fully-loaded cost plus a buffer.
Exchange and Counterparty Risk
Smaller venues may show the juiciest spreads but also carry higher risk of downtime, bad APIs, or even insolvency.
Section 4
Regulatory and Tax
Arbitrage is still taxable trading; frequent, high-volume activity means complex reporting and potential compliance issues depending on jurisdiction.
Section 5
Starter Setup
Here's a practical, low-capital starter setup for a simple crypto-arbitrage bot using Python and exchange APIs.
1. Choose Scope, Capital, and Exchanges
Start with one or two major centralized exchanges (for example Binance + OKX or Binance + KuCoin) because they have deep liquidity and solid APIs.
For real money, many guides suggest starting in the 200–500 USD range so mistakes are affordable while fees are still measurable.
Limit yourself initially to a few liquid pairs such as BTC/USDT and ETH/USDT, where spreads are small but order books are thick enough for fast fills.
2. Tech Stack and Environment
Use Python 3.10+ and the CCXT library, which gives you a unified interface to 100+ exchanges and their public/private REST APIs.
Set up a dedicated project environment (for example, python -m venv venv), install ccxt (pip install ccxt), and add basic logging with the logging module writing to rotating log files. This keeps market data, errors, and trades auditable.
Plan for two data paths: REST polling for slower tasks (balances, periodic snapshots) and, if you want lower latency later, WebSocket connections for live order-book updates.
3. API Keys and Security
In each exchange account, create API keys with only the permissions you need (start with read + trade; no withdrawals) and enable 2FA on the account.
Store keys in environment variables or a secrets manager, never hard-coded in your scripts or checked into Git; rotate them periodically and revoke any that might be exposed.
Where supported, restrict keys by IP or VPC allowlists and monitor access logs or exchange dashboards for unusual usage spikes.
4. Strategy: Simple Cross-Exchange Arbitrage
Logic: continuously read the best bid/ask for your chosen pair on Exchange A and Exchange B; if price_B_sell - price_A_buy exceeds a target spread after fees, execute buy on A and sell on B.
Compute a minimum profitable spread per pair as min_spread = trading_fees_A + trading_fees_B + buffer where buffer (for example 0.2–0.3%) covers slippage and small price moves.
Keep quote currency (USDT/USD) primarily on the exchange where you'll buy and base currency (BTC/ETH) where you'll sell so you don't depend on slow on-chain transfers during the trade.
Example Pseudo-Flow (One Pair):
- Fetch order books on A and B.
- Calculate best executable size at top of book (for example up to 50–100 USD).
- If spread ≥ min_spread and size ≥ your minimum trade size, fire market or aggressive limit orders on both venues.
- Log trade, update balances, and cool-down briefly to respect rate limits.
5. Risk Controls and Logging
Implement global guards: max position per coin, max daily notional traded, and fail-safe shutdown if cumulative loss reaches a set threshold (for example 1–2% of capital).
Add checks for stale data, partial fills, and API errors (network timeouts, rate-limit hits); if any occur, cancel open orders and pause trading until conditions clear.
Before touching real funds, run the bot in "paper-trade" mode using live prices but simulated balances, or use exchange testnets/sandboxes to validate execution logic.