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.