Tardis API + Python Matplotlib วาด K-Line Chart สำหรับ Cryptocurrency พร้อมโค้ดครบในบทความเดียว

Tardis API คืออะไร และทำไมต้องใช้สำหรับข้อมูลประวัติคริปโต

ตารางเปรียบเทียบบริการดึงข้อมูลคริปโต API ยอดนิยม 2025

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

ราคาและ ROI

ขั้นตอนที่ 1: ติดตั้ง Library และเตรียม Environment

# สร้าง Virtual Environment แยกสำหรับโปรเจกต์นี้
python -m venv crypto_chart_env

เปิดใช้งาน Environment
Windows:
crypto_chart_env\Scripts\activate
macOS/Linux:
source crypto_chart_env/bin/activate

ติดตั้ง Library ที่จำเป็น
pip install tardis-client matplotlib pandas requests

หรือใช้ conda
conda create -n crypto_chart python=3.10
conda activate crypto_chart
pip install tardis-client matplotlib pandas requests

ตรวจสอบเวอร์ชัน
python --version
pip show tardis-client matplotlib pandas

ขั้นตอนที่ 2: ดึงข้อมูล Historical K-Line จาก Tardis API

import requests
import pandas as pd
from datetime import datetime, timedelta

class TardisAPIClient:
    """
    คลาสสำหรับเชื่อมต่อ Tardis API และดึงข้อมูล Historical K-Line
    สำหรับ Cryptocurrency
    """
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.tardis.dev/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def get_historical_candles(
        self, 
        exchange: str, 
        symbol: str, 
        start_date: str, 
        end_date: str,
        interval: str = "1m"
    ):
        """
        ดึงข้อมูล OHLCV (Candlestick) จาก Exchange
        
        Parameters:
        -----------
        exchange : str
            ชื่อ Exchange เช่น 'binance', 'bybit', 'okx'
        symbol : str
            สัญลักษณ์คู่เทรด เช่น 'BTC/USDT', 'ETH/USDT'
        start_date : str
            วันที่เริ่มต้น format 'YYYY-MM-DD'
        end_date : str
            วันที่สิ้นสุด format 'YYYY-MM-DD'
        interval : str
            Timeframe เช่น '1m', '5m', '1h', '1d'
            
        Returns:
        --------
        pd.DataFrame
            DataFrame ที่มี columns: timestamp, open, high, low, close, volume
        """
        url = f"{self.base_url}/historical/candles"
        
        params = {
            "exchange": exchange,
            "symbol": symbol,
            "startDate": start_date,
            "endDate": end_date,
            "interval": interval,
            "limit": 1000  # จำกัด 1000 records ต่อ request
        }
        
        try:
            response = requests.get(
                url, 
                headers=self.headers, 
                params=params,
                timeout=30
            )
            response.raise_for_status()
            data = response.json()
            
            # แปลงเป็น DataFrame
            df = pd.DataFrame(data)
            
            # ปรับ format วันที่
            if 'timestamp' in df.columns:
                df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
            
            print(f"✅ ดึงข้อมูลสำเร็จ: {len(df)} records")
            print(f"📅 ช่วงเวลา: {df['timestamp'].min()} ถึง {df['timestamp'].max()}")
            
            return df
            
        except requests.exceptions.RequestException as e:
            print(f"❌ เกิดข้อผิดพลาดในการเชื่อมต่อ: {e}")
            return None

ตัวอย่างการใช้งาน
สมัคร API Key ที่ https://tardis.dev/
API_KEY = "YOUR_TARDIS_API_KEY"

tardis = TardisAPIClient(API_KEY)

