DataResearchTools

Category: Crypto & DeFi Proxies

  • Best Proxies for Binance, Bybit, and OKX API Trading

    Best Proxies for Binance, Bybit, and OKX API Trading

    API trading on major centralized exchanges is the foundation of algorithmic crypto trading. Binance, Bybit, and OKX each handle billions of dollars in daily volume, and their APIs power everything from simple trading bots to institutional-grade market-making systems. Each exchange has distinct API characteristics, rate limit structures, and IP management policies that affect how you should configure your proxy infrastructure.

    This guide provides exchange-specific proxy configurations, performance benchmarks, and practical setup examples for each of the three largest crypto exchanges.

    Exchange API Comparison

    Feature Binance Bybit OKX
    REST Rate Limit 1,200/min (weight-based) 120 req/5s per endpoint 20 req/2s per endpoint
    WebSocket Streams 1,024 per connection 200 per connection 100 per connection
    IP Whitelisting Required for withdrawals Optional Required for trading
    Max API Keys 30 per account 20 per account 20 per account
    Geographic Restrictions Yes (US, etc.) Yes (varies) Yes (varies)

    Binance API Proxy Setup

    Understanding Binance’s Weight System

    Binance uses a weight-based rate limiting system rather than simple request counting. Each endpoint costs a different weight:

    • GET /api/v3/ticker/price — 2 weight
    • GET /api/v3/depth (limit 100) — 10 weight
    • POST /api/v3/order — 1 weight
    • GET /api/v3/account — 20 weight

    The total weight limit is 1,200 per minute per IP address. This means a single IP can execute 1,200 order placements but only 60 account balance checks per minute.

    Proxy Configuration for Binance

    import aiohttp
import asyncio
import hmac
import hashlib
import time
from urllib.parse import urlencode
from typing import Dict, Optional

