프록시로 바이낸스 REST API 스크래핑하는 방법: 엔드포인트 가이드

바이낸스 REST API 프록시 스크래핑 개요

바이낸스 REST API는 풍부한 시장 데이터를 제공하지만, 가중치 기반 속도 제한(weight-based rate limit)으로 인해 대규모 데이터 수집이 어렵습니다. 단일 IP로 /api/v3/depth를 폴링하면 몇 분 안에 분당 약 6,000의 가중치 예산이 소진되어 HTTP 429 응답이 반환되고, 반복 시 HTTP 418로 IP가 차단될 수 있습니다. 이 가이드에서는 바이낸스 REST API 프록시 스크래핑을 안전하게 수행하기 위해 ProxyHat 주거 프록시를 활용하여 가중치를 여러 IP에 분산시키고, geo 타겟팅으로 바이낸스닷컴과 바이낸스 US 지역 분할(HTTP 451)을 우회하는 방법을 다룹니다.

면책 고지: 본 가이드는 공개 시장 데이터(public market data) 수집만을 다룹니다. 바이낸스 API 이용약관(Terms of Use)을 준수하고, 가중치 제한을 존중하며, 약관에서 공식 API 접근을 요구하는 경우 해당 경로를 우선 사용하십시오. 자세한 내용은 Binance Terms of Use를 참조하세요.

왜 이 문제가 발생하는가: 바이낸스 가중치 기반 속도 제한

바이낸스 REST API는 단순히 요청 수가 아니라 가중치(weight) 단위로 속도 제한을 관리합니다. 각 엔드포인트는 요청당 소비 가중치가 다르며, 응답 헤더 X-MBX-USED-WEIGHT-1M을 통해 현재 1분간 사용된 가중치를 확인할 수 있습니다. 자세한 사양은 Binance API Limits 공식 문서에 정의되어 있습니다.

주요 동작 방식은 다음과 같습니다:

• 분당 약 6,000 가중치 — IP당 기본 가중치 예산 (바이낸스는 이 값을 동적으로 조정할 수 있음).
• HTTP 429 — 가중치 예산 초과 시 반환. Retry-After 헤더로 대기 시간 안내.
• HTTP 418 — 429 후에도 계속 요청하면 IP가 자동 차단(ban). 차단은 점진적으로 길어집니다(2분 → 1일 등).

예를 들어 /api/v3/depth는 limit=1000 설정 시 가중치 10을 소비합니다. 분당 6,000 가중치 예산으로는 600회만 호출 가능하며, 1초 간격으로 폴링해도 약 10분이면 예산이 소진됩니다. 여러 심볼의 오더북을 동시에 수집하면 예산은 훨씬 빨리 고갈됩니다.

핵심 공개 시장 데이터 엔드포인트 매핑

다음 표는 바이낸스 REST API의 주요 공개 엔드포인트와 요청당 가중치를 정리한 것입니다. 가중치는 바이낸스 공식 문서 기준이며, 파라미터에 따라 달라질 수 있습니다.

모든 응답에는 X-MBX-USED-WEIGHT-1M 헤더가 포함되어 있으므로, 클라이언트는 실시간으로 가중치 소비를 추적할 수 있습니다. 이 값을 모니터링하고 동적으로 요청 속도를 조절하는 것이 차단을 방지하는 핵심입니다.

ProxyHat 주거 프록시로 가중치 분산하기

ProxyHat 주거 프록시를 사용하면 각 요청마다 다른 IP를 할당받아 가중치를 분산시킬 수 있습니다. 바이낸스의 속도 제한은 IP 기반이므로, N개의 IP를 사용하면 이론적으로 분당 6,000 × N 가중치까지 처리할 수 있습니다.

또한 바이낸스닷컴(Binance.com)은 미국 사용자에게 HTTP 451(법적 이유로 콘텐츠 사용 불가)을 반환합니다. ProxyHat의 -country-US 사용자 이름 플래그로 미국 IP를 타겟팅하면 바이낸스 US가 아닌 글로벌 바이낸스닷컴 엔드포인트에 접근할 수 있으며, 반대로 다른 국가 IP를 사용하면 지역 제한을 우회할 수 있습니다. ProxyHat 프록시 위치 페이지에서 사용 가능한 국가를 확인하세요.

