암호화폐 시장 데이터 인프라는 2024년 기준 일일 거래량 3조 달러를 넘어서며, 고빈도 트레이딩, 백테스팅, 리스크 분석에 있어 과거 주문형(Tick-by-Tick) 데이터의 중요성이 급증하고 있습니다. 저는 3년 넘게 암호화폐 데이터 파이프라인을 구축하며 Tardis.dev, Binance API, Bybit Historical Data 등 다양한 소스를 활용해왔고, 각 서비스의 장단점을 체감적으로 파악하고 있습니다. 본 가이드에서는 2026년 최신 Tardis.dev API를 중심으로 Binance, OKX, Bybit 주문형 회수(Orderbook Replay)를 단계별로 설명하고, HolySheep AI와 공식 API, 타 릴레이 서비스와의 차이를 비교합니다.

Tardis.dev vs 공식 API vs HolySheep AI — 서비스 비교

비교 항목 HolySheep AI Tardis.dev 공식 API (Binance/OKX/Bybit) 기타 릴레이 서비스
주요 용도 AI 모델 통합 · 다중 모델 라우팅 · 비용 최적화 암호화폐 Historical Tick 데이터 · Orderbook Replay 실시간 거래 · 현재 데이터 접근 중계·캐싱 서비스
데이터 범위 AI 모델 응답 (토큰 기반) 과거 Tick·Trade·Orderbook (2020~현재) 실시간 시세 · 계정 관리 제한적 Historical
Binance 지원 ✗ (AI API 중심) ✓ Full Depth · Raw Trades ✓ Spot + Futures Partial
OKX 지원 ✗ ✓ Raw Trades · Orderbooks ✓ Spot + Derivatives Limited
Bybit 지원 ✗ ✓ v3/v5 Raw Trades ✓ Spot + Linear/Option Partial
가격 모델 토큰 기반 ($/MTok) 데이터량 기반 ($/GB 또는 구독) 무료 (Rate Limit만) 구독제
과거 데이터 기간 N/A 2020년~현재 (선별적) 제한적 (보통 7일) 30~90일
WebSocket 스트리밍 ✓ 모델 응답 스트리밍 ✓ 실시간 + Historical Replay ✓ 공식 WebSocket ✓
결제 방식 로컬 결제 (해외 카드 불필요) 국제 카드 필수 해당 없음 국제 카드
Free Tier ✓ 가입 시 무료 크레딧 제한적 Trial ✓ Rate Limit 내 무제한 제한적

핵심 결론: Tardis.dev는 암호화폐 Historical Tick 데이터와 주문형 회수가 목적이시면 최적의 선택입니다. 하지만 AI 모델 통합, 다중 공급자 라우팅, 비용 최적화가 필요하시면 HolySheep AI가 별도로 활용 가치가 높습니다. 본 튜토리얼은 Tardis.dev API를 활용한 Binance · OKX · Bybit 데이터 회수에 집중합니다.

이런 팀에 적합 / 비적합

✓ Tardis.dev가 적합한 팀

✗ Tardis.dev가 비적합한 팀

Tardis.dev API 핵심 개념과 2026년 최신 변경사항

지원 거래소 및 데이터 유형

거래소 Raw Trades Orderbook Deltas Orderbook Snapshots Funding Rates 2026년 신규
Binance Spot ✓ ✓ ✓ ✗ v4 Combined Stream
Binance Futures ✓ ✓ ✓ ✓ USDT-M + COIN-M
OKX ✓ ✓ ✓ ✓ Unified Trading
Bybit Spot ✓ ✓ ✓ ✗ v5 WebSocket
Bybit Derivatives ✓ ✓ ✓ ✓ Linear + Inverse

2026년 Tardis.dev 주요 업데이트

Binance 주문형 회수(Orderbook Replay) 튜토리얼

사전 준비

먼저 Tardis.dev 계정을 생성하고 API Key를 발급받아야 합니다. 2026년 기준으로 Node.js 20+, Python 3.10+ 환경에서 진행합니다.



Node.js 프로젝트 초기화

mkdir tardis-binance-tutorial
cd tardis-binance-tutorial
npm init -y
npm install ws axios node-fetch


Python의 경우

pip install tardis-client websockets-client pandas

Binance Spot Raw Trades 회수


// tardis-binance-trades.js
// Binance Spot BTC/USDT Raw Trades 데이터 회수
const axios = require('axios');

