We develop high-frequency arbitrage bots that catch price discrepancies between exchanges in milliseconds. In the world of crypto arbitrage, risk-free is a myth: execution risk, latency risk, and inventory risk destroy profits if the architecture is not well-designed. Over 7 years, we have built more than 30 systems that consistently generate income using colocation for bots, WebSocket channels, and custom protocols. Let's examine the key strategies and technical solutions that separate a profitable bot from a losing one. Arbitrage as a strategy has been known for centuries, but in cryptocurrency arbitrage it requires modern technology.
Development cost for a simple exchange arbitrage bot starts at $15,000, while a full system with colocation ranges from $50,000 to $100,000.
Detailed cost breakdown
Our pricing includes strategy selection, implementation, backtesting, deployment, and 24/7 support. Contact us for a custom quote.The main problem is execution risk: between detecting an opportunity and executing it, the price moves. On Binance, latency via WebSocket is 10–50 ms. In that time, another bot can consume the spread. Without colocation and pre-placed balances, cross-exchange arbitrage is nearly impossible. You need a deposit of at least $10,000 on each exchange.
Why Developing an Arbitrage Bot is an Engineering Challenge
Execution risk is not the only problem. You also need to account for latency risk (network delays), inventory risk (risk of holding an illiquid asset), and the fee model. Every millisecond of delay reduces potential profit. A high-frequency trading bot requires minimal latency. Our solutions use colocation for bots in exchange data centers (AWS, Equinix), cutting latency to 1–5 ms. That is 10x faster than REST API. Profit from a single successful trade can reach $50–$200, but without a proper architecture, the bot will be unprofitable.
How an Arbitrage Bot Works
An arbitrage bot continuously monitors prices on multiple exchanges, calculates spreads, and executes trades when the threshold is exceeded. Key components: exchange connectors, detection logic, execution module, and hedging system. Without proper handling of partial fills, the bot will lose money—70% of errors come from edge cases during execution.
Simple Arbitrage (Cross-Exchange)
The same asset trades on two exchanges at different prices. BTC on Binance is $42,100, on OKX $42,150. Buy on Binance, sell on OKX, difference $50 is our profit. The main problem: by the time both legs are executed, prices may align. You need the lowest possible latency and pre-placed balances on both exchanges.
import asyncio
import aiohttp
from decimal import Decimal
class SimpleArbitrageBot:
def __init__(self):
self.binance = ccxt.binance({'apiKey': BINANCE_KEY, 'secret': BINANCE_SECRET})
self.okx = ccxt.okx({'apiKey': OKX_KEY, 'secret': OKX_SECRET})
self.min_profit_pct = Decimal('0.15')
async def check_opportunity(self, symbol: str) -> ArbitrageOpportunity | None:
binance_ticker, okx_ticker = await asyncio.gather(
self.binance.fetch_ticker(symbol),
self.okx.fetch_ticker(symbol),
)
binance_bid = Decimal(str(binance_ticker['bid']))
binance_ask = Decimal(str(binance_ticker['ask']))
okx_bid = Decimal(str(okx_ticker['bid']))
okx_ask = Decimal(str(okx_ticker['ask']))
if okx_bid > binance_ask:
spread = (okx_bid - binance_ask) / binance_ask * 100
net_spread = spread - BINANCE_TAKER_FEE - OKX_TAKER_FEE
if net_spread > self.min_profit_pct:
return ArbitrageOpportunity(
buy_exchange='binance', buy_price=binance_ask,
sell_exchange='okx', sell_price=okx_bid,
net_profit_pct=net_spread
)
if binance_bid > okx_ask:
spread = (binance_bid - okx_ask) / okx_ask * 100
net_spread = spread - OKX_TAKER_FEE - BINANCE_TAKER_FEE
if net_spread > self.min_profit_pct:
return ArbitrageOpportunity(
buy_exchange='okx', buy_price=okx_ask,
sell_exchange='binance', sell_price=binance_bid,
net_profit_pct=net_spread
)
return None
async def execute_arbitrage(self, opp: ArbitrageOpportunity, quantity: Decimal):
buy_task = self.place_order(opp.buy_exchange, 'buy', quantity, opp.buy_price)
sell_task = self.place_order(opp.sell_exchange, 'sell', quantity, opp.sell_price)
buy_result, sell_result = await asyncio.gather(buy_task, sell_task, return_exceptions=True)
if isinstance(buy_result, Exception) or isinstance(sell_result, Exception):
await self.handle_partial_execution(buy_result, sell_result, opp)
Triangular Arbitrage (Intra-Exchange)
On a single exchange: BTC → ETH → USDT → BTC. If the product of exchange rates > 1 + fees, there is an opportunity.
def find_triangular_opportunity(tickers: dict) -> TriangularPath | None:
currencies = ['BTC', 'ETH', 'BNB', 'XRP', 'SOL']
for a, b, c in permutations(currencies, 3):
pair_ab = f"{a}/{b}"
pair_bc = f"{b}/{c}"
pair_ca = f"{c}/{a}"
if not all(p in tickers for p in [pair_ab, pair_bc, pair_ca]):
continue
rate_ab = Decimal(str(tickers[pair_ab]['ask']))
rate_bc = Decimal(str(tickers[pair_bc]['ask']))
rate_ca = Decimal(str(tickers[pair_ca]['bid']))
result = (1 / rate_ab) * (1 / rate_bc) * rate_ca
after_fees = result * ((1 - TAKER_FEE) ** 3)
profit_pct = (after_fees - 1) * 100
if profit_pct > 0.05:
return TriangularPath(
a=a, b=b, c=c,
rates=(rate_ab, rate_bc, rate_ca),
profit_pct=profit_pct,
)
return None
Statistical Arbitrage (Pairs Trading)
A more sophisticated approach: look for statistically cointegrated pairs (BTC/ETH historically move together). When the spread diverges beyond a threshold, long the laggard, short the leader.
How to Minimize Execution Risk
Execution risk is the main enemy of an arbitrageur. Between detecting a spread and actual execution, the price can move. Solutions:
- Colocation: place your server in the same data center as the exchange (AWS Tokyo for Binance, AWS Frankfurt for OKX). This reduces latency to 1–5 ms, 10x faster than REST API.
- WebSocket instead of REST: subscribing to orderbook updates gives 1–2 ms updates vs 100–500 ms for REST.
- Pre-placed orders: limit orders placed close to the market in advance.
async def handle_partial_execution(self, buy_result, sell_result, opp):
"""Hedge when one leg is partially filled"""
if isinstance(sell_result, Exception) and not isinstance(buy_result, Exception):
filled_qty = buy_result['filled']
await self.emergency_sell(opp.sell_exchange, filled_qty)
elif isinstance(buy_result, Exception) and not isinstance(sell_result, Exception):
filled_qty = sell_result['filled']
await self.emergency_buy(opp.buy_exchange, filled_qty)
Comparison of connection methods:
| Method | Average Latency | Implementation Complexity | Reliability |
|---|---|---|---|
| REST API | 100-500 ms | Low | Low |
| WebSocket | 10-50 ms | Medium | Medium |
| WebSocket + colocation | 1-5 ms | High | High |
| Custom FPGA | <1 ms | Very High | Very High |
Comparison of arbitrage strategies:
| Strategy | Profitability | Risks | Implementation Complexity |
|---|---|---|---|
| Exchange | High (0.1-1% per trade) | Execution risk, latency | Medium |
| Triangular | Medium (0.05-0.5%) | Slippage | High |
| Statistical | Low (0.01-0.1%) | Model risk, regime change | Very High |
What's Included in Turnkey Arbitrage Bot Development
We provide a full cycle: architecture, implementation, testing, deployment, and monitoring. Each project includes:
- Market research and strategy selection (exchange, triangular, statistical)
- Development in Python or Node.js using WebSocket and colocation for bots
- Backtesting on historical data
- Deployment on VPS with monitoring (uptime, P&L, latency)
- Documentation and client team training
- 24/7 support after launch
Work Stages:
- Analytics: study available exchanges, liquidity, fees. Select the optimal strategy for your capital.
- Design: choose the tech stack (Foundry/Hardhat for smart contracts if DeFi arbitrage is needed). Architect with latency optimization in mind.
- Implementation: write code covering all edge cases (partial fills, WebSocket errors). Use asynchronous programming for maximum speed.
- Testing: simulate on exchange sandbox, then paper trade. Check resilience to flash crashes and high volatility.
- Deployment: launch with real funds, gradually increasing volumes. Set up alerts and dashboards.
Timelines:
- Simple exchange arbitrage bot: 4–6 weeks
- Triangular arbitrage: 3–4 weeks
- Statistical arbitrage: 6–10 weeks
- Full system with colocation and monitoring: 3–4 months
Common Mistakes When Launching an Arbitrage Bot
Even with correct architecture, mistakes happen. The most frequent:
- Insufficient capital on both exchanges: if one leg doesn't execute, the bot wastes time transferring funds.
- Ignoring fees: an apparent 0.2% profit can turn into a loss after subtracting taker fees (0.1% on Binance, 0.08% on OKX).
- Wrong threshold: too low leads to frequent trades with zero profit; too high leads to rare trades.
- Lack of monitoring: without alerts for WebSocket disconnection, the bot may run idle.
Our Advantages
We have completed 30+ projects in crypto trading. Average bot uptime — 99.9%, and average profitability exceeds the market by 15-20% thanks to latency optimization. We use certified AWS and Equinix infrastructure for colocation for bots. We guarantee code transparency and full support.
Contact us to assess your project and get a consultation on strategy selection. Order arbitrage bot development — start profiting from price discrepancies.