ProxyHat 연결 파라미터

사용자 이름에 국가 및 세션 플래그를 추가할 수 있습니다:

• user-country-US:pass — 미국 IP 사용
• user-country-DE-city-berlin:pass — 독일 베를린 IP 사용
• user-session-abc123:pass — 고정 세션(스티키 IP)

Python: 요청별 IP 로테이션으로 klines 수집

다음 예제는 requests 라이브러리와 ProxyHat 게이트웨이를 사용해 요청마다 새로운 주거 IP를 할당받아 바이낸스 klines 엔드포인트를 호출합니다. 가중치 추적, 지수 백오프 재시도, 429/418 처리를 포함합니다.

import requests
import time
import logging
from urllib.parse import urlencode

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger(__name__)

BINANCE_BASE = "https://api.binance.com"
PROXYHAT_GATEWAY = "gate.proxyhat.com"
PROXYHAT_PORT = 8080
PROXYHAT_USER = "your_username"
PROXYHAT_PASS = "your_password"

# ProxyHat는 사용자 이름 플래그 없이 기본 로테이션(요청마다 새 IP)
def get_proxy_url(country=None, session_id=None):
    username = PROXYHAT_USER
    if country:
        username += f"-country-{country}"
    if session_id:
        username += f"-session-{session_id}"
    return f"http://{username}:{PROXYHAT_PASS}@{PROXYHAT_GATEWAY}:{PROXYHAT_PORT}"

def fetch_klines(symbol, interval, limit=1000, max_retries=5):
    """바이낸스 klines를 ProxyHat 주거 프록시로 수집 (요청별 IP 로테이션)"""
    params = {"symbol": symbol, "interval": interval, "limit": limit}
    url = f"{BINANCE_BASE}/api/v3/klines?{urlencode(params)}"

    for attempt in range(max_retries):
        proxy_url = get_proxy_url()  # 매 요청마다 새 IP
        proxies = {"http": proxy_url, "https": proxy_url}

        try:
            resp = requests.get(url, proxies=proxies, timeout=15)
            used_weight = resp.headers.get("X-MBX-USED-WEIGHT-1M", "unknown")
            logger.info(f"{symbol} {interval} | HTTP {resp.status_code} | weight-1m={used_weight}")

            if resp.status_code == 200:
                return resp.json()
            elif resp.status_code == 429:
                retry_after = int(resp.headers.get("Retry-After", 10))
                logger.warning(f"429 rate limited. Waiting {retry_after}s...")
                time.sleep(retry_after)
                continue
            elif resp.status_code == 418:
                logger.error("418 IP banned. Backing off 120s and rotating IP.")
                time.sleep(120)
                continue
            else:
                logger.error(f"Unexpected status: {resp.status_code}")
                resp.raise_for_status()

        except requests.exceptions.RequestException as e:
            backoff = min(2 ** attempt, 60)
            logger.warning(f"Request failed (attempt {attempt+1}): {e}. Retrying in {backoff}s...")
            time.sleep(backoff)

    raise RuntimeError(f"Failed to fetch klines for {symbol} after {max_retries} retries")

# 사용 예
data = fetch_klines("BTCUSDT", "1m", limit=1000)
print(f"Got {len(data)} candles")

Python: httpx + ProxyHat SDK 스타일로 오더북 폴링

httpx를 사용하면 비동기 컨셉션으로 여러 심볼의 오더북을 동시에 수집할 수 있습니다. 다음 예제는 가중치 인식 스로틀링과 컨셉션 제한을 포함합니다.

import httpx
import asyncio
import logging
import time

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

BINANCE_BASE = "https://api.binance.com"
PROXYHAT_USER = "your_username"
PROXYHAT_PASS = "your_password"

MAX_CONCURRENT = 10  # 동시 요청 수 제한
WEIGHT_BUDGET_PER_MIN = 5500  # 안전 마진 500

# 전역 가중치 추적
used_weight_1m = 0
weight_reset_time = time.time() + 60

def build_proxy_url(country=None):
    user = PROXYHAT_USER
    if country:
        user += f"-country-{country}"
    return f"http://{user}:{PROXYHAT_PASS}@gate.proxyhat.com:8080"