const TARDIS_API_KEY = 'YOUR_TARDIS_API_KEY';
const MARKET = 'binance'; // Binance Spot
const SYMBOL = 'btcusdt';
const EXCHANGE = 'spot';
const FROM_DATE = '2026-01-01';
const TO_DATE = '2026-01-02';

async function fetchRawTrades() {
  const url = https://api.tardis.dev/v1/filtered/${MARKET}/${EXCHANGE}/${SYMBOL}/trades;

  const params = {
    from: ${FROM_DATE}T00:00:00Z,
    to: ${TO_DATE}T00:00:00Z,
    limit: 10000, // 최대 10000개 per 요청
    offset: 0,
  };

  try {
    const response = await axios.get(url, {
      headers: {
        'Authorization': Bearer ${TARDIS_API_KEY},
        'Accept': 'application/x-ndjson', // NDJSON 스트리밍 응답
      },
      params,
      timeout: 30000,
    });

    // NDJSON 파싱
    const lines = response.data.trim().split('\n');
    const trades = lines.map(line => JSON.parse(line));

    console.log(📊 Fetched ${trades.length} trades for ${SYMBOL});
    console.log(💰 Sample trade:, trades[0]);

    return trades;
  } catch (error) {
    console.error('❌ Tardis API Error:', error.response?.status, error.response?.data?.message || error.message);
    throw error;
  }
}

fetchRawTrades().then(trades => {
  // 첫 5개 거래 샘플 출력
  console.log('\n=== First 5 Trades ===');
  trades.slice(0, 5).forEach((t, i) => {
    console.log(${i+1}. Price: ${t.price} | Amount: ${t.amount} | Side: ${t.side} | Time: ${new Date(t.timestamp).toISOString()});
  });
}).catch(console.error);

Binance Futures Orderbook Snapshot + Delta 회수


// tardis-binance-orderbook.js
// Binance USDT-M Futures Orderbook Replay
const WebSocket = require('ws');

const TARDIS_WS_URL = 'wss://api.tardis.dev/v1/market-data/stream';
const MARKET = 'binance';
const EXCHANGE = 'futures';
const SYMBOL = 'btcusdt';

class OrderbookReplay {
  constructor() {
    this.ws = null;
    this.orderbook = { bids: {}, asks: {} };
    this.snapshots = [];
  }

  connect() {
    // Tardis.dev WebSocket 스트리밍
    const streamId = ${MARKET}:${EXCHANGE}:${SYMBOL}:orderbook:100ms;

    this.ws = new WebSocket(TARDIS_WS_URL, {
      headers: {
        'Authorization': Bearer ${process.env.TARDIS_API_KEY},
      }
    });

    this.ws.on('open', () => {
      console.log('🔗 Connected to Tardis.dev WebSocket');

      // 구독 메시지 전송
      this.ws.send(JSON.stringify({
        type: 'subscribe',
        stream: streamId,
        from: '2026-01-01T00:00:00Z',  // 회수 시작 시간
        to: '2026-01-01T01:00:00Z',    // 회수 종료 시간
        filters: {
          // 특정 심볼 필터 가능
        }
      }));
    });

    this.ws.on('message', (data) => {
      const message = JSON.parse(data.toString());
      this.processMessage(message);
    });

    this.ws.on('error', (err) => {
      console.error('❌ WebSocket Error:', err.message);
    });

    this.ws.on('close', () => {
      console.log('🔌 Connection closed');
    });
  }

