การทำ backtest ข้อมูล Options จาก Deribit เป็นงานที่ซับซ้อนสำหรับนักพัฒนาระบบเทรด โดยเฉพาะอย่างยิ่งเมื่อต้อง parse field จาก Tardis.dev API ให้ถูกต้อง บทความนี้จะอธิบายวิธีการดึงข้อมูล orderbook ของ Deribit options ผ่าน Tardis.dev แบบ step-by-step พร้อมตัวอย่างโค้ดที่ใช้งานได้จริง

Tardis.dev API คืออะไร และทำไมต้องใช้กับ Deribit

Tardis.dev เป็นบริการที่รวบรวม historical market data จาก exchanges ยอดนิยม รวมถึง Deribit ซึ่งเป็นแพลตฟอร์มเทรด crypto derivatives ที่ใหญ่ที่สุดสำหรับ Options ข้อมูล orderbook จาก Deribit มีความละเอียดสูงมาก เหมาะสำหรับ:

ตารางเปรียบเทียบบริการ API สำหรับ Deribit Market Data

บริการ ราคา/เดือน Latency Historical Data WebSocket Support ภาษาไทย
HolySheep AI $0.42 - $15 <50ms ✅ มี ✅ รองรับ รวดเร็ว ✅ มี
Tardis.dev $50 - $500 ~100ms ✅ มี ✅ รองรับ อีเมล ❌ ไม่มี
CoinAPI $75 - $500 ~150ms ✅ มี ✅ รองรับ ตั๋ว ❌ ไม่มี
CCAvenue $200+ ~200ms ✅ มี จำกัด ช้า ❌ ไม่มี
DIY (Direct) $0 (ค่า infrastructure) ~30ms ❌ ต้องเก็บเอง ✅ รองรับ ตนเอง ❌ ไม่มี

เหมาะกับใคร / ไม่เหมาะกับใคร

✅ เหมาะกับใคร

❌ ไม่เหมาะกับใคร

ราคาและ ROI

เมื่อเปรียบเทียบกับการใช้ Tardis.dev โดยตรง การใช้ HolySheep AI สามารถประหยัดได้มากกว่า 85%:

ROI Calculation: หากคุณประหยัด $492/เดือน ลงทุนคืนภายในวันแรกที่ใช้งาน

ทำไมต้องเลือก HolySheep

การตั้งค่า Environment และติดตั้ง Dependencies

ก่อนเริ่มต้น คุณต้องมี API key จาก Tardis.dev และติดตั้ง libraries ที่จำเป็น:

# สร้าง virtual environment
python -m venv tardis-env
source tardis-env/bin/activate  # Windows: tardis-env\Scripts\activate


ติดตั้ง dependencies

pip install tardis-client aiohttp pandas numpy pytz


หรือใช้ Poetry

poetry add tardis-client aiohttp pandas numpy pytz

โครงสร้างข้อมูล Deribit Options Orderbook

ข้อมูล orderbook จาก Deribit มีโครงสร้างที่ซับซ้อน โดยเฉพาะ Options contracts:

import asyncio
import aiohttp
import pandas as pd
from datetime import datetime

async def fetch_deribit_orderbook(
    symbol: str = "BTC-28MAR25-95000-C",  # BTC Call Option
    from_ts: int = 1704067200000,  # 2024-01-01 00:00:00 UTC
    to_ts: int = 1706745599000     # 2024-01-31 23:59:59 UTC
):
    """
    Fetch Deribit options orderbook data from Tardis.dev API
    
    ตัวอย่าง symbol format สำหรับ Deribit options:
    - BTC-28MAR25-95000-C  (Call Option, strike 95000)
    - ETH-28MAR25-3500-P   (Put Option, strike 3500)
    - BTC-29DEC23-100000-C (สัญญาที่หมดอายุแล้ว)
    """
    
    TARDIS_API_KEY = "your_tardis_api_key_here"
    
    url = f"https://api.tardis.dev/v1/derivatives/deribit/orderbook"
    
    params = {
        "symbol": symbol,
        "from": from_ts,
        "to": to_ts,
        "limit": 1000,  # จำนวน records ต่อ request
        "format": "object"  # รูปแบบ: "object" หรือ "array"
    }
    
    headers = {
        "Authorization": f"Bearer {TARDIS_API_KEY}"
    }
    
    async with aiohttp.ClientSession() as session:
        async with session.get(url, params=params, headers=headers) as response:
            if response.status == 200:
                data = await response.json()
                return parse_orderbook_response(data)
            else:
                print(f"Error: {response.status}")
                return None

