บทนำ: ทำไมต้องใช้ Market Making Bot บน Bybit

การทำ Market Making บน Bybit ผ่าน API เป็นกลยุทธ์ที่ได้รับความนิยมอย่างมากในวงการเทรดคริปโต โดยหลักการคือการสร้างคำสั่งซื้อ-ขายทั้งสองฝั่งอย่างต่อเนื่องเพื่อเก็บ Spread ระหว่างราคา Bid และ Ask การทำ Manual ทั้งหมดนั้นใช้เวลามากและมีความเสี่ยงจากความผิดพลาดของมนุษย์ ดังนั้นการใช้ Bot อัตโนมัติจึงเป็นทางเลือกที่ดีกว่า ในบทความนี้ ผมจะแนะนำวิธีตั้งค่า Bybit API Market Making ทั้งแบบ Native และแบบใช้ AI จาก HolySheep AI ที่ช่วยให้การสร้างโลจิก Bot ง่ายขึ้นมาก

พื้นฐาน Bybit API: การเชื่อมต่อและ Authentication

ก่อนเริ่มต้น คุณต้องมี API Key จาก Bybit ก่อน โดยไปที่ Bybit → Profile → API Management → Create New Key แล้วเลือก "Trade" Permission เท่านั้น ห้ามให้ Withdraw Permission เพื่อความปลอดภัย 
import hmac
import hashlib
import time
import requests

BYBIT_API_KEY = "YOUR_BYBIT_API_KEY"
BYBIT_API_SECRET = "YOUR_BYBIT_API_SECRET"
BASE_URL = "https://api.bybit.com"