  processMessage(msg) {
    // Snapshot 메시지 처리
    if (msg.type === 'snapshot') {
      console.log(📸 Snapshot received: ${msg.data.bids.length} bids, ${msg.data.asks.length} asks);
      this.orderbook.bids = {};
      this.orderbook.asks = {};

      msg.data.bids.forEach(([price, amount]) => {
        this.orderbook.bids[price] = parseFloat(amount);
      });
      msg.data.asks.forEach(([price, amount]) => {
        this.orderbook.asks[price] = parseFloat(amount);
      });

      console.log(   Best Bid: ${Object.keys(this.orderbook.bids)[0]} | Best Ask: ${Object.keys(this.orderbook.asks)[0]});
      console.log(   Spread: ${(Object.keys(this.orderbook.asks)[0] - Object.keys(this.orderbook.bids)[0]).toFixed(2)} USDT);
    }

    // Delta 업데이트 처리
    if (msg.type === 'delta') {
      msg.data.bids.forEach(([price, amount]) => {
        if (parseFloat(amount) === 0) {
          delete this.orderbook.bids[price];
        } else {
          this.orderbook.bids[price] = parseFloat(amount);
        }
      });

      msg.data.asks.forEach(([price, amount]) => {
        if (parseFloat(amount) === 0) {
          delete this.orderbook.asks[price];
        } else {
          this.orderbook.asks[price] = parseFloat(amount);
        }
      });

      // 1초마다 로깅
      if (msg.timestamp % 1000 < 100) {
        console.log(⏰ ${new Date(msg.timestamp).toISOString()} | Bids: ${Object.keys(this.orderbook.bids).length} | Asks: ${Object.keys(this.orderbook.asks).length});
      }
    }
  }

  disconnect() {
    if (this.ws) {
      this.ws.close();
    }
  }
}

// 실행
const replay = new OrderbookReplay();
replay.connect();

// 5분 후 자동 종료
setTimeout(() => {
  console.log('⏹ Stopping replay...');
  replay.disconnect();
  process.exit(0);
}, 300000);

OKX 주문형 회수(Replay) 튜토리얼



tardis_okx_replay.py


OKX Spot Raw Trades + Orderbook 회수

import asyncio
import json
import websockets
from datetime import datetime, timedelta

TARDIS_API_KEY = "YOUR_TARDIS_API_KEY"
MARKET = "okx"
EXCHANGE = "spot"
SYMBOL = "btc-usdt"

class OKXOrderbookReplay:
    def __init__(self):
        self.orderbook = {"bids": {}, "asks": {}}
        self.trade_count = 0
        self.replay_start = datetime(2026, 1, 1, 0, 0, 0)
        self.replay_end = datetime(2026, 1, 1, 1, 0, 0)

    async def fetch_historical_orderbook(self):
        """HTTP API로 Historical Orderbook Snapshot 회수"""
        from urllib.parse import urlencode
        import aiohttp

        url = "https://api.tardis.dev/v1/filtered/okx/spot/btc-usdt/orderbook_snapshots"
        params = {
            "from": self.replay_start.isoformat() + "Z",
            "to": self.replay_end.isoformat() + "Z",
            "limit": 1000,
        }

        headers = {
            "Authorization": f"Bearer {TARDIS_API_KEY}",
            "Accept": "application/x-ndjson",
        }

        async with aiohttp.ClientSession() as session:
            async with session.get(url, params=params, headers=headers) as resp:
                if resp.status == 200:
                    data = await resp.text()
                    lines = data.strip().split("\n")
                    snapshots = [json.loads(line) for line in lines]
                    print(f"📸 Fetched {len(snapshots)} orderbook snapshots from OKX")
                    return snapshots
                else:
                    print(f"❌ HTTP Error: {resp.status}")
                    error_text = await resp.text()
                    print(f"   Details: {error_text[:200]}")
                    return []

    async def stream_live_replay(self):
        """WebSocket으로 Real-time + Historical Replay 스트리밍"""
        stream_id = f"okx:spot:{SYMBOL}:orderbook:100ms"
        from_ts = self.replay_start.strftime("%Y-%m-%dT%H:%M:%SZ")
        to_ts = self.replay_end.strftime("%Y-%m-%dT%H:%M:%SZ")

        uri = "wss://api.tardis.dev/v1/market-data/stream"

        headers = {"Authorization": f"Bearer {TARDIS_API_KEY}"}

        async with websockets.connect(uri, extra_headers=headers) as ws:
            # 구독 요청
            subscribe_msg = {
                "type": "subscribe",
                "stream": stream_id,
                "from": from_ts,
                "to": to_ts,
            }
            await ws.send(json.dumps(subscribe_msg))
            print(f"🔗 Subscribed to OKX {SYMBOL} orderbook replay")
            print(f"   From: {from_ts} | To: {to_ts}")

            message_count = 0
            async for raw_msg in ws:
                msg = json.loads(raw_msg)
                message_count += 1

                if msg.get("type") == "snapshot":
                    self._process_snapshot(msg)
                elif msg.get("type") == "delta":
                    self._process_delta(msg)
                elif msg.get("type") == "trade":
                    self.trade_count += 1
                    if self.trade_count % 100 == 0:
                        trade = msg["data"]
                        print(f"   💹 Trade #{self.trade_count}: {trade.get('price')} | {trade.get('side')} | {trade.get('size')}")

                # 100개 메시지마다 상태 보고
                if message_count % 100 == 0:
                    bid_keys = list(self.orderbook["bids"].keys())[:3]
                    ask_keys = list(self.orderbook["asks"].keys())[:3]
                    print(f"📊 [{message_count} msgs] Best Bid: {bid_keys[0] if bid_keys else 'N/A'} | Best Ask: {ask_keys[0] if ask_keys else 'N/A'}")

    def _process_snapshot(self, msg):
        """OKX Orderbook Snapshot 처리"""
        data = msg.get("data", {})
        self.orderbook["bids"] = {}
        self.orderbook["asks"] = {}

        bids = data.get("bids", [])
        asks = data.get("asks", [])

        for price, size in bids[:20]:  # 상위 20단계만
            self.orderbook["bids"][price] = float(size)

        for price, size in asks[:20]:
            self.orderbook["asks"][price] = float(size)

        best_bid = list(self.orderbook["bids"].keys())[0] if self.orderbook["bids"] else None
        best_ask = list(self.orderbook["asks"].keys())[0] if self.orderbook["asks"] else None

        if best_bid and best_ask:
            spread = (float(best_ask) - float(best_bid))
            spread_pct = (spread / float(best_bid)) * 100
            print(f"📸 Snapshot @ {msg.get('timestamp')} | Spread: {spread:.2f} USDT ({spread_pct:.4f}%)")

    def _process_delta(self, msg):
        """OKX Orderbook Delta 업데이트 처리"""
        data = msg.get("data", {})
        bids = data.get("bids", [])
        asks = data.get("asks", [])

        for price, size in bids:
            if float(size) == 0:
                self.orderbook["bids"].pop(price, None)
            else:
                self.orderbook["bids"][price] = float(size)

        for price, size in asks:
            if float(size) == 0:
                self.orderbook["asks"].pop(price, None)
            else:
                self.orderbook["asks"][price] = float(size)