async def fetch_depth(client, symbol, limit=100):
    """오더북 수집 — limit=100은 가중치 1"""
    global used_weight_1m, weight_reset_time

    # 가중치 예산 체크
    now = time.time()
    if now > weight_reset_time:
        used_weight_1m = 0
        weight_reset_time = now + 60
    if used_weight_1m >= WEIGHT_BUDGET_PER_MIN:
        sleep_time = weight_reset_time - now
        logger.info(f"Weight budget reached. Sleeping {sleep_time:.1f}s...")
        await asyncio.sleep(max(sleep_time, 1))

    url = f"{BINANCE_BASE}/api/v3/depth?symbol={symbol}&limit={limit}"
    proxy = build_proxy_url()  # 요청별 IP 로테이션

    try:
        resp = await client.get(url, proxy=proxy, timeout=15)
        weight = int(resp.headers.get("X-MBX-USED-WEIGHT-1M", 0))
        used_weight_1m = max(used_weight_1m, weight)
        logger.info(f"{symbol} depth | HTTP {resp.status_code} | weight={weight}")
        if resp.status_code == 200:
            return {"symbol": symbol, "bids": resp.json()["bids"][:10], "asks": resp.json()["asks"][:10]}
        elif resp.status_code == 429:
            retry_after = int(resp.headers.get("Retry-After", 10))
            await asyncio.sleep(retry_after)
    except Exception as e:
        logger.error(f"{symbol}: {e}")
    return None

async def poll_multiple_symbols(symbols, limit=100):
    """여러 심볼의 오더북을 동시 폴링"""
    semaphore = asyncio.Semaphore(MAX_CONCURRENT)

    async def bounded_fetch(client, sym):
        async with semaphore:
            return await fetch_depth(client, sym, limit)

    async with httpx.AsyncClient() as client:
        tasks = [bounded_fetch(client, sym) for sym in symbols]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        return [r for r in results if r is not None and not isinstance(r, Exception)]

# 사용 예
symbols = ["BTCUSDT", "ETHUSDT", "BNBUSDT", "SOLUSDT", "XRPUSDT"]
results = asyncio.run(poll_multiple_symbols(symbols))
print(f"Collected depth for {len(results)} symbols")

Python: 스티키 세션으로 klines 백필 (페이지네이션)

과거 klines를 대량으로 백필할 때는 페이지네이션이 필요합니다. 동일한 IP로 연속 요청을 보내면 가중치가 누적되어 빠르게 차단되므로, 페이지 단위로 IP를 로테이션하거나 스티키 세션을 사용하는 것이 좋습니다. 다음 예제는 -session- 플래그로 특정 페이지 범위 동안 같은 IP를 유지하면서 백필합니다.

import requests
import time
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

BINANCE_BASE = "https://api.binance.com"
PROXYHAT_USER = "your_username"
PROXYHAT_PASS = "your_password"

def build_sticky_proxy(session_id, country=None):
    """ProxyHat 스티키 세션 — 같은 session_id = 같은 IP"""
    user = PROXYHAT_USER
    if country:
        user += f"-country-{country}"
    user += f"-session-{session_id}"
    return f"http://{user}:{PROXYHAT_PASS}@gate.proxyhat.com:8080"