def parse_orderbook_response(data: dict) -> pd.DataFrame:
    """
    Parse Tardis.dev orderbook response เป็น DataFrame
    """
    
    records = []
    
    # Tardis.dev ส่งข้อมูลเป็น array ของ timestamps
    for timestamp, snapshot in data.get("data", []).items():
        record = {
            "timestamp_ms": int(timestamp),
            "timestamp": datetime.fromtimestamp(int(timestamp) / 1000),
            
            # Bids: ราคาซื้อ (ผู้ซื้อตั้งราคา)
            "best_bid_price": snapshot.get("b", [[None, None]])[0][0],
            "best_bid_amount": snapshot.get("b", [[None, None]])[0][1],
            
            # Asks: ราคาขาย (ผู้ขายตั้งราคา)
            "best_ask_price": snapshot.get("a", [[None, None]])[0][0],
            "best_ask_amount": snapshot.get("a", [[None, None]])[0][1],
            
            # Settlement price (สำคัญมากสำหรับ options)
            "settlement_price": snapshot.get("settlement_price"),
            
            # Open Interest
            "open_interest": snapshot.get("open_interest"),
            
            # Mark Price (ราคาเฉลี่ย bid/ask)
            "mark_price": snapshot.get("mark_price"),
            
            # Underlying price
            "underlying_price": snapshot.get("underlying_price"),
            
            # Greeks (สำหรับ options)
            "greeks_delta": snapshot.get("greeks", {}).get("delta"),
            "greeks_gamma": snapshot.get("greeks", {}).get("gamma"),
            "greeks_theta": snapshot.get("greeks", {}).get("theta"),
            "greeks_vega": snapshot.get("greeks", {}).get("vega"),
            
            # IV (Implied Volatility)
            "best_bid_iv": snapshot.get("best_bid_iv"),
            "best_ask_iv": snapshot.get("best_ask_iv"),
        }
        
        # คำนวณ bid-ask spread
        if record["best_bid_price"] and record["best_ask_price"]:
            record["spread"] = record["best_ask_price"] - record["best_bid_price"]
            record["spread_pct"] = (record["spread"] / record["best_ask_price"]) * 100
        
        records.append(record)
    
    df = pd.DataFrame(records)
    return df


ตัวอย่างการใช้งาน

if __name__ == "__main__":
    df = asyncio.run(fetch_deribit_orderbook(
        symbol="BTC-28MAR25-95000-C"
    ))
    
    if df is not None:
        print(f"✅ ดึงข้อมูลสำเร็จ: {len(df)} records")
        print(df.head())

การ Parse Fields ที่สำคัญสำหรับ Backtesting

สำหรับการทำ backtest กลยุทธ์ Options คุณต้องเข้าใจ field เหล่านี้อย่างลึกซึ้ง:

import numpy as np
from typing import List, Tuple

