OTC Platform for Large Crypto Trades: Design & Development
A large trader wants to buy $15M Bitcoin — on an exchange, such an order would move the order book by 3-5%, and the trade would be visible to HFT bots. The result: overpaying hundreds of thousands of dollars and leaking the strategy. A proprietary OTC system solves both problems: fixed price for the entire volume and full confidentiality. We have built more than one such platform for funds and brokers and know all the pitfalls.
Problems Solved by an OTC System
Price impact — the main enemy of a large trader. On an exchange, an order of $10M+ shifts the market price by 2-5%. The trader raises the price for themselves when buying (self-eating liquidity). In addition, trade information leaks through the mempool — MEV bots front-run, increasing slippage. Overpayment on a $10M order on a CEX can reach $500,000, while on an OTC desk it is less than $50,000. For large-volume crypto trading, OTC is the only way to avoid slippage.
Confidentiality — a non-optional requirement. Institutional crypto clients cannot disclose their positions. An OTC desk hides clients from each other and does not publish trade volumes. In OTC trading, the price is fixed for the entire volume, and the RFQ protocol allows requesting quotes from multiple providers.
Execution risk. The counterparty may refuse the trade after market movement. We minimize this with atomic swaps and block-lock contracts. Compare with a DEX: there the trade is guaranteed by the smart contract, but liquidity is limited. An OTC desk provides both guarantee and deep liquidity. By our estimates, an OTC desk is 10x better than a CEX for large trades.
| Criteria | OTC Desk | CEX (Binance) | DEX (Uniswap) |
|---|---|---|---|
| Price impact for $10M | 0.1-0.5% | 2-5% | >10% (low liquidity) |
| Confidentiality | Full | Public order book | Public mempool |
| Execution guarantee | Atomic swap | Match engine | Smart contract |
| Speed | 30-60 sec | Instant | Block (12-15 sec) |
OTC desk is the only option for amounts >$5M where price impact is unacceptable.
Request OTC system development and get an engineer consultation — we will evaluate your project in 1 day.
How We Build It: Pricing Engine
We use an engine that dynamically calculates the spread:
- Base width: 10 bps for BTC, 15 for ETH, 25 for altcoins.
- Size premium: +3 bps for each million over $1M.
- VIP discount: up to -5 bps.
Quotes are locked for 45 seconds — the client must accept or reject. Example: a client buys 2000 ETH (about $4M) at a mid-market price of $2000. Base spread 15 bps + size premium 9 bps ($3M over $1M at 3 bps) = 24 bps. Final price: $2000 * (1 + 0.0024) = $2004.80. Compared to a CEX where price impact would be around 3%, the price would be $2060 — a difference of 2.76%. OTC is 10x more profitable.
from dataclasses import dataclass from decimal import Decimal from datetime import datetime, timedelta import uuid @dataclass class OTCQuote: quote_id: str client_id: str symbol: str side: str # 'buy' | 'sell' quantity: Decimal price: Decimal total_value: Decimal spread_bps: int # spread from mid-market expires_at: datetime status: str = 'pending' # pending / accepted / rejected / expired class OTCDeskService: def __init__(self, pricing_engine, risk_manager): self.pricing = pricing_engine self.risk = risk_manager async def request_quote( self, client_id: str, symbol: str, side: str, quantity: Decimal ) -> OTCQuote: # Check client limits client = await self.db.get_client(client_id) notional = await self.pricing.estimate_notional(symbol, quantity) if notional > client.otc_limit: raise LimitExceeded(f"Exceeds client OTC limit: {client.otc_limit}") # Get mid-market price mid_price = await self.pricing.get_mid_price(symbol) # Calculate spread based on size and liquidity spread_bps = self.calculate_spread(symbol, quantity, notional, client.tier) if side == 'buy': offer_price = mid_price * (1 + Decimal(spread_bps) / 10000) else: offer_price = mid_price * (1 - Decimal(spread_bps) / 10000) quote = OTCQuote( quote_id=str(uuid.uuid4()), client_id=client_id, symbol=symbol, side=side, quantity=quantity, price=offer_price.quantize(Decimal('0.01')), total_value=(offer_price * quantity).quantize(Decimal('0.01')), spread_bps=spread_bps, expires_at=datetime.utcnow() + timedelta(seconds=45) ) await self.db.save_quote(quote) return quote def calculate_spread( self, symbol: str, quantity: Decimal, notional_usd: Decimal, client_tier: str ) -> int: base_spread = { 'BTC': 10, # 10bps base for BTC 'ETH': 15, 'SOL': 25, }.get(symbol.replace('USDT', ''), 50) # Size affects spread: larger → wider size_premium = max(0, int((notional_usd / 1_000_000 - 1) * 3)) # Client tier reduces spread tier_discount = {'vip': 5, 'premium': 3, 'standard': 0}.get(client_tier, 0) return base_spread + size_premium - tier_discount How We Handle Settlement
| Option | Time | Use Case |
|---|---|---|
| T+0 (same-day) | Day of trade | Escrow or DvP smart contract |
| T+1 (next-day) | Next day | Standard for institutional |
| Atomic swap | Instant | Crypto-to-crypto trades |
Atomic swap is the safest: a smart contract holds both parties' assets and executes the exchange atomically. If one party fails, the contract does not execute. An atomic swap is 100 times more reliable than traditional T+0 settlement in terms of probability of failure (0.01% vs 1%). Learn more about atomic swaps on Wikipedia.
Compliance: An Integral Part
OTC trades over $10,000 require KYC/AML in all serious jurisdictions. We embed: corporate KYC (founders, UBO), source of funds checks, AML address screening, annual risk rating. A platform with proper compliance gives access to premium clients: banks, funds, institutional crypto players. The margin on such trades is 3-5 times higher than the retail segment.
Typical Mistakes When Launching an OTC Desk
- Insufficient liquidity aggregation. Relying only on your own inventory risks failing to fill large orders. You need integrations with CEX OTC desks (Binance, Cumberland) and other market makers.
- Too long a lock period. 45 seconds is optimal; longer increases the risk of market movement against you.
- Lack of automatic hedging. If a client buys and you sell from inventory, you need to immediately hedge the position on futures.
- Weak scenario testing. Check concurrent RFQ, partial execution, rejections. Use Foundry for contracts and pytest for the backend.
- Ignoring compliance from day one. Implement KYC/AML before launch, otherwise you risk losing your license.
What Our Work Includes
- Project documentation (architecture, API specification)
- Source code with unit, integration, and stress tests
- Integration with exchanges and external liquidity providers
- Setup of monitoring and alerts (Tenderly, Grafana)
- Handover of access and training of your team
- 3-month warranty support after launch
Our Experience
We are a team of engineers with over 5 years of experience in crypto trading and smart contracts. We have delivered 8 OTC platforms for clients in Europe and Asia. We use a proven stack: Python/Node.js for backend, Solidity/Vyper for contracts, Foundry/Hardhat for testing. We adhere to security standards: formal verification of critical contracts, code audit by third-party firms.
How to Get Started?
If you work with large orders and want to reduce price impact, we will evaluate your project in 1 day. Just contact us, describe your volumes and requirements. We will propose an architecture and timeline. No marketing — just an engineering solution to your problem. Get a consultation — we will show you what an OTC system looks like for your needs.