def backfill_klines(symbol, interval, start_time_ms, end_time_ms, batch_size=1000):
    """과거 klines를 페이지네이션으로 백필 — 페이지마다 새 스티키 세션(새 IP)"""
    all_candles = []
    current_start = start_time_ms
    page = 0

    while current_start < end_time_ms:
        # 페이지마다 새 세션 ID → 새 IP 할당
        session_id = f"backfill-{symbol}-{page}"
        proxy_url = build_sticky_proxy(session_id)
        proxies = {"http": proxy_url, "https": proxy_url}

        params = {
            "symbol": symbol,
            "interval": interval,
            "startTime": current_start,
            "endTime": end_time_ms,
            "limit": batch_size,
        }
        url = f"{BINANCE_BASE}/api/v3/klines"

        for attempt in range(5):
            try:
                resp = requests.get(url, params=params, proxies=proxies, timeout=20)
                weight = resp.headers.get("X-MBX-USED-WEIGHT-1M", "?")
                logger.info(f"Page {page} | HTTP {resp.status_code} | weight={weight} | session={session_id}")

                if resp.status_code == 200:
                    candles = resp.json()
                    if not candles:
                        logger.info("No more data.")
                        return all_candles
                    all_candles.extend(candles)
                    # 다음 페이지 시작 시간 = 마지막 캔들 종료 시간 + 1ms
                    current_start = candles[-1][6] + 1
                    page += 1
                    time.sleep(0.2)  # 가중치 완화를 위한 최소 대기
                    break
                elif resp.status_code == 429:
                    retry_after = int(resp.headers.get("Retry-After", 10))
                    logger.warning(f"429 on page {page}. Waiting {retry_after}s...")
                    time.sleep(retry_after)
                    # 새 IP로 세션 교체
                    session_id = f"backfill-{symbol}-{page}-retry"
                    proxy_url = build_sticky_proxy(session_id)
                    proxies = {"http": proxy_url, "https": proxy_url}
                elif resp.status_code == 418:
                    logger.error("418 banned. Rotating IP and waiting 120s.")
                    time.sleep(120)
                    session_id = f"backfill-{symbol}-{page}-ban"
                    proxy_url = build_sticky_proxy(session_id)
                    proxies = {"http": proxy_url, "https": proxy_url}
                else:
                    resp.raise_for_status()
            except requests.RequestException as e:
                backoff = min(2 ** attempt, 60)
                logger.warning(f"Error on page {page}: {e}. Backoff {backoff}s.")
                time.sleep(backoff)
        else:
            logger.error(f"Failed page {page} after retries. Stopping.")
            break

    return all_candles

# 사용 예: BTCUSDT 1분봉 2024-01-01 ~ 2024-01-07 백필
start = 1704067200000  # 2024-01-01 00:00:00 UTC ms
candles = backfill_klines("BTCUSDT", "1m", start, start + 7 * 86400000)
print(f"Total candles: {len(candles)}")

Node.js: axios로 24시간 티커 수집

Node.js 환경에서는 axios와 https-proxy-agent를 조합해 ProxyHat 프록시를 사용할 수 있습니다. 다음 예제는 전체 심볼의 24시간 티커를 수집하되, 가중치 40이 소모되는 전체 심볼 조회 대신 개별 심볼 조회(가중치 1)를 병렬로 수행합니다.

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');
const pLimit = require('p-limit');

const BINANCE_BASE = 'https://api.binance.com';
const PROXYHAT_USER = 'your_username';
const PROXYHAT_PASS = 'your_password';
const GATEWAY = 'gate.proxyhat.com';
const PORT = 8080;

// ProxyHat 프록시 URL 생성 (요청별 로테이션)
function buildProxyUrl(country = null) {
  let user = PROXYHAT_USER;
  if (country) user += `-country-${country}`;
  return `http://${user}:${PROXYHAT_PASS}@${GATEWAY}:${PORT}`;
}

// 지수 백오프 재시도 래퍼
async function fetchWithRetry(url, proxyUrl, maxRetries = 5) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const agent = new HttpsProxyAgent(proxyUrl);
      const resp = await axios.get(url, {
        httpsAgent: agent,
        timeout: 15000,
        headers: { 'User-Agent': 'MarketDataCollector/1.0' },
      });
      const weight = resp.headers['x-mbx-used-weight-1m'] || 'unknown';
      console.log(`HTTP ${resp.status} | weight-1m=${weight}`);
      return resp.data;
    } catch (err) {
      const status = err.response?.status;
      if (status === 429) {
        const retryAfter = parseInt(err.response.headers['retry-after'] || '10', 10);
        console.warn(`429 rate limited. Waiting ${retryAfter}s...`);
        await new Promise(r => setTimeout(r, retryAfter * 1000));
        // 새 프록시 URL (새 IP)
        continue;
      } else if (status === 418) {
        console.error('418 IP banned. Waiting 120s...');
        await new Promise(r => setTimeout(r, 120000));
        continue;
      }
      const backoff = Math.min(Math.pow(2, attempt), 60);
      console.warn(`Attempt ${attempt + 1} failed: ${err.message}. Backoff ${backoff}s.`);
      await new Promise(r => setTimeout(r, backoff * 1000));
    }
  }
  throw new Error(`Failed after ${maxRetries} retries`);
}