class DeribitOptionsBacktester:
    """
    Backtester สำหรับ Deribit Options โดยใช้ Tardis.dev data
    
    กลยุทธ์ที่รองรับ:
    1. Long Call/Put
    2. Covered Call
    3. Bull Spread / Bear Spread
    4. Straddle / Strangle
    5. Iron Condor
    """
    
    def __init__(self, data: pd.DataFrame, initial_capital: float = 100000):
        self.data = data.sort_values("timestamp").reset_index(drop=True)
        self.initial_capital = initial_capital
        self.capital = initial_capital
        self.positions = []
        self.trades = []
        
    def calculate_pnl(
        self, 
        entry_price: float, 
        exit_price: float, 
        position_size: int,
        is_long: bool = True,
        contract_type: str = "call"
    ) -> float:
        """
        คำนวณ PnL สำหรับ options position
        
        Parameters:
        - entry_price: ราคาเข้า position (USD)
        - exit_price: ราคาออก position (USD)
        - position_size: จำนวน contracts (1 contract = 1 BTC สำหรับ BTC options)
        - is_long: True = Long, False = Short
        - contract_type: "call" หรือ "put"
        """
        
        multiplier = 1 if is_long else -1
        
        if contract_type == "call":
            pnl = (exit_price - entry_price) * multiplier * position_size
        else:  # put
            pnl = (entry_price - exit_price) * multiplier * position_size
            
        return pnl
    
    def calculate_greeks_exposure(
        self,
        delta: float,
        gamma: float,
        theta: float,
        vega: float,
        position_size: int
    ) -> dict:
        """
        คำนวณ Greeks exposure ของ portfolio
        
        Greeks จาก Deribit orderbook:
        - delta: ความไวของราคา options ต่อราคา underlying
        - gamma: ความไวของ delta ต่อราคา underlying
        - theta: การลดลงของมูลค่า options ต่อวัน (time decay)
        - vega: ความไวของราคา options ต่อ implied volatility
        """
        
        return {
            "delta_exposure": delta * position_size,
            "gamma_exposure": gamma * position_size,
            "theta_exposure": theta * position_size,  # ค่าลบ = สูญเสียจาก time decay
            "vega_exposure": vega * position_size    # ความเสี่ยงจาก IV change
        }
    
    def backtest_long_call(
        self, 
        entry_time: pd.Timestamp, 
        exit_time: pd.Timestamp,
        strike: float,
        premium: float,
        position_size: int = 1
    ) -> dict:
        """
        Backtest Long Call strategy
        
        กลยุทธ์: ซื้อ Call option เมื่อคาดว่าราคา BTC จะขึ้น
        Max Loss: premium ที่จ่าย
        Max Profit: Unlimited
        """
        
        entry_data = self.data[self.data["timestamp"] >= entry_time].iloc[0]
        exit_data = self.data[self.data["timestamp"] >= exit_time].iloc[0]
        
        # ตรวจสอบว่า underlying price > strike หรือไม่
        underlying_exit = exit_data["underlying_price"]
        
        # คำนวณ intrinsic value ที่ expiry
        if underlying_exit > strike:
            exit_price = underlying_exit - strike  # In-the-money
        else:
            exit_price = 0  # Out-of-the-money (expires worthless)
        
        entry_cost = premium * position_size
        pnl = self.calculate_pnl(
            entry_price=premium,
            exit_price=exit_price,
            position_size=position_size,
            is_long=True,
            contract_type="call"
        )
        
        # คำนวณ ROI
        roi = (pnl / entry_cost) * 100 if entry_cost > 0 else 0
        
        return {
            "strategy": "Long Call",
            "entry_time": entry_time,
            "exit_time": exit_time,
            "strike": strike,
            "premium_paid": entry_cost,
            "exit_price": exit_price,
            "pnl": pnl,
            "roi_pct": roi,
            "underlying_exit": underlying_exit,
            "holding_days": (exit_time - entry_time).days
        }
    
    def backtest_iron_condor(
        self,
        entry_time: pd.Timestamp,
        exit_time: pd.Timestamp,
        put_short_strike: float,
        put_long_strike: float,
        call_short_strike: float,
        call_long_strike: float,
        premium_received: float,
        position_size: int = 1
    ) -> dict:
        """
        Backtest Iron Condor strategy
        
        กลยุทธ์: ขาย OTM Put spread + OTM Call spread
        Max Profit: premium ที่ได้รับ
        Max Loss: difference between strikes - premium
        """
        
        entry_data = self.data[self.data["timestamp"] >= entry_time].iloc[0]
        exit_data = self.data[self.data["timestamp"] >= exit_time].iloc[0]
        
        underlying_exit = exit_data["underlying_price"]
        
        # คำนวณผลลัพธ์สำหรับแต่ละ leg
        put_spread_loss = 0
        call_spread_loss = 0
        
        # Put spread (put short + put long)
        if underlying_exit < put_short_strike:
            put_spread_loss = (put_short_strike - underlying_exit) - (put_long_strike - put_short_strike)
        elif underlying_exit >= put_long_strike:
            put_spread_loss = 0
        
        # Call spread (call short + call long)
        if underlying_exit > call_short_strike:
            call_spread_loss = (underlying_exit - call_short_strike) - (call_long_strike - call_short_strike)
        elif underlying_exit <= call_long_strike:
            call_spread_loss = 0
        
        # Total PnL
        total_loss = (put_spread_loss + call_spread_loss) * position_size
        net_pnl = premium_received * position_size - total_loss
        
        return {
            "strategy": "Iron Condor",
            "entry_time": entry_time,
            "exit_time": exit_time,
            "strikes": {
                "put_short": put_short_strike,
                "put_long": put_long_strike,
                "call_short": call_short_strike,
                "call_long": call_long_strike
            },
            "premium_received": premium_received * position_size,
            "max_loss": total_loss,
            "pnl": net_pnl,
            "underlying_exit": underlying_exit,
            "holding_days": (exit_time - entry_time).days
        }
    
    def analyze_slippage(
        self,
        orderbook_data: pd.DataFrame,
        order_size: float,
        side: str = "buy"
    ) -> dict:
        """
        วิเคราะห์ slippage จาก orderbook depth
        
        สำคัญมากสำหรับ Market Making backtest
        """
        
        bids = orderbook_data["best_bid_price"].values
        asks = orderbook_data["best_ask_price"].values
        bid_amounts = orderbook_data["best_bid_amount"].values
        ask_amounts = orderbook_data["best_ask_amount"].values
        
        # คำนวณ VWAP สำหรับ order size
        if side == "buy":
            prices = asks
            amounts = ask_amounts
        else:
            prices = bids
            amounts = bid_amounts
        
        # Simulate fill at multiple levels
        remaining_size = order_size
        total_cost = 0
        levels_used = 0
        
        for price, amount in zip(prices, amounts):
            if remaining_size <= 0:
                break
            fill_size = min(remaining_size, amount)
            total_cost += price * fill_size
            remaining_size -= fill_size
            levels_used += 1
        
        avg_fill_price = total_cost / order_size if order_size > 0 else 0
        mid_price = (bids[0] + asks[0]) / 2
        
        slippage = avg_fill_price - mid_price
        slippage_pct = (slippage / mid_price) * 100
        
        return {
            "order_size": order_size,
            "avg_fill_price": avg_fill_price,
            "mid_price": mid_price,
            "slippage": slippage,
            "slippage_pct": slippage_pct,
            "levels_used": levels_used,
            "fill_ratio": 1 - (remaining_size / order_size)
        }