def create_signature(params, secret):
    """สร้าง HMAC SHA256 signature สำหรับ Bybit API"""
    param_str = '&'.join([f"{k}={v}" for k, v in sorted(params.items())])
    signature = hmac.new(
        secret.encode('utf-8'),
        param_str.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()
    return signature

def bybit_request(method, endpoint, params=None):
    """ส่ง request ไปยัง Bybit API พร้อม signature"""
    params = params or {}
    params['api_key'] = BYBIT_API_KEY
    params['timestamp'] = int(time.time() * 1000)
    params['recv_window'] = 5000
    params['sign'] = create_signature(params, BYBIT_API_SECRET)
    
    url = f"{BASE_URL}{endpoint}"
    if method == 'GET':
        return requests.get(url, params=params).json()
    return requests.post(url, data=params).json()


ทดสอบเชื่อมต่อ

result = bybit_request('GET', '/v5/account/wallet-balance', {'account_type': 'UNIFIED'})
print(result)
# ตรวจสอบยอดเงินและความถูกต้องของการเชื่อมต่อ
python3 test_connection.py

Output: {'retCode': 0, 'retMsg': 'success', ... } = เชื่อมต่อสำเร็จ

โครงสร้าง Market Making Bot พื้นฐาน

Market Making Bot ที่ดีต้องมีองค์ประกอบหลักดังนี้: 
import json
from datetime import datetime

class MarketMakerBot:
    def __init__(self, symbol, base_spread=0.001, max_position=1000):
        self.symbol = symbol
        self.base_spread = base_spread  # 0.1% base spread
        self.max_position = max_position
        self.current_position = 0
        
    def calculate_order_price(self, mid_price, side, spread_multiplier=1.0):
        """คำนวณราคาคำสั่งซื้อ/ขาย"""
        spread = mid_price * self.base_spread * spread_multiplier
        if side == 'Buy':
            return round(mid_price - spread, 2)
        return round(mid_price + spread, 2)
    
    def calculate_quantity(self, mid_price):
        """คำนวณขนาดล็อตที่เหมาะสม"""
        # จำกัดขนาดตาม position
        available = self.max_position - abs(self.current_position)
        if available <= 0:
            return 0
        # ลดขนาดเมื่อ position สูง
        return min(available * 0.1, 100)
    
    def should_place_order(self, volatility):
        """ตัดสินใจว่าควรวางคำสั่งหรือไม่"""
        # ไม่วางคำสั่งเมื่อ volatility สูงเกินไป
        if volatility > 0.05:  # 5%
            return False, "High volatility"
        # ไม่วางคำสั่งเมื่อ position เต็ม
        if abs(self.current_position) >= self.max_position:
            return False, "Position limit"
        return True, "OK"
    
    def generate_orders(self, order_book):
        """สร้างคำสั่งซื้อ-ขาย"""
        mid_price = (order_book['best_bid'] + order_book['best_ask']) / 2
        volatility = order_book.get('volatility', 0.001)
        
        should_place, reason = self.should_place_order(volatility)
        if not should_place:
            return [], reason
        
        orders = []
        # วาง Buy order
        buy_price = self.calculate_order_price(mid_price, 'Buy')
        buy_qty = self.calculate_quantity(mid_price)
        if buy_qty > 0:
            orders.append({
                'symbol': self.symbol,
                'side': 'Buy',
                'price': buy_price,
                'qty': buy_qty,
                'order_type': 'Limit'
            })
        
        # วาง Sell order
        sell_price = self.calculate_order_price(mid_price, 'Sell')
        sell_qty = self.calculate_quantity(mid_price)
        if sell_qty > 0:
            orders.append({
                'symbol': self.symbol,
                'side': 'Sell',
                'price': sell_price,
                'qty': sell_qty,
                'order_type': 'Limit'
            })
        
        return orders, "Orders generated"


ทดสอบ

bot = MarketMakerBot('BTCUSDT', base_spread=0.001, max_position=0.5)
test_book = {'best_bid': 67000, 'best_ask': 67050, 'volatility': 0.002}
orders, status = bot.generate_orders(test_book)
print(f"Status: {status}")
print(f"Generated Orders: {json.dumps(orders, indent=2)}")

การใช้ AI ช่วยสร้าง Market Making Strategy

การสร้าง Market Making Bot ที่ฉลาดต้องใช้ AI วิเคราะห์ข้อมูลตลาดและปรับกลยุทธ์อัตโนมัติ HolySheep AI ให้บริการ AI API ความเร็วสูงที่รองรับหลายโมเดล เช่น GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash และ DeepSeek V3.2 ด้วยความหน่วงต่ำกว่า 50ms เหมาะสำหรับการประมวลผลแบบ Real-time 
import requests
import json


HolySheep AI - ใช้สำหรับวิเคราะห์ตลาดและสร้างกลยุทธ์

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"

def analyze_market_with_ai(order_book_data, historical_data):
    """ใช้ AI วิเคราะห์สภาพตลาดและแนะนำกลยุทธ์"""
    
    prompt = f"""
    วิเคราะห์ข้อมูลตลาดและแนะนำกลยุทธ์ Market Making:
    
    Order Book: {json.dumps(order_book_data, indent=2)}
    Historical: {json.dumps(historical_data[-10:], indent=2)}
    
    ให้คำตอบเป็น JSON พร้อม:
    - recommended_spread: ค่า spread ที่แนะนำ
    - position_limit: ขีดจำกัด position
    - risk_level: low/medium/high
    - action: buy/sell/hold พร้อมเหตุผล
    """
    
    response = requests.post(
        f"{HOLYSHEEP_BASE_URL}/chat/completions",
        headers={
            "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "model": "gpt-4.1",
            "messages": [
                {"role": "system", "content": "คุณเป็นผู้เชี่ยวชาญ Market Making สำหรับ Bybit"},
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.3,
            "max_tokens": 500
        }
    )
    
    result = response.json()
    recommendation = result['choices'][0]['message']['content']
    
    # Parse JSON จาก response
    return json.loads(recommendation)


ทดสอบ

test_order_book = {
    "best_bid": 67000,
    "best_ask": 67050,
    "bid_volume": 150,
    "ask_volume": 180,
    "spread_percent": 0.0007
}

test_historical = [
    {"time": "09:00", "price": 66800, "volume": 1200},
    {"time": "09:05", "price": 66950, "volume": 1500},
    {"time": "09:10", "price": 67000, "volume": 1100},
]

strategy = analyze_market_with_ai(test_order_book, test_historical)
print(f"AI Recommendation: {json.dumps(strategy, indent=2)}")

การทำ Backtest และ Optimization

ก่อนใช้งานจริง ควรทำ Backtest กับข้อมูลย้อนหลัง เพื่อหา Parameters ที่เหมาะสมที่สุด 
import random

def backtest_market_maker(bot, price_data, commission=0.0004):
    """
    ทดสอบกลยุทธ์กับข้อมูลย้อนหลัง
    commission: ค่าคอมมิชชั่น Bybit spot (0.04%)
    """
    initial_balance = 10000  # USDT
    balance = initial_balance
    position = 0
    trades = []
    
    for i in range(1, len(price_data)):
        current_price = price_data[i]['close']
        prev_price = price_data[i-1]['close']
        
        # จำลองการวางคำสั่ง
        mid_price = current_price
        spread = mid_price * bot.base_spread
        
        # ความน่าจะเป็นที่คำสั่งจะถูก execute
        buy_prob = 0.5 + random.uniform(-0.1, 0.1)
        sell_prob = 0.5 + random.uniform(-0.1, 0.1)
        
        # Execute Buy
        if buy_prob > 0.45 and abs(position) < bot.max_position:
            qty = bot.calculate_quantity(mid_price)
            cost = mid_price - spread
            balance -= cost * qty
            position += qty
            trades.append({'side': 'buy', 'price': cost, 'qty': qty})
        
        # Execute Sell
        if sell_prob > 0.45 and position > 0:
            qty = min(bot.calculate_quantity(mid_price), position)
            revenue = mid_price + spread
            balance += revenue * qty
            position -= qty
            trades.append({'side': 'sell', 'price': revenue, 'qty': qty})
        
        # คำนวณ PnL รวม position
        unrealized_pnl = position * current_price
    
    # ปิด position สุดท้าย
    final_price = price_data[-1]['close']
    if position > 0:
        balance += position * final_price
    
    total_pnl = balance - initial_balance
    pnl_percent = (total_pnl / initial_balance) * 100
    
    return {
        'final_balance': balance,
        'total_pnl': total_pnl,
        'pnl_percent': pnl_percent,
        'total_trades': len(trades),
        'final_position': position
    }


Generate dummy price data

random.seed(42)
price_data = [
    {'close': 67000 + random.gauss(0, 100)}
    for _ in range(100)
]


ทดสอบหลายค่า spread

spreads = [0.0005, 0.001, 0.0015, 0.002, 0.003]
results = []

for spread in spreads:
    bot = MarketMakerBot('BTCUSDT', base_spread=spread, max_position=0.5)
    result = backtest_market_maker(bot, price_data)
    results.append({
        'spread': f"{spread*100:.2f}%",
        'pnl': f"${result['total_pnl']:.2f}",
        'pnl_percent': f"{result['pnl_percent']:.2f}%",
        'trades': result['total_trades']
    })

print("Backtest Results:")
for r in results:
    print(f"  Spread: {r['spread']:>6} | PnL: {r['pnl']:>10} | %: {r['pnl_percent']:>8} | Trades: {r['trades']}")

ตารางเปรียบเทียบ: วิธีการทำ Market Making บน Bybit

เกณฑ์ Native Bybit API HolySheep AI + Bybit Third-party Bot
ความยากในการตั้งค่า สูง (ต้องเขียนโค้ดเอง) ปานกลาง (ใช้ AI ช่วย) ต่ำ (GUI สำเร็จรูป)
ความยืดหยุ่นของกลยุทธ์ สูงมาก สูง (ปรับแต่งได้) จำกัด
ความเร็วในการตอบสนอง <50ms <50ms (รวม AI) 100-500ms
ค่าใช้จ่าย ฟรี (เฉพาะ Bybit Fee) $0.42-15/MTok $29-299/เดือน
ความเสี่ยงด้านความปลอดภัย ต่ำ (คุมโค้ดเอง) ต่ำ (API Key ของคุณ) สูง (信任 บุคคลที่สาม)
Backtesting ต้องเขียนเอง รองรับ API มีในตัว
คะแนนรวม ★★★★☆ ★★★★★ ★★★☆☆

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

กรณีที่ 1: API Signature ไม่ถูกต้อง (retCode: 10002)

# ❌ วิธีผิด: Timestamp ไม่ตรงกับ server
params['timestamp'] = int(time.time() * 1000)  # อาจล่าช้า


✅ วิธีถูกต้อง

import threading
import time as time_module

def bybit_request_v2(method, endpoint, params=None):
    params = params or {}
    
    # Sync timestamp กับ server ก่อน
    server_time = requests.get(f"{BASE_URL}/v5/time").json()['time']
    local_time = int(time_module.time() * 1000)
    time_diff = server_time - local_time
    
    params['api_key'] = BYBIT_API_KEY
    params['timestamp'] = int(time_module.time() * 1000) + time_diff
    params['recv_window'] = 10000  # เพิ่ม window สำหรับ latency
    params['sign'] = create_signature(params, BYBIT_API_SECRET)
    
    # Retry logic
    for attempt in range(3):
        try:
            url = f"{BASE_URL}{endpoint}"
            if method == 'GET':
                result = requests.get(url, params=params, timeout=10).json()
            else:
                result = requests.post(url, data=params, timeout=10).json()
            
            if result['retCode'] == 0:
                return result
            elif result['retCode'] in [10002, 10003]:  # Signature error
                time_module.sleep(0.5)  # รอแล้วลองใหม่
                params['timestamp'] = int(time_module.time() * 1000) + time_diff
                params['sign'] = create_signature(params, BYBIT_API_SECRET)
                continue
            else:
                return result  # ข้อผิดพลาดอื่น
        except requests.exceptions.Timeout:
            if attempt == 2:
                raise Exception("Connection timeout after 3 attempts")
    
    return {'retCode': 99999, 'retMsg': 'Max retries exceeded'}

กรณีที่ 2: Position ล้นเกิน (Insufficient Balance)

# ❌ วิธีผิด: วางคำสั่งโดยไม่เช็ค balance ก่อน
order_qty = calculate_position_size()
place_order(symbol, 'Buy', price, order_qty)  # อาจล้นได้


✅ วิธีถูกต้อง: Double-check ก่อนวางคำสั่ง

def safe_place_order(symbol, side, price, requested_qty):
    """วางคำสั่งอย่างปลอดภัยพร้อมตรวจสอบ balance"""
    
    # 1. ดึงข้อมูล balance ล่าสุด
    balance_resp = bybit_request('GET', '/v5/account/wallet-balance', 
                                  {'account_type': 'UNIFIED'})
    if balance_resp['retCode'] != 0:
        return {'success': False, 'error': balance_resp['retMsg']}
    
    # หา available balance
    coins = balance_resp['result']['coins']
    usdt_balance = next((c for c in coins if c['coin'] == 'USDT'), {})
    available = float(usdt_balance.get('availableToTrade', 0))
    
    # 2. ดึงข้อมูล position ปัจจุบัน
    position_resp = bybit_request('GET', '/v5/position/list',
                                   {'category': 'spot', 'symbol': symbol})
    current_position = 0
    if position_resp['retCode'] == 0 and position_resp['result']['list']:
        current_position = float(position_resp['result']['list'][0].get('size', 0))
    
    # 3. คำนวณ qty ที่ปลอดภัย
    if side == 'Buy':
        max_qty = available / price
        safe_qty = min(requested_qty, max_qty * 0.99)  # เผื่อ 1%
    else:  # Sell
        max_qty = current_position
        safe_qty = min(requested_qty, max_qty)
    
    # 4. วางคำสั่งเฉพาะ qty ที่ปลอดภัย
    if safe_qty < 0.00001:  # ต่ำกว่า minimum
        return {'success': False, 'error': 'Insufficient balance'}
    
    order_resp = bybit_request('POST', '/v5/order/create',
                               {'category': 'spot', 'symbol': symbol,
                                'side': side, 'orderType': 'Limit',
                                'price': str(price), 'qty': str(safe_qty)})
    
    return {
        'success': order_resp['retCode'] == 0,
        'orderId': order_resp.get('result', {}).get('orderId'),
        'executedQty': safe_qty,
        'error': order_resp.get('retMsg') if order_resp['retCode'] != 0 else None
    }

กรณีที่ 3: Rate Limit Error (retCode: 10006)

# ❌ วิธีผิด: เรียก API บ่อยเกินไปโดยไม่ควบคุม
while True:
    get_order_book()  # ทุก 100ms = ล้น rate limit แน่นอน
    place_orders()
    time.sleep(0.1)


✅ วิธีถูกต้อง: Rate limiter และ queue คำสั่ง

from collections import deque
import threading

class RateLimiter:
    def __init__(self, max_calls, time_window):
        self.max_calls = max_calls
        self.time_window = time_window
        self.calls = deque()
        self.lock = threading.Lock()
    
    def acquire(self):
        """รอจนกว่าจะมี quota"""
        with self.lock:
            now = time_module.time()
            # ลบ calls ที่หมดอายุ
            while self.calls and self.calls[0] < now - self.time_window:
                self.calls.popleft()
            
            if len(self.calls) >= self.max_calls:
                sleep_time = self.calls[0] - (now - self.time_window)
                if sleep_time > 0:
                    time_module.sleep(sleep_time)
                return self.acquire()  # ลองใหม่
            
            self.calls.append(now)
            return True


Bybit Rate Limits (Spot):


- 600 requests/10s (IP level)


- 60 requests/10s (UID level)


- 10 orders/second


order_limiter = RateLimiter(max_calls=8, time_window=1)  # 8 orders/sec
read_limiter = RateLimiter(max_calls=50, time_window=10)  # 50 reads/10s

def safe_get_order_book():
    read_limiter.acquire()
    return bybit_request('GET', '/v5/market/orderbook',
                         {'category': 'spot', 'symbol': 'BTCUSDT', 'limit': 50})

def safe_place_order(order_data):
    order_limiter.acquire()
    return bybit_request('POST', '/v5/order/create', order_data)

ราคาและ ROI

รายการ ราคา/เดือน รายละเอียด
Bybit Trading Fee Maker: 0.1%, Taker: 0.2% ขึ้นอยู่กับ VIP Level
Third-party Bot $29 - $299 แพงและมีข้อจำกัด
HolySheep AI (DeepSeek V3.2) $0.42/MTok ประหยัดมาก รองรับ Strategy ซับซ้อน
HolySheep AI (Gemini 2.5 Flash) $2.50/MTok สมดุลราคา-ความสามารถ
HolySheep AI (GPT-4.1) $8/MTok คุณภาพสูงสุดสำหรับ Strategy หลากหลาย
ต้นทุน AI รวมต่อเดือน* $5 - $50 เฉลี่ย 1M tokens/วัน
*ต้นทุน AI สำหรับ Market Making ขั้นพื้นฐา

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

บทความที่เกี่ยวข้อง