// 여러 심볼의 24hr ticker를 병렬 수집 (가중치 1 per 심볼)
async function fetch24hrTickers(symbols) {
  const limit = pLimit(10); // 동시 10개 제한
  const results = await Promise.all(
    symbols.map(sym =>
      limit(async () => {
        const url = `${BINANCE_BASE}/api/v3/ticker/24hr?symbol=${sym}`;
        const proxyUrl = buildProxyUrl(); // 각 요청마다 새 IP
        try {
          const data = await fetchWithRetry(url, proxyUrl);
          return { symbol: sym, lastPrice: data.lastPrice, volume: data.volume };
        } catch (e) {
          console.error(`${sym} failed: ${e.message}`);
          return null;
        }
      })
    )
  );
  return results.filter(r => r !== null);
}

// 사용 예
(async () => {
  const symbols = ['BTCUSDT', 'ETHUSDT', 'BNBUSDT', 'SOLUSDT', 'XRPUSDT',
                   'ADAUSDT', 'DOGEUSDT', 'AVAXUSDT', 'DOTUSDT', 'LINKUSDT'];
  const tickers = await fetch24hrTickers(symbols);
  console.log(`Collected ${tickers.length} tickers`);
  tickers.forEach(t => console.log(`${t.symbol}: $${t.lastPrice} (vol: ${t.volume})`));
})();

curl: 단일 요청으로 가중치 헤더 확인

가장 빠르게 ProxyHat 프록시를 통해 바이낸스 API 응답 헤더를 확인하는 방법입니다. -v 플래그로 X-MBX-USED-WEIGHT-1M 헤더를 직접 확인할 수 있습니다.

# ProxyHat HTTP 프록시로 klines 호출 + 응답 헤더 확인
curl -v --proxy "http://your_username:your_password@gate.proxyhat.com:8080" \
  "https://api.binance.com/api/v3/klines?symbol=BTCUSDT&interval=1m&limit=10" \
  2>&1 | grep -i "x-mbx-used-weight-1m"

# 미국 IP로 타겟팅
curl -v --proxy "http://your_username-country-US:your_password@gate.proxyhat.com:8080" \
  "https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT"

# SOCKS5 프록시로 오더북 호출
curl -v --proxy "socks5://your_username:your_password@gate.proxyhat.com:1080" \
  "https://api.binance.com/api/v3/depth?symbol=BTCUSDT&limit=100"

WebSocket vs REST: 언제 어떤 것을 사용해야 하는가

바이낸스는 wss://stream.binance.com:9443을 통해 WebSocket 스트림을 제공합니다. REST 폴링과 WebSocket의 선택 기준은 다음과 같습니다.

실시간 오더북이 필요하다면 wss://stream.binance.com:9443/ws/btcusdt@depth 스트림을 사용하는 것이 REST 폴링보다 효율적입니다. 하지만 과거 데이터 백필이나 간헐적 스냅샷 수집에는 REST API가 적합하며, 이때 ProxyHat 프록시로 가중치를 분산하는 것이 핵심입니다. WebSocket 연결에도 프록시가 필요한 경우 SOCKS5(gate.proxyhat.com:1080)를 사용할 수 있습니다.

흔한 실수와 엣지 케이스

• X-MBX-USED-WEIGHT-1M 무시: 응답 헤더를 추적하지 않으면 429를 예상 없이 맞게 됩니다. 모든 요청에서 이 헤더를 로깅하세요.
• limit=1000 depth 남용: 가중치 10을 소모합니다. limit=100(가중치 1)으로 충분한 경우가 많습니다.
• 전체 심볼 24hr ticker 호출: /api/v3/ticker/24hr를 심볼 없이 호출하면 가중치 40이 소모됩니다. 필요한 심볼만 개별 조회(가중치 1)하는 것이 효율적입니다.
• 동일 IP로 연속 429 후 재시도: 429 후 같은 IP로 계속 요청하면 418로 에스컬레이션됩니다. 반드시 IP를 로테이션하고 Retry-After 대기 시간을 준수하세요.
• HTTP 451 (지역 제한): 바이낸스닷컴이 특정 지역 IP를 차단할 때 반환됩니다. -country-US 또는 다른 국가 플래그로 우회하세요.
• 재시도 없는 단일 실패: 네트워크 타임아웃, 프록시 연결 실패 등은 일시적일 수 있습니다. 지수 백오프 재시도를 기본으로 구현하세요.