ตัวอย่างการใช้งาน

if __name__ == "__main__":
    # Load data จาก Tardis.dev
    # df = asyncio.run(fetch_deribit_orderbook(...))
    
    # สร้าง backtester
    # bt = DeribitOptionsBacktester(df, initial_capital=100000)
    
    # ทดสอบ Long Call
    # result = bt.backtest_long_call(
    #     entry_time=pd.Timestamp("2024-01-15"),
    #     exit_time=pd.Timestamp("2024-01-30"),
    #     strike=95000,
    #     premium=1500,  # USD
    #     position_size=1
    # )
    # print(result)

การใช้ HolySheep AI สำหรับวิเคราะห์ข้อมูล

คุณสามารถใช้ HolySheep AI เพื่อวิเคราะห์ข้อมูล orderbook ด้วย AI ได้อย่างรวดเร็ว:

import aiohttp
import json

async def analyze_orderbook_with_ai(
    orderbook_summary: dict,
    api_key: str = "YOUR_HOLYSHEEP_API_KEY"
):
    """
    ใช้ HolySheep AI เพื่อวิเคราะห์ orderbook pattern
    
    base_url: https://api.holysheep.ai/v1 (บังคับ)
    """
    
    base_url = "https://api.holysheep.ai/v1"
    
    prompt = f"""
    วิเคราะห์ Deribit Options orderbook ด้านล่าง และให้คำแนะนำ:
    
    1. Bid-Ask Spread Analysis:
       - Best Bid: ${orderbook_summary.get('best_bid_price', 0)}
       - Best Ask: ${orderbook_summary.get('best_ask_price', 0)}
       - Spread: ${orderbook_summary.get('spread', 0)} ({orderbook_summary.get('spread_pct', 0):.2f}%)
    
    2. Greeks:
       - Delta: {orderbook_summary.get('greeks_delta', 'N/A')}
       - Gamma: {orderbook_summary.get('greeks_gamma', 'N/A')}
       - Theta: {orderbook_summary.get('greeks_theta', 'N/A')}
       - Vega: {orderbook_summary.get('greeks_vega', 'N/A')}
    
    3. Implied Volatility:
       - Bid IV: {orderbook_summary.get('best_bid_iv', 'N/A')}%
       - Ask IV: {orderbook_summary.get('best_ask_iv', 'N/A')}%
    
    คำแนะนำ:
    - ควร Long หรือ Short?
    - ความเสี่ยงจาก IV changes?
    - Position sizing ที่เหมาะสม?
    """
    
    payload = {
        "model": "gpt-4.1",  # $8/MTok
        "messages": [
            {"role": "system", "content": "คุณเป็นผู้เชี่ยวชาญด้าน Options trading และ Deribit exchange"},
            {"role": "user", "content": prompt}
        ],
        "temperature": 0.3,
        "max_tokens": 1000
    }
    
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    async with aiohttp.ClientSession() as session:
        async with session.post(
            f"{base_url}/chat/completions",
            json=payload,
            headers=headers
        ) as response:
            if response.status == 200:
                result = await response.json()
                return result["choices"][0]["message"]["content"]
            else:
                error = await response.text()
                raise Exception(f"API Error: {response.status} - {error}")

