Using proxy with Siebly SDKs

Exchanges like Binance and Bybit track request volume per IP. Go over the limit and you get HTTP 429 responses. Keep pushing and the IP can end up blocked entirely.

A proxy pool spreads REST polling across multiple IPs. That helps with public market data workloads where one server IP cannot carry the full request load.

Some endpoints only work from certain regions. That affects okx-api, @siebly/kraken-api, gateio-api, and kucoin-api depending on which market or region you target. A proxy in the right location lets your app reach those gateways without moving your main compute.

Exchanges like OKX and Kraken require accurate timestamps in signed requests. Extra proxy latency can trigger recv window errors if you are close to the limit.

The SDK signs the request before it hits the network. The proxy does not rewrite auth headers. If you see timestamp errors after adding a proxy, increase the recv window. The Bybit SDK documents this directly in its proxy examples (recv_window defaults to 5000 ms).

Before touching private endpoints, call a public method like a ticker or server time check to confirm routing works.

This pattern comes from the bybit-api proxy example and matches what the SDK test suites use:

import { RestClientV5 } from "bybit-api";

const client = new RestClientV5( { key: process.env.BYBIT_API_KEY, secret: process.env.BYBIT_API_SECRET, testnet: true, // Extra latency from a proxy can cause recv window errors // recv_window: 10000, }, { proxy: { protocol: "http", host: process.env.PROXY_HOST!, port: Number(process.env.PROXY_PORT), auth: { username: process.env.PROXY_USER!, password: process.env.PROXY_PASS!, }, }, }, );

The same second-argument pattern works for:

Binance example:

import { MainClient } from "binance";

const client = new MainClient( { testnet: true }, { proxy: { protocol: "http", host: process.env.PROXY_HOST!, port: Number(process.env.PROXY_PORT), auth: { username: process.env.PROXY_USER!, password: process.env.PROXY_PASS!, }, }, }, );

const serverTime = await client.getServerTime();

Kraken example:

import { SpotClient } from "@siebly/kraken-api";

const client = new SpotClient( { apiKey: process.env.KRAKEN_API_KEY, apiSecret: process.env.KRAKEN_API_SECRET, }, { proxy: { protocol: "http", host: process.env.PROXY_HOST!, port: Number(process.env.PROXY_PORT), auth: { username: process.env.PROXY_USER!, password: process.env.PROXY_PASS!, }, }, }, );

Coinbase example:

import { CBAdvancedTradeClient } from "coinbase-api";

const client = new CBAdvancedTradeClient( {}, { proxy: { protocol: "http", host: process.env.PROXY_HOST!, port: Number(process.env.PROXY_PORT), auth: { username: process.env.PROXY_USER!, password: process.env.PROXY_PASS!, }, }, }, );

Some proxy providers do not work with axios proxy config. Use https-proxy-agent instead, as shown in bybit-api rest-v5-proxies2.ts:

import { HttpsProxyAgent } from "https-proxy-agent"; import { RestClientV5 } from "bybit-api";

const client = new RestClientV5( { key: process.env.BYBIT_API_KEY, secret: process.env.BYBIT_API_SECRET, testnet: true, }, { httpAgent: proxyAgent, httpsAgent: proxyAgent, }, );

From the binance ws-proxy-socks example:

import { WebsocketClient } from "binance"; import { SocksProxyAgent } from "socks-proxy-agent";

const agent = new SocksProxyAgent(process.env.SOCKS_PROXY_URL!);

const wsClient = new WebsocketClient({ beautify: true, wsOptions: { agent, }, });

wsClient.on("open", (data) => { console.log("connected:", data.wsKey); });

wsClient.subscribeAll24hrTickers("usdm");

Most WebSocket clients only need wsOptions.agent. Some also make internal REST calls (listen keys, WS auth tokens). For those, set both:

• wsOptions.agent for the socket connection
• requestOptions for axios-backed REST calls inside the client

Kraken / KuCoin example (token fetch over REST):

import { HttpsProxyAgent } from "https-proxy-agent"; import { WebsocketClient } from "kucoin-api";

const wsClient = new WebsocketClient({ apiKey: process.env.KUCOIN_API_KEY, apiSecret: process.env.KUCOIN_API_SECRET, apiPassphrase: process.env.KUCOIN_API_PASSPHRASE, wsOptions: { agent: proxyAgent, }, requestOptions: { httpAgent: proxyAgent, httpsAgent: proxyAgent, }, });

Bybit needs only the socket agent:

import { HttpsProxyAgent } from "https-proxy-agent"; import { WebsocketClient } from "bybit-api";

const wsClient = new WebsocketClient({ key: process.env.BYBIT_API_KEY, secret: process.env.BYBIT_API_SECRET, wsOptions: { agent: proxyAgent, }, });

Binance private streams (listen keys) need the same split on WebsocketClient or WebsocketAPIClient. From the SDK test suite:

import { WebsocketAPIClient } from "binance";

const wsAPIClient = new WebsocketAPIClient({ api_key: process.env.BINANCE_API_KEY, api_secret: process.env.BINANCE_API_SECRET, wsOptions: { agent: proxyAgent, }, requestOptions: { proxy: { protocol: "http", host: process.env.PROXY_HOST!, port: Number(process.env.PROXY_PORT), auth: { username: process.env.PROXY_USER!, password: process.env.PROXY_PASS!, }, }, }, });

HTTP proxies work for REST and for many WebSocket setups. SOCKS5 is often a better fit for long-lived private streams because it tunnels raw TCP with less overhead.

For okx-api, bitget-api, bitmart-api, gateio-api, bybit-api, and coinbase-api, pass the agent through wsOptions.agent only.

Gate.io example:

import { WebsocketClient } from "gateio-api"; import { SocksProxyAgent } from "socks-proxy-agent";

const agent = new SocksProxyAgent(process.env.SOCKS_PROXY_URL!);

const ws = new WebsocketClient({ apiKey: process.env.GATE_API_KEY, apiSecret: process.env.GATE_API_SECRET, wsOptions: { agent }, });

• REST: new MainClient(restOptions, networkOptions)
• WebSocket (public streams): wsOptions.agent
• WebSocket private user-data / listen keys: wsOptions.agent + requestOptions
• WebSocket API (order commands over WS): wsOptions + requestOptions
• Test with testnet: true or demoTrading: true in restOptions

• REST: new RestClientV5(restOptions, networkOptions)
• Official proxy examples: examples/Rest/rest-v5-proxies.ts and rest-v5-proxies2.ts
• WebSocket: wsOptions.agent only (requestOptions.agent is a legacy alias for the same WS agent)
• Test with testnet: true on the v5 testnet

• REST: new RestClient(restOptions, networkOptions)
• WebSocket: wsOptions.agent
• WebSocket API client: WebsocketAPIClient with the same agent pattern
• Demo trading: demoTrading: true (not market: 'demo')

• REST: new SpotClient(restOptions, networkOptions) or DerivativesClient
• WebSocket: wsOptions.agent + requestOptions for axios REST token fetches
• Testnet: testnet: true (derivatives demo environment)

• REST: new RestClientV2(restOptions, networkOptions)
• WebSocket: wsOptions.agent on WebsocketClientV2
• WS API commands (order placement over WS) need a stable tunnel; SOCKS5 is a solid default

• REST: new RestClient(restOptions, networkOptions)
• WebSocket: wsOptions.agent

• REST: new RestClient(restOptions, networkOptions)
• WebSocket: wsOptions.agent only
• Sandbox: useTestnet: true

• REST: new SpotClient(restOptions, networkOptions)
• WebSocket: wsOptions.agent + requestOptions (bullet token over REST)
• Regional routing: apiRegion: 'EU' | 'AU' in restOptions when needed

• REST: second constructor arg on CBAdvancedTradeClient, CBExchangeClient, CBPrimeClient, etc.
• WebSocket: wsOptions.agent on WebsocketClient
• Sandbox: useSandbox: true where supported

Pass axios networking config as the second constructor argument. You can use the native proxy object or an HttpsProxyAgent via httpAgent/httpsAgent. See examples/Rest/rest-v5-proxies.ts in the bybit-api repo.

No. The SDK signs locally before the request leaves your process. The proxy only forwards the payload.

Yes. Pass a SocksProxyAgent through wsOptions.agent. This works across Binance, Bybit, OKX, Kraken, Bitget, BitMart, Gate.io, KuCoin, and Coinbase WebSocket clients.

It helps with IP-based limits by spreading traffic across multiple addresses. It does not bypass account-level limits tied to your API key.

https-proxy-agent for HTTP/HTTPS proxies and socks-proxy-agent for SOCKS5. Both integrate with the axios config that Siebly SDKs accept.

No. Build rotation in your application, or use a provider that rotates at the gateway.

Yes, as long as the values come from environment variables or a secret manager at runtime, not from source code.

Usually 5 to 50 ms depending on geography and protocol. For coinbase-api, pick a proxy region close to the exchange gateway you are hitting.

Article by Siebly.io