async def main():
    replay = OKXOrderbookReplay()

    # 1단계: Historical Snapshot 먼저 조회
    print("=" * 60)
    print("Step 1: Fetching Historical Orderbook Snapshots via HTTP")
    print("=" * 60)
    snapshots = await replay.fetch_historical_orderbook()

    # 2단계: WebSocket으로 Orderbook Replay 스트리밍
    print("\n" + "=" * 60)
    print("Step 2: Starting Orderbook Replay via WebSocket")
    print("=" * 60)

    # 30초만 테스트
    try:
        await asyncio.wait_for(replay.stream_live_replay(), timeout=30.0)
    except asyncio.TimeoutError:
        print("\n⏹ Replay timeout (30s) — completed successfully")

    print(f"\n✅ Total trades processed: {replay.trade_count}")

if __name__ == "__main__":
    asyncio.run(main())

Bybit 주문형 회수(Replay) 튜토리얼


// tardis-bybit-replay.js
// Bybit Spot + Linear USDT Futures Orderbook + Trades Replay
const WebSocket = require('ws');

const TARDIS_API_KEY = process.env.TARDIS_API_KEY;

class BybitReplay {
  constructor(exchangeType = 'spot') {
    this.exchangeType = exchangeType; // 'spot' or 'linear'
    this.ws = null;
    this.trades = [];
    this.orderbook = { bids: {}, asks: {} };
  }

  startReplay(symbol, fromDate, toDate) {
    const wsUrl = 'wss://api.tardis.dev/v1/market-data/stream';

    this.ws = new WebSocket(wsUrl, {
      headers: { 'Authorization': Bearer ${TARDIS_API_KEY} }
    });

    this.ws.on('open', () => {
      console.log(🔗 Bybit ${this.exchangeType} WebSocket connected);

      // Bybit v5 API 스트림 형식
      const streamId = bybit:${this.exchangeType}:${symbol.toLowerCase()};

      // Orderbook 스트림 구독
      this.ws.send(JSON.stringify({
        type: 'subscribe',
        stream: ${streamId}:orderbook:200ms, // 200ms 주기
        from: fromDate,
        to: toDate,
      }));

      // Raw Trades 스트림 구독
      this.ws.send(JSON.stringify({
        type: 'subscribe',
        stream: ${streamId}:trades,
        from: fromDate,
        to: toDate,
      }));
    });

    this.ws.on('message', (data) => {
      const msg = JSON.parse(data.toString());
      this.handleMessage(msg);
    });

    this.ws.on('error', (err) => {
      console.error('❌ WebSocket error:', err.message);
    });
  }

