암호화폐 옵션 거래에서 오더북(호가창) 데이터는 시장 깊이, 유동성, 그리고 잠재적 가격 변동을 분석하는 핵심 요소입니다. Deribit는 업계 최대 규모의 BTC·ETH 옵션 거래량을 자랑하며, 그 실시간·히스토리컬 오더북 데이터는 퀀트 트레이딩 및 리스크 관리 시스템에서 필수적인 자원입니다.

본 가이드에서는 Deribit 옵션 오더북 히스토리컬 스냅샷 API를 HolySheep AI 게이트웨이를 통해 안전하고 효율적으로 연동하는 방법을 단계별로 설명합니다. HolySheep AI는 지금 가입 시 무료 크레딧을 제공하며, 단일 API 키로 글로벌 AI 모델과 외부金融市场 데이터 파이프라인을 통합 관리할 수 있습니다.

Deribit 옵션 오더북 API 개요

Deribit는 Bitcoin, Ethereum 옵션 및 선물에 대한 REST API와 WebSocket API를 제공합니다. 오더북 관련 주요 엔드포인트는 다음과 같습니다:

Deribit API의 기본 엔드포인트 구조는 다음과 같습니다:

# Deribit API 기본 설정
BASE_URL = "https://www.deribit.com/api/v2"


히스토리컬 스냅샷 조회 (deribit API 직접 호출)


이 데이터는 HolySheep AI로 분석 파이프라인에 연결 가능


import requests
import time
from datetime import datetime

class DeribitOptionsClient:
    def __init__(self, client_id: str, client_secret: str):
        self.client_id = client_id
        self.client_secret = client_secret
        self.access_token = None
        self.token_expires = 0
    
    def authenticate(self) -> dict:
        """OAuth2 클라이언트 크리덴셜 플로우로 인증"""
        auth_url = f"{BASE_URL}/public/auth"
        payload = {
            "grant_type": "client_credentials",
            "client_id": self.client_id,
            "client_secret": self.client_secret
        }
        response = requests.post(auth_url, data=payload, timeout=30)
        response.raise_for_status()
        result = response.json()
        
        if result.get("success"):
            self.access_token = result["result"]["access_token"]
            self.token_expires = time.time() + result["result"]["expires_in"]
            print(f"✓ Deribit 인증 성공: 토큰 만료 {result['result']['expires_in']}초")
        return result
    
    def get_order_book_snapshot(self, instrument_name: str, depth: int = 10) -> dict:
        """옵션 오더북 스냅샷 조회"""
        if not self.access_token or time.time() >= self.token_expires - 60:
            self.authenticate()
        
        url = f"{BASE_URL}/private/get_order_book_by_instrument_id"
        headers = {"Authorization": f"Bearer {self.access_token}"}
        params = {
            "instrument_name": instrument_name,
            "depth": depth
        }
        
        response = requests.get(url, headers=headers, params=params, timeout=30)
        response.raise_for_status()
        result = response.json()
        
        if result.get("success"):
            return result["result"]
        raise ValueError(f"오더북 조회 실패: {result}")
    
    def get_historical_snapshots(self, instrument_name: str, start_timestamp: int, 
                                  end_timestamp: int) -> list:
        """히스토리컬 스냅샷 조회 (캔들베이스)"""
        if not self.access_token or time.time() >= self.token_expires - 60:
            self.authenticate()
        
        url = f"{BASE_URL}/private/get_order_book_snapshot_by_time"
        headers = {"Authorization": f"Bearer {self.access_token}"}
        params = {
            "instrument_name": instrument_name,
            "start_timestamp": start_timestamp,
            "end_timestamp": end_timestamp,
            "resolution": 60  # 1분 단위
        }
        
        response = requests.get(url, headers=headers, params=params, timeout=30)
        response.raise_for_status()
        return response.json().get("result", [])


사용 예시

client = DeribitOptionsClient(
    client_id="YOUR_DERIBIT_CLIENT_ID",
    client_secret="YOUR_DERIBIT_CLIENT_SECRET"
)


BTC 옵션 오더북 조회 예시

instrument = "BTC-29DEC23-40000-C"  # BTC 만기 12/29, 행사가 40000, Call
snapshot = client.get_order_book_snapshot(instrument, depth=20)
print(f"호가창 깊이: {len(snapshot.get('bids', []))} bids / {len(snapshot.get('asks', []))} asks")