ProxyHat 설정 및 내부 링크

ProxyHat 주거 프록시를 사용하면 바이낸스 REST API 스크래핑 시 가중치를 여러 IP에 분산시킬 수 있습니다. ProxyHat 요금제에서 주거/데이터센터/모바일 프록시 옵션을 확인하고, 웹 스크래핑 사용 사례 페이지에서 다른 스크래핑 시나리오를 참조하세요. SERP 추적과 관련된 작업은 SERP 추적 사용 사례를 확인하시고, ProxyHat SDK 및 API 문법은 ProxyHat 공식 문서를 참조하세요.

핵심 요약

• 바이낸스 REST API는 IP당 분당 약 6,000 가중치 제한을 가지며, 초과 시 429 → 418로 에스컬레이션됩니다.
• X-MBX-USED-WEIGHT-1M 헤더를 실시간 추적하여 동적으로 요청 속도를 조절하세요.
• ProxyHat 주거 프록시(gate.proxyhat.com:8080)로 요청별 IP 로테이션을 사용하면 가중치를 여러 IP에 분산할 수 있습니다.
• 과거 데이터 백필에는 스티키 세션(-session-), 실시간 데이터에는 WebSocket 스트림이 적합합니다.
• -country-US 플래그로 바이낸스닷컴 지역 제한(HTTP 451)을 우회할 수 있습니다.
• 지수 백오프 재시도, 컨셉션 제한, 가중치 인식 스로틀링을 프로덕션 코드에 기본으로 포함하세요.

FAQ

바이낸스 REST API를 프록시로 스크래핑하는 방법이란 무엇인가요?

바이낸스 REST API의 공개 시장 데이터 엔드포인트(klines, depth, ticker 등)를 호출할 때, ProxyHat과 같은 주거 프록시를 통해 요청마다 다른 IP를 사용하여 바이낸스의 가중치 기반 속도 제한을 여러 IP에 분산시키는 기법입니다. 이를 통해 단일 IP의 분당 6,000 가중치 제한을 우회하여 대규모 데이터 수집이 가능해집니다.

프록시 사용자에게 바이낸스 REST API 스크래핑이 중요한 이유는 무엇인가요?

바이낸스는 IP 기반 가중치 제한을 사용하므로, 단일 IP로 대규모 데이터를 수집하면 빠르게 429(속도 제한) 또는 418(IP 차단) 응답을 받게 됩니다. 프록시를 사용해 IP를 로테이션하면 가중치를 분산시켜 차단 없이 지속적인 데이터 수집이 가능하며, 지역 제한(HTTP 451)도 우회할 수 있습니다.

바이낸스 REST API 스크래핑에 어떤 프록시 유형이 가장 적합한가요?

주거 프록시(residential proxy)가 가장 적합합니다. 데이터센터 IP는 바이낸스가 의심스러운 트래픽으로 식별할 가능성이 높고, 모바일 프록시는 안정성이 떨어질 수 있습니다. 주거 프록시는 실제 ISP IP를 사용하므로 차단 위험이 낮고, ProxyHat의 요청별 로테이션 기능으로 가중치를 효과적으로 분산시킬 수 있습니다.

바이낸스 REST API 스크래핑 시 차단을 피하려면 어떻게 해야 하나요?

세 가지 핵심 전략이 있습니다: (1) X-MBX-USED-WEIGHT-1M 헤더를 모니터링하여 가중치 예산에 가까워지면 자동으로 속도를 줄이세요. (2) 429 응답 시 Retry-After 헤더를 준수하고 즉시 IP를 로테이션하세요. (3) 동시 요청 수를 제한하고 지수 백오프 재시도를 구현하세요. 또한 limit 파라미터를 최소화하여 가중치 소모를 줄이는 것이 중요합니다.