class BinanceProxyTrader:
    BASE_URL = "https://api.binance.com"
    FUTURES_URL = "https://fapi.binance.com"

    def __init__(self, api_key: str, api_secret: str, proxy: str):
        self.api_key = api_key
        self.api_secret = api_secret
        self.proxy = proxy
        self.weight_used = 0
        self.weight_reset_time = time.time() + 60

    def _sign(self, params: dict) -> str:
        query_string = urlencode(params)
        signature = hmac.new(
            self.api_secret.encode(),
            query_string.encode(),
            hashlib.sha256
        ).hexdigest()
        return signature

    def _get_headers(self) -> dict:
        return {"X-MBX-APIKEY": self.api_key}

    async def _check_weight(self, weight: int):
        """Enforce rate limits locally before sending request."""
        now = time.time()
        if now > self.weight_reset_time:
            self.weight_used = 0
            self.weight_reset_time = now + 60

        if self.weight_used + weight > 1100:  # 92% threshold
            wait_time = self.weight_reset_time - now
            if wait_time > 0:
                await asyncio.sleep(wait_time)
            self.weight_used = 0
            self.weight_reset_time = time.time() + 60

        self.weight_used += weight

    async def get_price(self, session, symbol: str) -> float:
        await self._check_weight(2)
        url = f"{self.BASE_URL}/api/v3/ticker/price"

        async with session.get(
            url,
            params={"symbol": symbol},
            headers=self._get_headers(),
            proxy=f"http://{self.proxy}",
            timeout=aiohttp.ClientTimeout(total=5)
        ) as resp:
            # Update weight from response headers
            self.weight_used = int(
                resp.headers.get("X-MBX-USED-WEIGHT-1M", 0)
            )
            data = await resp.json()
            return float(data["price"])

    async def place_order(self, session, symbol: str, side: str,
                           order_type: str, quantity: float,
                           price: float = None) -> dict:
        await self._check_weight(1)
        url = f"{self.BASE_URL}/api/v3/order"

        params = {
            "symbol": symbol,
            "side": side,
            "type": order_type,
            "quantity": str(quantity),
            "timestamp": int(time.time() * 1000),
            "recvWindow": 5000,
        }
        if price and order_type == "LIMIT":
            params["price"] = str(price)
            params["timeInForce"] = "GTC"

        params["signature"] = self._sign(params)

        async with session.post(
            url,
            data=params,
            headers=self._get_headers(),
            proxy=f"http://{self.proxy}",
            timeout=aiohttp.ClientTimeout(total=5)
        ) as resp:
            self.weight_used = int(
                resp.headers.get("X-MBX-USED-WEIGHT-1M", 0)
            )
            return await resp.json()

    async def get_account(self, session) -> dict:
        await self._check_weight(20)
        url = f"{self.BASE_URL}/api/v3/account"

        params = {
            "timestamp": int(time.time() * 1000),
            "recvWindow": 5000,
        }
        params["signature"] = self._sign(params)

        async with session.get(
            url,
            params=params,
            headers=self._get_headers(),
            proxy=f"http://{self.proxy}",
            timeout=aiohttp.ClientTimeout(total=5)
        ) as resp:
            return await resp.json()

    Binance IP Whitelisting with Proxies

    Binance requires IP whitelisting for API keys that can perform withdrawals. When using proxies, you need to whitelist your proxy’s IP address, not your server’s IP:

    1. Get your proxy’s exit IP: curl --proxy http://user:pass@proxy:port https://api.ipify.org
    2. In Binance API management, add this IP to the whitelist
    3. Use sticky proxies to maintain the same exit IP

    Important: Use mobile proxies with extended sticky sessions (24h+) for Binance API trading. If your proxy IP rotates, your API calls will be rejected by the whitelist.

    Bybit API Proxy Setup

    Bybit Rate Limit Structure

    Bybit uses per-endpoint rate limits measured in requests per 5-second window:

    • Market data endpoints: 120 requests per 5 seconds
    • Order endpoints: 10 requests per second
    • Account endpoints: 120 requests per 5 seconds
    class BybitProxyTrader:
    BASE_URL = "https://api.bybit.com"

    def __init__(self, api_key: str, api_secret: str, proxy: str):
        self.api_key = api_key
        self.api_secret = api_secret
        self.proxy = proxy

    def _sign(self, params: dict, timestamp: int) -> str:
        param_str = f"{timestamp}{self.api_key}5000"
        param_str += urlencode(sorted(params.items()))
        return hmac.new(
            self.api_secret.encode(),
            param_str.encode(),
            hashlib.sha256
        ).hexdigest()

    def _get_headers(self, params: dict = None) -> dict:
        timestamp = int(time.time() * 1000)
        sign = self._sign(params or {}, timestamp)
        return {
            "X-BAPI-API-KEY": self.api_key,
            "X-BAPI-SIGN": sign,
            "X-BAPI-TIMESTAMP": str(timestamp),
            "X-BAPI-RECV-WINDOW": "5000",
            "Content-Type": "application/json",
        }

    async def get_tickers(self, session, category: str = "spot",
                           symbol: str = None) -> dict:
        url = f"{self.BASE_URL}/v5/market/tickers"
        params = {"category": category}
        if symbol:
            params["symbol"] = symbol

        async with session.get(
            url,
            params=params,
            proxy=f"http://{self.proxy}",
            timeout=aiohttp.ClientTimeout(total=5)
        ) as resp:
            data = await resp.json()
            return data.get("result", {})

    async def place_order(self, session, symbol: str, side: str,
                           order_type: str, qty: str,
                           price: str = None) -> dict:
        url = f"{self.BASE_URL}/v5/order/create"

        payload = {
            "category": "spot",
            "symbol": symbol,
            "side": side.capitalize(),
            "orderType": order_type.capitalize(),
            "qty": qty,
        }
        if price:
            payload["price"] = price

        headers = self._get_headers(payload)

        async with session.post(
            url,
            json=payload,
            headers=headers,
            proxy=f"http://{self.proxy}",
            timeout=aiohttp.ClientTimeout(total=5)
        ) as resp:
            return await resp.json()

    async def get_wallet_balance(self, session,
                                  account_type: str = "UNIFIED") -> dict:
        url = f"{self.BASE_URL}/v5/account/wallet-balance"
        params = {"accountType": account_type}
        headers = self._get_headers(params)

        async with session.get(
            url,
            params=params,
            headers=headers,
            proxy=f"http://{self.proxy}",
            timeout=aiohttp.ClientTimeout(total=5)
        ) as resp:
            return await resp.json()

    OKX API Proxy Setup

    OKX Rate Limit Structure

    OKX has the most restrictive rate limits among the three exchanges:

    • Trade endpoints: 60 requests per 2 seconds (per instrument)
    • Market data: 20 requests per 2 seconds
    • Account info: 10 requests per 2 seconds
    import base64