ดึงข้อมูล BTC/USDT จาก Binance ย้อนหลัง 7 วัน
df_btc = tardis.get_historical_candles(
    exchange="binance",
    symbol="BTC/USDT",
    start_date=(datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d"),
    end_date=datetime.now().strftime("%Y-%m-%d"),
    interval="5m"
)

print(df_btc.head())

ขั้นตอนที่ 3: วาด K-Line Chart ด้วย Matplotlib

import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from matplotlib.patches import Rectangle
import pandas as pd
import numpy as np

class KLineChart:
    """
    คลาสสำหรับวาด K-Line Chart (Candlestick Chart)
    แสดงราคา OHLC ของ Cryptocurrency
    """
    
    def __init__(self, figsize=(16, 8), style='seaborn-v0_8-darkgrid'):
        plt.style.use(style)
        self.figsize = figsize
        self.fig = None
        self.ax = None
    
    def plot_candlesticks(self, df, title="K-Line Chart", pair="BTC/USDT"):
        """
        วาด K-Line Chart จาก DataFrame
        
        Parameters:
        -----------
        df : pd.DataFrame
            ต้องมี columns: timestamp, open, high, low, close
        title : str
            หัวข้อกราฟ
        pair : str
            ชื่อคู่เทรด
        """
        self.fig, self.ax = plt.subplots(figsize=self.figsize)
        
        # เตรียมข้อมูล
        df = df.copy()
        df['timestamp'] = pd.to_datetime(df['timestamp'])
        df = df.sort_values('timestamp')
        
        # คำนวณสีของแท่งเทียน
        df['color'] = np.where(df['close'] >= df['open'], 'green', 'red')
        df['body_bottom'] = df[['open', 'close']].min(axis=1)
        df['body_height'] = abs(df['open'] - df['close'])
        
        # วาดแท่งเทียน (Candlestick)
        for idx, row in df.iterrows():
            # กำหนดสี
            color = 'green' if row['close'] >= row['open'] else 'red'
            
            # วาดไส้เทียน (Wick/Shadow)
            self.ax.plot(
                [row['timestamp'], row['timestamp']],
                [row['low'], row['high']],
                color=color,
                linewidth=0.8
            )
            
            # วาดตัวเทียน (Body)
            body = Rectangle(
                xy=(row['timestamp'] - pd.Timedelta(minutes=2), row['body_bottom']),
                width=pd.Timedelta(minutes=4),
                height=max(row['body_height'], 0.0001),  # ป้องกัน body สูง 0
                facecolor=color if row['close'] >= row['open'] else color,
                edgecolor=color,
                linewidth=1
            )
            self.ax.add_patch(body)
        
        # ตั้งค่าแกน X
        self.ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M'))
        self.ax.xaxis.set_major_locator(mdates.AutoDateLocator())
        plt.xticks(rotation=45, ha='right')
        
        # ตั้งค่า labels และ title
        self.ax.set_xlabel('เวลา (Time)', fontsize=12)
        self.ax.set_ylabel('ราคา (USDT)', fontsize=12)
        self.ax.set_title(f'{title} - {pair}', fontsize=16, fontweight='bold')
        
        # เพิ่ม Grid
        self.ax.grid(True, alpha=0.3, linestyle='--')
        
        # เพิ่ม Volume ด้านล่าง
        ax_volume = self.ax.twinx()
        colors = ['green' if df.loc[i, 'close'] >= df.loc[i, 'open'] else 'red' 
                  for i in df.index]
        ax_volume.bar(df['timestamp'], df['volume'], width=0.0004, alpha=0.3, color=colors)
        ax_volume.set_ylabel('Volume', fontsize=12, color='gray')
        
        # ปรับ layout
        plt.tight_layout()
        
        return self.fig
    
    def add_indicators(self, df):
        """
        เพิ่ม Technical Indicators (SMA, EMA)
        """
        # Simple Moving Average (SMA)
        df['SMA_20'] = df['close'].rolling(window=20).mean()
        df['SMA_50'] = df['close'].rolling(window=50).mean()
        
        self.ax.plot(df['timestamp'], df['SMA_20'], 
                    color='blue', linewidth=1.5, label='SMA 20', alpha=0.8)
        self.ax.plot(df['timestamp'], df['SMA_50'], 
                    color='orange', linewidth=1.5, label='SMA 50', alpha=0.8)
        
        self.ax.legend(loc='upper left')
        
    def save_chart(self, filename="kline_chart.png", dpi=300):
        """บันทึกกราฟเป็นไฟล์"""
        self.fig.savefig(filename, dpi=dpi, bbox_inches='tight')
        print(f"✅ บันทึกกราฟที่: {filename}")
    
    def show(self):
        """แสดงกราฟ"""
        plt.show()


ตัวอย่างการใช้งานเต็มรูปแบบ
def create_full_chart(df, pair_name="BTC/USDT"):
    """
    สร้าง K-Line Chart พร้อม Indicators
    """
    chart = KLineChart(figsize=(18, 10))
    
    # วาดกราฟหลัก
    chart.plot_candlesticks(
        df.tail(200),  # แสดงเฉพาะ 200 แท่งล่าสุด
        title="Cryptocurrency K-Line Chart",
        pair=pair_name
    )
    
    # เพิ่ม Indicators
    chart.add_indicators(df.tail(200))
    
    return chart

วิ่งทดสอบ (สมมติว่า df_btc ถูกสร้างจากขั้นตอนที่ 2 แล้ว)
chart = create_full_chart(df_btc, "BTC/USDT")
chart.show()
chart.save_chart("btc_kline.png")

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

# ❌ วิธีที่ทำให้เกิดข้อผิดพลาด
client = TardisAPIClient("expired_or_invalid_key")
df = client.get_historical_candles(...)
df.info()  # AttributeError เพราะ df เป็น None

✅ วิธีแก้ไข: ตรวจสอบ Response ก่อนใช้งาน
client = TardisAPIClient("YOUR_VALID_KEY")
df = client.get_historical_candles(
    exchange="binance",
    symbol="BTC/USDT",
    start_date="2025-01-01",
    end_date="2025-01-08",
    interval="5m"
)

if df is not None and not df.empty:
    print(f"✅ ได้ข้อมูล {len(df)} records")
    print(df.info())
else:
    print("❌ ไม่สามารถดึงข้อมูลได้ กรุณาตรวจสอบ API Key")

# ❌ วิธีที่ทำให้เกิดข้อผิดพลาด
df1 = get_data(start="2025-01-01", end="2025-01-05")
df2 = get_data(start="2025-01-04", end="2025-01-08")
combined = pd.concat([df1, df2])  # Timestamp ซ้ำ!

✅ วิธีแก้ไข: Drop Duplicates หรือใช้ merge
combined = pd.concat([df1, df2]).drop_duplicates(subset=['timestamp'])
combined = combined.sort_values('timestamp').reset_index(drop=True)

หรือใช้ merge แทน concat
df1.set_index('timestamp', inplace=True)
df2.set_index('timestamp', inplace=True)
combined = df1.join(df2, how='outer', lsuffix='_1', rsuffix='_2')
combined.reset_index(inplace=True)

# ✅ วิธีแก้ไข: เพิ่ม Magic Command ที่ Jupyter Notebook
%matplotlib inline
import matplotlib.pyplot as plt

หรือถ้าใช้ Qt5 Backend
%matplotlib qt5

หรือแบบนี้
import matplotlib
matplotlib.use('Agg')  # ใช้ Backend แบบ non-interactive
import matplotlib.pyplot as plt

สำหรับ Linux Server (ไม่มี Display)
import matplotlib
matplotlib.use('Agg')  # สำคัญมากสำหรับ Server
import matplotlib.pyplot as plt

จากนั้นวาดกราฟและ save แทน show()
chart = KLineChart()
chart.plot_candlesticks(df, title="BTC Chart")
chart.save_chart("output.png")  # ใช้ save แทน show() ใน Server

import time
from ratelimit import limits, sleep_and_retry

@sleep_and_retry
@limits(calls=30, period=60)  # จำกัด 30 ครั้งต่อ 60 วินาที
def get_candles_with_retry(client, **kwargs):
    """ดึงข้อมูลพร้อมจัดการ Rate Limit"""
    try:
        df = client.get_historical_candles(**kwargs)
        return df
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 429:
            print("⏳ Rate Limit รอ 60 วินาที...")
            time.sleep(60)  # รอ 1 นาที
            raise  # Re-raise เพื่อให้ decorator รีเทรย์
        raise

การใช้งาน
for i in range(10):
    df = get_candles_with_retry(
        client, 
        exchange="binance", 
        symbol="ETH/USDT",
        start_date=f"2025-01-0{i+1}",
        end_date=f"2025-01-0{i+2}",
        interval="5m"
    )
    time.sleep(2)  # delay 2 วินาทีระหว่างแต่ละ request

Advanced: เพิ่ม Technical Indicators และ Bollinger Bands

import ta
from ta.volatility import BollingerBands
from ta.momentum import RSIIndicator

def add_advanced_indicators(df):
    """
    เพิ่ม Technical Indicators หลายตัว
    """
    # Bollinger Bands
    indicator_bb = BollingerBands(close=df['close'], window=20, window_dev=2)
    df['BB_upper'] = indicator_bb.bollinger_hband()
    df['BB_middle'] = indicator_bb.bollinger_mavg()
    df['BB_lower'] = indicator_bb.bollinger_lband()
    
    # RSI
    indicator_rsi = RSIIndicator(close=df['close'], window=14)
    df['RSI'] = indicator_rsi.rsi()
    
    # MACD
    df['EMA_12'] = df['close'].ewm(span=12, adjust=False).mean()
    df['EMA_26'] = df['close'].ewm(span=26, adjust=False).mean()
    df['MACD'] = df['EMA_12'] - df['EMA_26']
    df['Signal_Line'] = df['MACD'].ewm(span=9, adjust=False).mean()
    
    return df

def plot_advanced_chart(df, pair="BTC/USDT"):
    """
    วาดกราฟ K-Line + Indicators ขั้นสูง
    """
    fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(16, 12), 
                                        gridspec_kw={'height_ratios': [3, 1, 1]})
    
    # เพิ่ม Indicators
    df = add_advanced_indicators(df)
    df = df.tail(500)  # 500 แท่งล่าสุด
    
    # ===== K-Line Chart =====
    for idx, row in df.iterrows():
        color = 'green' if row['close'] >= row['open'] else 'red'
        self.ax_1 = ax1
        # ไส้เทียน
        ax1.plot([row['timestamp'], row['timestamp']], 
                [row['low'], row['high']], color=color, linewidth=0.7)
        # ตัวเทียน
        body_bottom = min(row['open'], row['close'])
        body_height = abs(row['open'] - row['close'])
        rect = Rectangle(
            (row['timestamp'] - pd.Timedelta(minutes=3), body_bottom),
            pd.Timedelta(minutes=6),
            max(body_height, 0.0001),
            facecolor=color, edgecolor=color
        )
        ax1.add_patch(rect)
    
    # Bollinger Bands
    ax1.plot(df['timestamp'], df['BB_upper'], 'b--', alpha=0.5, label='BB Upper')
แหล่งข้อมูลที่เกี่ยวข้อง
📚 บทช่วยสอน AI API
💰 ดูราคา
📖 เอกสารสำหรับนักพัฒนา
🚀 สมัครฟรี
บทความที่เกี่ยวข้อง
macOS ติดตั้ง Claude Code ภายในเครื่อง: ลดค่าใช้จ่ายด้วย Hol
Funding rate arbitrage data pipeline architecture design
เครื่องคำนวณค่าใช้จ่าย Multi-Model API: เปรียบเทียบค่าใช้จ่า