async def generate_backtest_report(
    backtest_results: list,
    api_key: str = "YOUR_HOLYSHEEP_API_KEY"
):
    """
    ใช้ HolySheep AI เพื่อสร้างรายงาน backtest อย่างมืออาชีพ
    """
    
    base_url = "https://api.holysheep.ai/v1"
    
    # คำนวณสถิติ
    total_trades = len(backtest_results)
    winning_trades = sum(1 for r in backtest_results if r.get('pnl', 0) > 0)
    losing_trades = total_trades - winning_trades
    win_rate = (winning_trades / total_trades * 100) if total_trades > 0 else 0
    
    total_pnl = sum(r.get('pnl', 0) for r in backtest_results)
    avg_pnl = total_pnl / total_trades if total_trades > 0 else 0
    
    prompt = f"""
    สร้างรายงาน backtest สำหรับ Deribit Options Strategy:
    
    สรุปผลการทดสอบ:
    - จำนวน trades ทั้งหมด: {total_trades}
    - Win rate: {win_rate:.2f}%
    - Total PnL: ${total_pnl:,.2f}
    - Average PnL per trade: ${avg_pnl:,.2f}
    - Winning trades: {winning_trades}
    - Losing trades: {losing_trades}
    
    ผลลัพธ์ราย trade:
    {json.dumps(backtest_results[:5], indent=2)}  # แสดง 5 รายการแรก
    
    กรุณาวิเคราะห์:
    1. ประสิทธิภาพของกลยุทธ์
    2. จุดแข็งและจุดอ่อน
    3. คำแนะนำในการปรับปรุง
    4. ความเสี่ยงที่ต้องระวัง
    """
    
    payload = {
        "model": "claude-sonnet-4.5",  # $15/MTok
        "messages": [
            {"role": "system", "content": "คุณเป็นผู้เชี่ยวชาญด้าน quantitative trading และ risk management"},
            {"role": "user", "content": prompt}
        ],
        "temperature": 0.2,
        "max_tokens": 2000
    }
    
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    async with aiohttp.ClientSession() as session:
        async with session.post(
            f"{base_url}/chat/completions",
            json=payload,
            headers=headers
        ) as response:
            if response.status ==

แหล่งข้อมูลที่เกี่ยวข้อง
บทความที่เกี่ยวข้อง