  handleMessage(msg) {
    // Bybit v5 데이터 포맷 처리
    if (msg.exchange === 'bybit' && msg.type === 'snapshot') {
      const ob = msg.data;
      if (ob.b) { // Bybit bid structure: [[price, size, ...]]
        this.orderbook.bids = {};
        ob.b.slice(0, 25).forEach(([price, size]) => {
          this.orderbook.bids[price] = parseFloat(size);
        });
      }
      if (ob.a) { // Bybit ask structure
        this.orderbook.asks = {};
        ob.a.slice(0, 25).forEach(([price, size]) => {
          this.orderbook.asks[price] = parseFloat(size);
        });
      }

      const bestBid = Object.keys(this.orderbook.bids).sort((a, b) => parseFloat(b) - parseFloat(a))[0];
      const bestAsk = Object.keys(this.orderbook.asks).sort((a, b) => parseFloat(a) - parseFloat(b))[0];

      if (bestBid && bestAsk) {
        const spread = (parseFloat(bestAsk) - parseFloat(bestBid)).toFixed(8);
        const spreadPct = ((parseFloat(bestAsk) - parseFloat(bestBid)) / parseFloat(bestBid) * 100).toFixed(6);
        console.log(📋 OB Snapshot | Bid: ${bestBid} | Ask: ${bestAsk} | Spread: ${spread} (${spreadPct}%));
      }
    }

    // Orderbook Delta 업데이트
    if (msg.exchange === 'bybit' && msg.type === 'delta') {
      const ob = msg.data;

      if (ob.b) {
        ob.b.forEach(([price, size]) => {
          if (parseFloat(size) === 0) {
            delete this.orderbook.bids[price];
          } else {
            this.orderbook.bids[price] = parseFloat(size);
          }
        });
      }

      if (ob.a) {
        ob.a.forEach(([price, size]) => {
          if (parseFloat(size) === 0) {
            delete this.orderbook.asks[price];
          } else {
            this.orderbook.asks[price] = parseFloat(size);
          }
        });
      }
    }

    // Raw Trade 데이터 처리 (Bybit v5)
    if (msg.exchange === 'bybit' && msg.type === 'trade') {
      const trade = msg.data;
      this.trades.push({
        price: parseFloat(trade.p),
        amount: parseFloat(trade.s),
        side: trade.S,
        timestamp: new Date(trade.T).toISOString(),
        tradeId: trade.i,
      });

      if (this.trades.length % 50 === 0) {
        const latest = this.trades[this.trades.length - 1];
        const totalVolume = this.trades.slice(-50).reduce((sum, t) => sum + t.amount, 0);
        console.log(📈 Trades: ${this.trades.length} | Latest: ${latest.price} | Last 50 Vol: ${totalVolume.toFixed(4)});
      }
    }
  }

  stop() {
    if (this.ws) {
      this.ws.close();
      console.log(\n🔌 Disconnected. Total trades: ${this.trades.length});
    }
  }
}

// ===== 실행 예시 =====

// Bybit Spot BTC/USDT 1시간 회수
const spotReplay = new BybitReplay('spot');
spotReplay.startReplay(
  'BTCUSDT',
  '2026-01-01T00:00:00Z',
  '2026-01-01T01:00:00Z'
);

// 60초 후 자동 종료
setTimeout(() => {
  console.log('\n--- Spot Replay Complete ---');
  spotReplay.stop();

  // Bybit Linear USDT Futures 회수 예시
  console.log('\n--- Starting Linear Futures Replay ---');
  const linearReplay = new BybitReplay('linear');
  linearReplay.startReplay(
    'BTCUSDT',
    '2026-01-01T00:00:00Z',
    '2026-01-01T00:30:00Z'
  );

  setTimeout(() => {
    linearReplay.stop();
    process.exit(0);
  }, 60000);

}, 60000);

Python으로 대용량 Historical Dump 다운로드