HolySheep AI 통합: 옵션 데이터 AI 분석 파이프라인

Deribit에서 수집한 오더북 데이터를 HolySheep AI 게이트웨이를 통해 AI 모델로 분석하면, 시장 미세구조 패턴 인식, 변동성 표면 분석, 그리이스 감도(Greeks) 예측 등을 자동화할 수 있습니다.

import requests
import json
from typing import List, Dict, Optional

class DeribitOptionsAnalyzer:
    """
    Deribit 옵션 오더북 + HolySheep AI 분석 통합 클래스
    HolySheep AI: https://api.holysheep.ai/v1
    """
    
    def __init__(self, deribit_client: 'DeribitOptionsClient', 
                 holy_api_key: str):
        self.deribit = deribit_client
        self.holy_api_key = holy_api_key
        self.holy_base_url = "https://api.holysheep.ai/v1"
    
    def analyze_orderbook_with_ai(self, snapshot: dict, 
                                   model: str = "gpt-4.1") -> str:
        """
        HolySheep AI를 통해 오더북 데이터 패턴 분석
        Deribit 옵션 호가창의 유동성 공급/수요 균형 평가
        """
        # Deribit 오더북 데이터를 분석 가능한 텍스트로 변환
        bids = snapshot.get("bids", [])
        asks = snapshot.get("asks", [])
        
        bid_prices = [float(b[0]) for b in bids[:5]]
        ask_prices = [float(a[0]) for a in asks[:5]]
        bid_sizes = [float(b[1]) for b in bids[:5]]
        ask_sizes = [float(a[1]) for a in asks[:5]]
        
        spread = ask_prices[0] - bid_prices[0] if ask_prices and bid_prices else 0
        spread_pct = (spread / bid_prices[0] * 100) if bid_prices else 0
        
        analysis_prompt = f"""Deribit BTC 옵션 오더북 분석 리포트:

호가창 스프레드: {spread:.2f} ({spread_pct:.3f}%)
최우선 매수호가 5단계: {bid_prices}
최우선 매도호가 5단계: {ask_prices}
매수 수량 (BTC): {bid_sizes}
매도 수량 (BTC): {ask_sizes}
총 매수 유동성: {sum(bid_sizes):.4f} BTC
총 매도 유流动性: {sum(ask_sizes):.4f} BTC
시장 심화 지표: {'매수 우위' if sum(bid_sizes) > sum(ask_sizes) else '매도 우위'}

다음 분석을 제공해주세요:
1. 유동성 불균형 분석 및 시장 심화 판단
2. 행사가 주변 미결제약정(Premium) 추청
3. 단기 시장 방향성 리스크 평가
4. 스프레드 해석 및 거래 비용 영향"""

        # HolySheep AI API 호출
        headers = {
            "Authorization": f"Bearer {self.holy_api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": [
                {
                    "role": "system",
                    "content": "당신은 암호화폐 옵션 시장 분석 전문가입니다. Deribit 시장 데이터를 기반으로 실용적인 거래 인사이트를 제공합니다."
                },
                {
                    "role": "user", 
                    "content": analysis_prompt
                }
            ],
            "temperature": 0.3,
            "max_tokens": 800
        }
        
        response = requests.post(
            f"{self.holy_base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=60
        )
        
        if response.status_code == 200:
            result = response.json()
            return result["choices"][0]["message"]["content"]
        else:
            raise RuntimeError(f"HolySheep API 오류: {response.status_code} - {response.text}")
    
    def batch_analyze_snapshots(self, snapshots: List[dict], 
                                 instruments: List[str]) -> List[Dict]:
        """
        다중 오더북 스냅샷 배치 분석
        포트폴리오 레벨 옵션 노출 평가
        """
        results = []
        
        for i, snapshot in enumerate(snapshots):
            instrument = instruments[i] if i < len(instruments) else f"UNKNOWN-{i}"
            
            try:
                analysis = self.analyze_orderbook_with_ai(snapshot)
                results.append({
                    "instrument": instrument,
                    "timestamp": snapshot.get("timestamp", "N/A"),
                    "analysis": analysis,
                    "status": "success"
                })
                print(f"✓ {instrument} 분석 완료")
            except Exception as e:
                results.append({
                    "instrument": instrument,
                    "error": str(e),
                    "status": "failed"
                })
                print(f"✗ {instrument} 분석 실패: {e}")
        
        return results
    
    def generate_portfolio_risk_summary(self, analyses: List[dict]) -> str:
        """HolySheep AI로 포트폴리오 전체 리스크 요약 생성"""
        
        summary_prompt = f"""다음 Deribit 옵션 포트폴리오 분석 결과를 종합하여 리스크 보고서를 작성해주세요:

{json.dumps(analyses, indent=2, ensure_ascii=False)}

리포트 포함 사항:
1. 전체 노출(Net Exposure) 요약
2. 주요 리스크 집중 영역
3. Greeks 균형 평가 (Delta, Gamma, Vega, Theta)
4. 권장 헤지 전략"""

        headers = {
            "Authorization": f"Bearer {self.holy_api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": "claude-sonnet-4.5",
            "messages": [{"role": "user", "content": summary_prompt}],
            "temperature": 0.2,
            "max_tokens": 1200
        }
        
        response = requests.post(
            f"{self.holy_base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=90
        )
        
        if response.status_code == 200:
            return response.json()["choices"][0]["message"]["content"]
        raise RuntimeError(f"리스크 요약 생성 실패: {response.text}")


