The collapse of FTX and other exchanges showed: assets on a trading platform are not your assets. Institutional investors now demand zero counterparty risk. Copper.co solves this with ClearLoop — an off-exchange settlement network where funds are stored in MPC wallets under full client control, and trading happens without transferring assets to the exchange. We have completed 15+ custody integration projects, including ClearLoop for funds with portfolios from $50M.
What Integration Delivers
Without ClearLoop: a trader transfers $10M to Binance—assets are on the exchange. Risk: hack or bankruptcy. With ClearLoop: assets stay in Copper custody; only a credit line is on the exchange. Settlement occurs within ClearLoop several times per day (intraday netting). Result: zero counterparty risk. ClearLoop is 6 times faster than blockchain settlement and saves up to 60% on withdrawal fees compared to standard transfers.
For products: the custody API provides programmatic access to institutional-grade wallets with MPC, a policy engine for multi-level approval, and an audit trail for compliance. All in a single integration. According to Copper reports, clients save up to 60% on fees.
How ClearLoop Works
ClearLoop is a network where each trade is recorded in an off-chain ledger, and final settlement happens internally without blockchain transactions. This means even at massive volumes (typical clients manage portfolios from $10M), gas costs are zero. Per Copper documentation, ClearLoop supports intraday netting with settlement frequencies up to 6 times daily, reducing operational risk.
Copper API: Key Endpoints
Copper provides a REST API plus WebSocket for real-time events. Authentication: API Key + HMAC-SHA256 request signing. Below is a full client example and calls—note error handling and signing.
import crypto from 'crypto';
import axios from 'axios';
class CopperClient {
private baseUrl = 'https://api.copper.co';
private signRequest(
method: string,
path: string,
timestamp: number,
body: string,
): string {
const message = `${timestamp}${method.toUpperCase()}${path}${body}`;
return crypto
.createHmac('sha256', process.env.COPPER_API_SECRET!)
.update(message)
.digest('hex');
}
async request<T>(method: string, path: string, data?: unknown): Promise<T> {
const timestamp = Date.now();
const body = data ? JSON.stringify(data) : '';
const signature = this.signRequest(method, path, timestamp, body);
const response = await axios({
method,
url: `${this.baseUrl}${path}`,
data: data || undefined,
headers: {
'Authorization': `ApiKey ${process.env.COPPER_API_KEY}`,
'X-Signature': signature,
'X-Timestamp': timestamp.toString(),
'Content-Type': 'application/json',
},
});
return response.data;
}
// Portfolio & wallets
async getPortfolios() {
return this.request('GET', '/platform/portfolios');
}
async getWallets(portfolioId: string) {
return this.request('GET', `/platform/portfolios/${portfolioId}/wallets`);
}
async createWallet(portfolioId: string, name: string, currency: string, type: 'hot' | 'cold') {
return this.request('POST', '/platform/wallets', {
portfolioId,
name,
mainCurrency: currency,
type,
});
}
// Transactions & approval
async createTransaction(portfolioId: string, currency: string, amount: string, toAddress: string, network: string, memo?: string) {
return this.request('POST', '/platform/transactions', {
type: 'withdrawal',
portfolioId,
currency,
amount,
toAddress,
network,
memo,
});
}
// ClearLoop
async transferToClearloop(fromPortfolioId: string, toExchangeAccountId: string, currency: string, amount: string) {
return this.request('POST', '/clearloop/transfers', {
fromPortfolioId,
toExchangeAccountId,
currency,
amount,
});
}
async getClearloopPositions(exchangeAccountId: string) {
return this.request('GET', `/clearloop/positions/${exchangeAccountId}`);
}
}
WebSocket: Real-Time Updates
import WebSocket from 'ws';
const ws = new WebSocket('wss://ws.copper.co/platform');
ws.on('open', () => {
ws.send(JSON.stringify({
type: 'auth',
apiKey: process.env.COPPER_API_KEY,
signature: generateWsSignature(),
timestamp: Date.now(),
}));
ws.send(JSON.stringify({
type: 'subscribe',
channels: ['transactions', 'portfolio_balances'],
portfolioIds: [portfolioId],
}));
});
ws.on('message', (data) => {
const event = JSON.parse(data.toString());
if (event.type === 'transaction_update') {
handleTransactionUpdate(event.payload);
}
if (event.type === 'balance_update') {
handleBalanceUpdate(event.payload);
}
});
Compliance and Reporting
Copper provides audit-ready data: all transactions with timestamps, approver logs, and blockchain confirmations. Exporting transaction history for any period is a single API call. Each record includes initiator, approvers, timestamps, txHash. For regulatory reporting, connect a SIEM system via WebSocket. For an accurate cost and timeline estimate, contact us—we'll audit your infrastructure and propose the optimal solution.
Integration Process: Typical Stages
| Stage | Duration | What Happens |
|---|---|---|
| KYB onboarding | 2–4 weeks | Document submission, company verification, API key issuance |
| Basic API integration | 2–3 weeks | SDK development, webhook handling, deposit/withdrawal implementation |
| ClearLoop integration | 2–4 weeks | Exchange account setup, off-exchange settlement configuration |
| Approval workflow | 1–2 weeks | Policy engine setup, multi-signature approval integration |
| Compliance reporting | 1–2 weeks | Transaction export, audit trail, SIEM connection |
| QA and testing | 1–2 weeks | Sandbox testing, load testing, security audit |
ClearLoop vs Standard Settlement
| Parameter | ClearLoop | Standard Settlement |
|---|---|---|
| Counterparty risk | Zero (assets in custody) | High (assets on exchange) |
| Settlement speed | Intraday netting (up to 6x/day) | Depends on blockchain |
| Transaction cost | Minimal (internal netting) | Gas + exchange fees |
| Audit transparency | Full audit trail | Limited |
| Exchange support | 10+ (Binance, Deribit, Kraken) | Single exchange |
Common Integration Mistakes
- Incorrect HMAC signing order. Timestamp and method must be in exact order. One second off—request rejected.
- Ignoring webhooks. Transaction status changes asynchronously—relying only on API response is insufficient. Handle WSS events.
- Skipping policy engine setup. Without proper limits and whitelists, transactions may stall in approval.
- Starting without KYB. API access is granted only after full verification—beginning integration without KYB is futile.
Case Study: ClearLoop for a Hedge Fund. One of our clients—a hedge fund with $50M monthly volume—faced high withdrawal fees (up to 0.5% on Ethereum). We integrated ClearLoop in 8 weeks, configuring off-exchange settlement with Binance and Deribit. Result: zero counterparty risk, $120K annual savings on fees due to intraday netting. The entire audit trail is automatically exported to their SIEM.
What's Included
- Integration documentation (architecture, data schemas, sequence diagrams)
- SDK/adapter source code (TypeScript or Python on request)
- Access to Copper test sandbox
- Webhook integration for transaction status updates
- Load testing of ClearLoop channels
- One month of post-deployment support
Contact us for a preliminary project assessment. We'll help plan the architecture, prepare documentation, and get through KYB with minimal delays. Get a consultation—our engineers will review your current architecture and provide an integration roadmap.