백테스팅에 필요한 대규모 데이터를 한 번에 다운로드하려면 Parquet 포맷이 가장 효율적입니다. CSV 대비 저장 공간 70%, 읽기 속도 50% 이상 향상됩니다.



download_parquet.py


Binance Full Depth 데이터 Parquet 다운로드

import requests
import os
from datetime import datetime, timedelta

TARDIS_API_KEY = "YOUR_TARDIS_API_KEY"

def download_parquet_data(market, exchange, symbol, data_type, date_str):
    """
    Tardis.dev Parquet 파일 다운로드
    market: 'binance'
    exchange: 'spot' or 'futures'
    symbol: 'btcusdt'
    data_type: 'trades' or 'orderbook_snapshots' or 'orderbook_deltas'
    date_str: '2026-01-01'
    """
    base_url = "https://api.tardis.dev/v1/filtered"
    url = f"{base_url}/{market}/{exchange}/{symbol}/{data_type}"

    params = {
        "format": "parquet",  # Parquet 포맷 지정
        "date": date_str,
    }

    headers = {
        "Authorization": f"Bearer {TARDIS_API_KEY}",
    }

    print(f"📥 Downloading {market}/{exchange}/{symbol}/{data_type} - {date_str}")

    response = requests.get(url, params=params, headers=headers, stream=True, timeout=120)

    if response.status_code == 200:
        content_type = response.headers.get('Content-Type', '')

        if 'application/x-parquet' in content_type or 'application/octet-stream' in content_type:
            # Parquet 파일로 저장
            filename = f"{market}_{exchange}_{symbol}_{data_type}_{date_str}.parquet"
            filepath = os.path.join("data", filename)
            os.makedirs("data", exist_ok=True)

            with open(filepath, 'wb') as f:
                for chunk in response.iter_content(chunk_size=8192):
                    f.write(chunk)

            file_size = os.path.getsize(filepath)
            print(f"✅ Saved: {filepath} ({file_size / 1024 / 1024:.2f} MB)")

            # PyArrow로 Parquet 읽기
            try:
                import pyarrow.parquet as pq
                table = pq.read_table(filepath)
                print(f"   Rows: {table.num_rows:,} | Columns: {table.num_columns}")
                print(f"   Schema: {table.schema.names}")
            except ImportError:
                print("   ⚠️ Install pyarrow to read parquet: pip install pyarrow")

            return filepath
        elif 'application/x-ndjson' in content_type:
            print("   ⚠️ Server returned NDJSON. Checking available dates...")
            print(f"   Response preview: {response.text[:500]}")
            return None
        else:
            print(f"   ⚠️ Unexpected content type: {content_type}")
            print(f"   Preview: {response.text[:300]}")
            return None
    else:
        print(f"❌ HTTP {response.status_code}: {response.text[:300]}")
        return None


===== 배치 다운로드 예시 =====

if __name__ == "__main__":
    # Binance Spot BTC/USDT 7일치 거래 데이터 다운로드
    start_date = datetime(2026, 1, 1)
    downloaded = []

    for i in range(7):
        date = (start_date + timedelta(days=i)).strftime("%Y-%m-%d")
        filepath = download_parquet_data(
            market='binance',
            exchange='spot',
            symbol='btcusdt',
            data_type='trades',
            date_str=date
        )
        if filepath:
            downloaded.append(filepath)

    print(f"\n📦 Downloaded {len(downloaded)} files")
    print("   Ready for batch backtesting!")

실전 활용: 슬리피지(Slippage) 분석 파이프라인

저는 실제 백테스팅 시스템에서 Tardis.dev Raw Trades 데이터를 활용하여 슬리피지 분석 파이프라인을 구축한 경험이 있습니다. 다음은 Binance Futures 데이터를 활용한 거래 실행 품질 측정 파이프라인의 핵심 코드입니다.



slippage_analysis.py


Binance Futures Raw Trades 기반 슬리피지 분석

import pyarrow.parquet as pq
import pandas as pd
import numpy as np
from collections import defaultdict

class SlippageAnalyzer:
    def __init__(self, parquet_dir):
        self.parquet_dir = parquet_dir
        self.trades = []

    def load_trades(self, filename):
        """Parquet 파일에서 Raw Trades 로드"""
        table = pq.read_table(f"{self.parquet_dir}/{filename}")
        df = table.to_pandas()
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
        df = df.sort

관련 리소스
관련 문서