HolySheep AI 키로 초기화

analyzer = DeribitOptionsAnalyzer(
    deribit_client=client,
    holy_api_key="YOUR_HOLYSHEEP_API_KEY"
)


단일 오더북 분석

snapshot = client.get_order_book_snapshot("BTC-29DEC23-40000-C", depth=20)
analysis = analyzer.analyze_orderbook_with_ai(snapshot)
print(analysis)

Deribit vs 경쟁 거래소 API 비교

비교 항목DeribitOKX OptionsBybit OptionsFTX (단종)
BTC 옵션 일간 거래량$2B+$500M$300M-
히스토리컬 스냅샷 제공✓ 최대 90일✓ 최대 30일✓ 최대 14일-
REST API 속도 (P99)~80ms~120ms~100ms-
WebSocket 실시간✓ 50ms 내✓ 80ms✓ 60ms-
옵션 Greeks 데이터✓ IV 포함✓ IV 포함✓ IV 포함-
API 레이트 리밋20 req/s10 req/s10 req/s-
개발자 문서 품질우수양호양호-
HolySheep 연동 지원✓ Python SDK△ 수동△ 수동-

평가: Deribit는 암호화폐 옵션 시장에서 압도적인流動성 점유율을 보유하며, 히스토리컬 스냅샷 데이터의 깊이와 API 안정성 측면에서 경쟁사를 앞서고 있습니다. 특히 만기일, 행사가 조합이 다양하고(spreads), 내재변동성(iv) 데이터가 실시간으로 제공되어 퀀트 전략 개발에 최적화된 환경을 제공합니다.

Deribit API 데이터 구조 상세 분석

옵션 오더북 스냅샷의 핵심 필드와 활용 방안을 설명드리겠습니다:

{
  "instrument_name": "BTC-29DEC23-40000-C",
  "settlement_price": 0.058,        // 결제 가격 (BTC)
  "underlying_price": 42000.50,     // 현물 BTC 가격
  "underlying_index": "btc",        // 기반 자산
  "state": "open",                  // 계약 상태
  
  "bids": [                         // 매수 호가
    [42000.00, 2.5],               // [가격, 수량(BTC)]
    [41950.00, 1.8],
    [41900.00, 3.2]
  ],
  
  "asks": [                         // 매도 호가
    [42100.00, 2.1],
    [42150.00, 1.5],
    [42200.00, 2.8]
  ],
  
  "greeks": {
    "delta": 0.52,
    "gamma": 0.0023,
    "vega": 0.045,
    "theta": -0.0012
  },
  
  "mark_price": 0.056,             // 중립 가격
  "best_bid_price": 0.054,
  "best_ask_price": 0.058,
  "best_bid_amount": 10.5,
  "best_ask_amount": 8.2
}


오더북 깊이 데이터 계산 예시