import datetime

class OKXProxyTrader:
    BASE_URL = "https://www.okx.com"

    def __init__(self, api_key: str, secret_key: str,
                 passphrase: str, proxy: str):
        self.api_key = api_key
        self.secret_key = secret_key
        self.passphrase = passphrase
        self.proxy = proxy

    def _sign(self, timestamp: str, method: str,
              request_path: str, body: str = "") -> str:
        message = timestamp + method + request_path + body
        mac = hmac.new(
            self.secret_key.encode(),
            message.encode(),
            hashlib.sha256
        )
        return base64.b64encode(mac.digest()).decode()

    def _get_headers(self, method: str, request_path: str,
                      body: str = "") -> dict:
        timestamp = datetime.datetime.utcnow().strftime(
            '%Y-%m-%dT%H:%M:%S.%f'
        )[:-3] + 'Z'
        sign = self._sign(timestamp, method, request_path, body)

        return {
            "OK-ACCESS-KEY": self.api_key,
            "OK-ACCESS-SIGN": sign,
            "OK-ACCESS-TIMESTAMP": timestamp,
            "OK-ACCESS-PASSPHRASE": self.passphrase,
            "Content-Type": "application/json",
        }

    async def get_ticker(self, session, inst_id: str) -> dict:
        path = f"/api/v5/market/ticker?instId={inst_id}"
        headers = self._get_headers("GET", path)

        async with session.get(
            f"{self.BASE_URL}{path}",
            headers=headers,
            proxy=f"http://{self.proxy}",
            timeout=aiohttp.ClientTimeout(total=5)
        ) as resp:
            data = await resp.json()
            return data.get("data", [{}])[0]

    async def place_order(self, session, inst_id: str,
                           side: str, ord_type: str,
                           sz: str, px: str = None) -> dict:
        path = "/api/v5/trade/order"
        body = {
            "instId": inst_id,
            "tdMode": "cash",
            "side": side,
            "ordType": ord_type,
            "sz": sz,
        }
        if px:
            body["px"] = px

        import json
        body_str = json.dumps(body)
        headers = self._get_headers("POST", path, body_str)

        async with session.post(
            f"{self.BASE_URL}{path}",
            data=body_str,
            headers=headers,
            proxy=f"http://{self.proxy}",
            timeout=aiohttp.ClientTimeout(total=5)
        ) as resp:
            return await resp.json()

    async def get_account_balance(self, session) -> dict:
        path = "/api/v5/account/balance"
        headers = self._get_headers("GET", path)

        async with session.get(
            f"{self.BASE_URL}{path}",
            headers=headers,
            proxy=f"http://{self.proxy}",
            timeout=aiohttp.ClientTimeout(total=5)
        ) as resp:
            return await resp.json()

    Multi-Exchange Proxy Architecture

    For traders operating across all three exchanges simultaneously:

    class MultiExchangeProxySetup:
    def __init__(self):
        self.exchanges = {}

    def configure(self, exchange: str, api_key: str,
                   api_secret: str, proxy: str, **kwargs):
        if exchange == "binance":
            self.exchanges["binance"] = BinanceProxyTrader(
                api_key, api_secret, proxy
            )
        elif exchange == "bybit":
            self.exchanges["bybit"] = BybitProxyTrader(
                api_key, api_secret, proxy
            )
        elif exchange == "okx":
            self.exchanges["okx"] = OKXProxyTrader(
                api_key, api_secret,
                kwargs.get("passphrase", ""),
                proxy
            )

    async def get_prices(self, symbol_map: dict) -> dict:
        """Get prices from all exchanges simultaneously."""
        async with aiohttp.ClientSession() as session:
            results = {}
            tasks = {}

            for exchange, trader in self.exchanges.items():
                symbol = symbol_map.get(exchange)
                if not symbol:
                    continue

                if exchange == "binance":
                    tasks[exchange] = trader.get_price(session, symbol)
                elif exchange == "bybit":
                    tasks[exchange] = trader.get_tickers(
                        session, symbol=symbol
                    )
                elif exchange == "okx":
                    tasks[exchange] = trader.get_ticker(session, symbol)

            for exchange, task in tasks.items():
                try:
                    results[exchange] = await task
                except Exception as e:
                    results[exchange] = {"error": str(e)}

            return results

    Proxy Recommendations by Exchange

    Exchange Proxy Type Session Notes
    Binance Mobile (sticky 24h) Dedicated per API key Must whitelist exit IP
    Bybit Mobile (sticky 1h+) Can share across keys Less strict than Binance
    OKX Mobile (sticky 24h) Dedicated per API key IP binding enforced

    All three exchanges work best with mobile proxies that provide stable, high-trust IP addresses. Datacenter proxies are detected and restricted by all three platforms.

    Latency Benchmarks

    Proxy latency directly impacts trading performance. Here are typical latency ranges:

    Proxy Type Binance (Singapore) Bybit (Singapore) OKX (Hong Kong)
    No proxy (co-located) 1-3ms 1-3ms 1-3ms
    Datacenter (same region) 3-10ms 3-10ms 3-10ms
    Mobile (same region) 20-80ms 20-80ms 20-80ms
    Mobile (cross-region) 100-300ms 100-300ms 100-300ms

    For high-frequency strategies, co-located servers without proxies are ideal. For medium-frequency strategies (holding positions for minutes to hours), mobile proxies in the exchange’s region provide acceptable latency. To understand how latency, IP reputation, and connection types interact, the proxy glossary provides detailed technical explanations.

    WebSocket Streams Through Proxies

    All three exchanges provide WebSocket feeds for real-time data. Configure persistent WebSocket connections through your proxies:

    async def binance_websocket_stream(proxy: str, symbols: list):
    streams = "/".join(f"{s.lower()}@trade" for s in symbols)
    ws_url = f"wss://stream.binance.com:9443/stream?streams={streams}"

    async with aiohttp.ClientSession() as session:
        async with session.ws_connect(
            ws_url,
            proxy=f"http://{proxy}",
            heartbeat=30
        ) as ws:
            async for msg in ws:
                if msg.type == aiohttp.WSMsgType.TEXT:
                    data = msg.json()
                    stream = data.get("stream", "")
                    trade = data.get("data", {})
                    print(f"{stream}: {trade.get('p')} @ {trade.get('q')}")

    Common Mistakes

    Using the same proxy for multiple exchange accounts. Exchanges cross-reference IPs across accounts. Dedicate one proxy per account.

    Not accounting for clock skew. API signature validation requires accurate timestamps. Ensure your server clock is synchronized via NTP, and account for any proxy-induced time offset.

    Ignoring IP changes on rotating proxies. If your proxy IP changes mid-session, authenticated API calls fail. Use sticky sessions for trading operations.

    Not implementing local rate limiting. Relying solely on exchange 429 responses wastes requests and risks temporary bans. Track and enforce rate limits in your code.

    Conclusion

    Each exchange demands a tailored proxy approach. Binance’s weight-based limits require careful request budgeting, Bybit’s per-endpoint limits need endpoint-aware rotation, and OKX’s strict IP binding demands the most stable proxy connections. Mobile proxies with extended sticky sessions are the universal recommendation across all three platforms. Invest in exchange-specific proxy configurations rather than using a one-size-fits-all approach, and always implement local rate limiting to protect your API access.

    Related Reading