def calculate_market_depth(order_book: dict, levels: int = 5) -> dict:
    """시장 깊이 지표 계산"""
    bids = order_book.get("bids", [])
    asks = order_book.get("asks", [])
    
    bid_volume = sum(float(b[1]) for b in bids[:levels])
    ask_volume = sum(float(a[1]) for a in asks[:levels])
    
    bid_notional = sum(float(b[0]) * float(b[1]) for b in bids[:levels])
    ask_notional = sum(float(a[0]) * float(a[1]) for a in asks[:levels])
    
    spread = float(asks[0][0]) - float(bids[0][0]) if asks and bids else 0
    mid_price = (float(asks[0][0]) + float(bids[0][0])) / 2 if asks and bids else 0
    
    return {
        "bid_volume_btc": bid_volume,
        "ask_volume_btc": ask_volume,
        "bid_notional_usd": bid_notional,
        "ask_notional_usd": ask_notional,
        "volume_imbalance": (bid_volume - ask_volume) / (bid_volume + ask_volume + 1e-9),
        "spread_bps": spread / mid_price * 10000 if mid_price else 0,
        "mid_price": mid_price
    }

depth = calculate_market_depth(snapshot)
print(f"호가창 불균형: {depth['volume_imbalance']:.3f}")
print(f"스프레드: {depth['spread_bps']:.1f} bps")

이런 팀에 적합 / 비적합

✓ 이런 팀에 적합

✗ 이런 팀에는 비적합

가격과 ROI

비용 항목DeribitHolySheep AI총 비용估算
API 사용료무료 (기본)GPT-4.1: $8/MTok$0 ~ $50/월
거래 수수료 (Maker)0.02%-거래량 기반
거래 수수료 (Taker)0.05%-거래량 기반
데이터 스토리지 (S3)-$0.023/GB$5~20/월
분석 API 호출 비용-$0.15/anal分析$30~500/월
월간 총 예상 비용거래량 기반$50~600$100~$1,200+

ROI 분석: Deribit 옵션에서 하루 $100K 거래하는 팀을 기준으로, HolySheep AI 분석 시스템 도입 시:

왜 HolySheep AI를 선택해야 하나

Deribit 옵션 API 연동에 HolySheep AI를 활용하면 다음과 같은 차별화된 가치를 얻을 수 있습니다:

  1. 단일 통합 게이트웨이: Deribit 데이터 + GPT-4.1/Claude 분석을 하나의 API 키로 관리. 별도의 AI API 계정 유지 불필요
  2. 비용 최적화: DeepSeek V3.2 ($0.42/MTok)로 대량 데이터 분석 가능. 지금 가입 시 무료 크레딧 제공
  3. 해외 신용카드 불필요: 국내 은행转账/간편결제 지원으로 Deribit USD 입금 및 HolySheep 결제 동시에 해결
  4. 낮은 지연 시간: HolySheep API 응답 시간 P95 기준 800ms 내외. 배치 분석 워크플로우에 적합
  5. 다중 모델 지원: GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash 등 목적에 따라 모델 교체 가능

HolySheep AI는 전 세계 50+ 국가의 개발자들이 사용하는 글로벌 AI 게이트웨이이며, Deribit를 포함한 주요 암호화폐 거래소 API와의 연동을 지속적으로 확장하고 있습니다.

Deribit API 연동 체크리스트

자주 발생하는 오류와 해결

1. Deribit 인증 토큰 만료 (401 Unauthorized)

# 오류 메시지: {"success": false, "message": "Invalid token"}

원인: OAuth 토큰 기본 만료시간 15분



해결: 토큰 만료 60초 전에 자동갱신

class DeribitClient:
    def __init__(self, client_id, client_secret):
        self.client_id = client_id
        self.client_secret = client_secret
        self.access_token = None
        self.token_expires_at = 0
    
    def get_valid_token(self) -> str:
        """토큰 유효성 검사 및 갱신"""
        if not self.access_token or time.time() >= self.token_expires_at - 60:
            self.authenticate()
        return self.access_token
    
    def authenticate(self):
        """토큰 갱신 로직"""
        url = "https://www.deribit.com/api/v2/public/auth"
        response = requests.post(url, data={
            "grant_type": "client_credentials",
            "client_id": self.client_id,
            "client_secret": self.client_secret
        })
        result = response.json()
        
        if result.get("success"):
            self.access_token = result["result"]["access_token"]
            expires_in = result["result"]["expires_in"]
            self.token_expires_at = time.time() + expires_in
            print(f"토큰 갱신 완료. {expires_in}초 후 만료")
        else:
            raise ConnectionError(f"인증 실패: {result.get('message')}")
    
    def api_call(self, endpoint, params=None):
        """모든 API 호출에 토큰 자동갱신 적용"""
        headers = {
            "Authorization": f"Bearer {self.get_valid_token()}"
        }
        url = f"https://www.deribit.com/api/v2{endpoint}"
        response = requests.get(url, headers=headers, params=params, timeout=30)
        
        if response.status_code == 401:
            # 토큰 만료 시 한 번 재시도
            self.authenticate()
            headers["Authorization"] = f"Bearer {self.access_token}"
            response = requests.get(url, headers=headers, params=params, timeout=30)
        
        return response.json()

2. Rate Limit 초과 (429 Too Many Requests)

# 오류 메시지: {"success": false, "message": "Too many requests"}

해결:指數バックオフ(지수 백오프)로 재시도 구현


import time
import random
from ratelimit import limits, sleep_and_retry

class RateLimitedClient:
    def __init__(self, client: DeribitClient):
        self.client = client
        self.calls = 0
        self.window_start = time.time()
        self.max_calls = 18  # 안전 마진 10%
        self.window_seconds = 1.0
    
    def throttled_call(self, endpoint, params=None, max_retries=5):
        """레이트 리밋이 적용된 API 호출"""
        for attempt in range(max_retries):
            # 윈도우 리셋 체크
            if time.time() - self.window_start >= self.window_seconds:
                self.calls = 0
                self.window_start = time.time()
            
            # 레이트 리밋 체크
            if self.calls >= self.max_calls:
                wait_time = self.window_seconds - (time.time() - self.window_start)
                wait_time = max(0.1, wait_time + random.uniform(0.1, 0.3))
                print(f"Rate limit 근접. {wait_time:.2f}초 대기...")
                time.sleep(wait_time)
                self.calls = 0
                self.window_start = time.time()
            
            try:
                self.calls += 1
                result = self.client.api_call(endpoint, params)
                
                if result.get("success"):
                    return result
                elif "Too many requests" in str(result):
                    raise RateLimitError("Rate limit exceeded")
                else:
                    return result
                    
            except RateLimitError as e:
                if attempt < max_retries - 1:
                    # 지수 백오프: 1초, 2초, 4초, 8초...
                    backoff = (2 ** attempt) + random.uniform(0, 1)
                    print(f"재시도 {attempt + 1}/{max_retries}: {backoff:.1f}초 후")
                    time.sleep(backoff)
                else:
                    raise
        
        raise RuntimeError(f"최대 재시도 횟수 초과: {max_retries}")


사용 예시

client = DeribitClient(client_id, client_secret)
limited_client = RateLimitedClient(client)
result = limited_client.throttled_call(
    "/private/get_order_book_by_instrument_id",
    {"instrument_name": "BTC-29DEC23-40000-C", "depth": 10}
)

3. HolySheep AI API 호출 시 400/401/429 오류

# HolySheep AI API 일반적 오류 처리

def call_holy_sheep(model: str, messages: list, max_retries: int = 3) -> str:
    """HolySheep AI API 안전한 호출 래퍼"""
    import os
    
    api_key = os.environ.get("HOLYSHEEP_API_KEY")
    if not api_key:
        raise ValueError("HOLYSHEEP_API_KEY 환경변수 설정 필요")
    
    base_url = "https://api.holysheep.ai/v1"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": model,
        "messages": messages,
        "temperature": 0.3,
        "max_tokens": 1000
    }
    
    for attempt in range(max_retries):
        try:
            response = requests.post(
                f"{base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=60
            )
            
            if response.status_code == 200:
                return response.json()["choices"][0]["message"]["content"]
            
            elif response.status_code == 400:
                error_detail = response.json()
                raise ValueError(f"잘못된 요청: {error_detail}")
            
            elif response.status_code == 401:
                raise PermissionError("API 키 확인 필요: https://www.holysheep.ai/register")
            
            elif response.status_code == 429:
                # Rate limit: 60초 대기
                retry_after = int(response.headers.get("Retry-After", 60))
                print(f"Rate limit. {retry_after}초 대기...")
                time.sleep(retry_after)
                continue
            
            else:
                raise RuntimeError(f"API 오류 {response.status_code}: {response.text}")
                
        except requests.exceptions.Timeout:
            if attempt < max_retries - 1:
                wait = 2 ** attempt
                print(f"타임아웃. {wait}초 후 재시도...")
                time.sleep(wait)
            else:
                raise
        
        except requests.exceptions.ConnectionError:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
                continue
            else:
                raise ConnectionError("HolySheep AI 서버 연결 실패. 네트워크 확인 필요")
    
    raise RuntimeError("최대 재시도 횟수 초과")


검증된 모델 목록

AVAILABLE_MODELS = {
    "gpt-4.1": {"price_per_mtok": 8.00, "context": 128000},
    "claude-sonnet-4.5": {"price_per_mtok": 15.00, "context": 200000},
    "gemini-2.5-flash": {"price_per_mtok": 2.50, "context": 1000000},
    "deepseek-v3.2": {"price_per_mtok": 0.42, "context": 64000}
}


배치 분석 시 비용 최적화

def optimized_batch_analysis(orderbooks: list) -> list:
    """비용 최적화를 위한 모델 선택 로직"""
    results = []
    
    for ob in orderbooks:
        # 단순 구조 분석: DeepSeek V3.2 (저렴)
        if len(ob.get("bids", [])) < 10:
            model = "deepseek-v3.2"
        # 복잡한 패턴 분석: GPT-4.1 (고성능)
        elif "greeks" in ob:
            model = "gpt-4.1"
        # 일반 분석: Claude Sonnet (균형)
        else:
            model = "claude-sonnet-4.5"
        
        result = call_holy_sheep(model, [
            {"role": "user", "content": f"오더북 분석: {ob}"}
        ])
        results.append({"model_used": model, "analysis": result})
    
    return results

4. Deribit 히스토리컬 스냅샷 데이터 갭

# 히스토리컬 데이터 연속성 보장 로직

def get_continuous_snapshots(client, instrument: str, 
                              start_ts: int, end_ts: int,
                              chunk_hours: int = 6) -> list:
    """
    히스토리컬 스냅샷을 여러 청크로 나누어 조회
    - Deribit 기본 제한: 최대 7일 범위
    - 해결: 6시간 단위 청크로 분할
    """
    all_snapshots = []
    current_ts = start_ts
    chunk_ms = chunk_hours * 60 * 60 * 1000
    
    while current_ts < end_ts:
        chunk_end = min(current_ts + chunk_ms, end_ts)
        
        try:
            snapshots = client.get_historical_snapshots(
                instrument,
                start_timestamp=current_ts,
                end_timestamp=chunk_end
            )
            
            if snapshots:
                all_snapshots.extend(snapshots)
                print(f"✓ {len(snapshots)}개 스냅샷 수집 ({len(all_snapshots)} 총합)")
            else:
                print(f"⚠ 데이터 갭 감지: {current_ts} ~ {chunk_end}")
            
            current_ts = chunk_end
            
        except Exception as e:
            if "timestamp" in str(e).lower():
                # 타임스탬프 범위 오류 시 1시간 감소 후 재시도
                current_ts += (chunk_ms - 3600000)
                print(f"범위 조정 후 재시도...")
            else:
                raise
        
        time.sleep(0.5)  # Rate limit 보호
    
    # 타임스탬프 기준 정렬
    all_snapshots.sort(key=lambda x: x.get("timestamp", 0))
    
    return all_snapshots


결측 데이터 보간

def interpolate_gaps(snapshots: list, expected_interval_ms: int = 60000) -> list:
    """결측 타임스탬프 보간"""
    if len(snapshots) < 2:
        return snapshots
    
    filled = [snapshots[0]]
    
    for i in range(1, len(snapshots)):
        prev_ts = filled[-1]["timestamp"]
        curr_ts = snapshots[i]["timestamp"]
        gap = (curr_ts - prev_ts) / expected_interval_ms

관련 리소스
관련 문서