วิธีใช้ Kraken API: คู่มือเทรดฉบับสมบูรณ์

ลองจินตนาการถึงการเข้าถึงหนึ่งในตลาดแลกเปลี่ยนคริปโตเคอร์เรนซีที่มีสภาพคล่องสูงที่สุดในโลกผ่าน API ที่ผ่านการพิสูจน์แล้วซึ่งจัดการสัญญาซื้อขายล่วงหน้า (futures contracts) และการซื้อขายแบบสปอต (spot trading) Kraken มอบสิ่งนั้นให้ โดยนำเสนออินเทอร์เฟซ WebSocket และ REST สำหรับตลาดแลกเปลี่ยนที่ก่อตั้งขึ้นในปี 2011 และให้บริการผู้ใช้งานกว่า 10 ล้านรายใน 190 ประเทศ พร้อมสภาพคล่องที่กว้างขวางในคู่การซื้อขายมากกว่า 200 คู่

API สำหรับการซื้อขายคริปโตเคอร์เรนซีแบ่งออกเป็นสองประเภท: ประเภทที่ออกแบบมาเพื่อความสะดวกสบายของผู้ใช้งานทั่วไป และประเภทที่สร้างขึ้นเพื่อความน่าเชื่อถือระดับสถาบัน ตลาดแลกเปลี่ยนหลายแห่งให้ความสำคัญกับแอปพลิเคชันมือถือมากกว่าความเสถียรของ API ส่งผลให้มีข้อจำกัดด้านอัตรา (rate limits) ที่จำกัดกลยุทธ์แบบอัลกอริทึมและเอกสารที่ล้าหลังกว่าการเปิดตัวฟีเจอร์ Kraken ขจัดปัญหาเหล่านี้ด้วยการนำเสนอการเข้าถึง API แบบแบ่งระดับตามปริมาณการซื้อขาย สภาพแวดล้อมแซนด์บ็อกซ์ที่ครอบคลุม และเอนด์พอยต์เฉพาะสำหรับนักเทรดที่มีความถี่สูง คุณสามารถสร้างกลยุทธ์อัตโนมัติที่สามารถปรับขนาดได้ตั้งแต่สคริปต์สำหรับมือสมัครเล่นไปจนถึงระบบระดับสถาบัน

สารบัญ:

ทำความเข้าใจสถาปัตยกรรม API ของ Kraken
การยืนยันตัวตนและการตั้งค่าคีย์ API
การซื้อขายแบบสปอตด้วย REST API
ข้อมูลเรียลไทม์ด้วย WebSocket
การซื้อขายสัญญาซื้อขายล่วงหน้าและคุณสมบัติขั้นสูง
บทสรุป

💡

การสร้างระบบซื้อขายคริปโตอัตโนมัติจำเป็นต้องมีการทดสอบ API ที่เชื่อถือได้ทั้งในเอนด์พอยต์ REST และ WebSocket Apidog นำเสนอการทดสอบ API ด้วยภาพ, การสร้างเอกสารอัตโนมัติ และคุณสมบัติการทำงานร่วมกันเป็นทีมที่ออกแบบมาโดยเฉพาะสำหรับตลาดแลกเปลี่ยนคริปโตเคอร์เรนซี ลองใช้ Apidog ฟรี เพื่อปรับปรุงการพัฒนา Kraken API ของคุณให้คล่องตัวยิ่งขึ้น—ไม่จำเป็นต้องใช้บัตรเครดิต

button

ทำความเข้าใจสถาปัตยกรรม API ของ Kraken

Kraken ดำเนินงานด้วยระบบนิเวศ API สามแบบที่แตกต่างกัน: Spot REST, Futures REST และ WebSocket การทำความเข้าใจสถาปัตยกรรมเหล่านี้จะช่วยให้คุณเลือกเส้นทางการรวมระบบที่เหมาะสม

Spot REST API

Spot REST API ให้การเข้าถึงฟังก์ชันหลักของตลาดแลกเปลี่ยน Kraken โดยแบ่งออกเป็นเอนด์พอยต์สาธารณะ (ข้อมูลตลาด, ข้อมูลราคาปัจจุบัน, ความลึกของสมุดคำสั่งซื้อ) และเอนด์พอยต์ส่วนตัว (ยอดคงเหลือในบัญชี, การจัดการคำสั่งซื้อ, การฝากถอน) คำขอทั้งหมดใช้ HTTPS พร้อม TLS 1.2 หรือสูงกว่า

Base URL: https://api.kraken.com/0

เอนด์พอยต์สาธารณะไม่จำเป็นต้องมีการยืนยันตัวตน เอนด์พอยต์ส่วนตัวใช้การลงนามคำขอ HMAC-SHA512 ด้วยคีย์ API รูปแบบการตอบกลับจะแตกต่างกันไป — เอนด์พอยต์บางส่วนส่งคืนอาร์เรย์ที่องค์ประกอบแรกเป็นสตริงข้อผิดพลาด (การออกแบบเดิม) ในขณะที่เอนด์พอยต์ใหม่ใช้วัตถุ JSON มาตรฐาน

Futures REST API

Kraken Futures ดำเนินการแยกต่างหากจากตลาดแลกเปลี่ยนสปอตด้วยโครงสร้างพื้นฐาน API ของตัวเอง รองรับ perpetual swaps และสัญญาซื้อขายล่วงหน้าที่มีวันหมดอายุที่แน่นอนบนคริปโตเคอร์เรนซีพร้อมเลเวอเรจสูงสุด 50 เท่า

Base URLs:

Production: https://futures.kraken.com/api/v3
Sandbox: https://demo-futures.kraken.com/api/v3

Futures API ใช้กลไกการยืนยันตัวตนและโครงสร้างเอนด์พอยต์ที่แตกต่างจาก Spot คุณต้องใช้คีย์ API แยกต่างหากที่สร้างขึ้นที่ futures.kraken.com ซึ่งไม่เกี่ยวข้องกับข้อมูลรับรองการซื้อขายสปอตของคุณ

WebSocket API

Kraken ให้บริการสตรีมข้อมูลเรียลไทม์ผ่าน เซิร์ฟเวอร์ WebSocket สองแห่ง:

สาธารณะ: wss://ws.kraken.com — ข้อมูลตลาด, สมุดคำสั่งซื้อ, การซื้อขาย
ส่วนตัว: wss://ws-auth.kraken.com — การอัปเดตบัญชี, สถานะคำสั่งซื้อ, การเปลี่ยนแปลงยอดคงเหลือ

แตกต่างจากการเรียกข้อมูลแบบ REST (polling) การเชื่อมต่อ WebSocket จะส่งข้อมูลทันทีที่ข้อมูลพร้อมใช้งาน ซึ่งช่วยลดความหน่วงจากหลักร้อยมิลลิวินาทีเหลือเพียงหลักสิบมิลลิวินาที เซิร์ฟเวอร์สาธารณะไม่จำเป็นต้องมีการยืนยันตัวตน; เซิร์ฟเวอร์ส่วนตัวต้องใช้โทเค็น WebSocket ที่ได้รับผ่าน REST API

การจำกัดอัตรา (Rate Limiting)

Kraken ใช้การจำกัดอัตราแบบแบ่งระดับ:

Starter: 60 คำขอต่อนาที (สาธารณะ), 30 คำขอต่อนาที (ส่วนตัว)
Intermediate: 125 คำขอต่อนาที (สาธารณะ), 60 คำขอต่อนาที (ส่วนตัว)
Pro: 250+ คำขอต่อนาที โดยอิงจากปริมาณการซื้อขาย 30 วัน

การเกินขีดจำกัดจะส่งผลให้เกิดข้อผิดพลาด HTTP 429 พร้อมด้วยเฮดเดอร์ Retry-After ที่ระบุว่าคุณสามารถส่งคำขอต่อได้เมื่อใด

การยืนยันตัวตนและการตั้งค่าคีย์ API

Kraken ใช้การยืนยันตัวตนแบบ HMAC-SHA512 พร้อมการป้องกันการเล่นซ้ำ (replay protection) โดยใช้ nonce ซึ่งต้องมีการใช้งานที่ระมัดระวังเพื่อหลีกเลี่ยงข้อผิดพลาด "Invalid nonce" ที่พบบ่อยในแอปพลิเคชันแบบ multi-threaded

การสร้างคีย์ API

ไปที่ Account → Security → API ในแดชบอร์ด Kraken ของคุณ:

คลิก "Generate New Key" (สร้างคีย์ใหม่)
เลือกสิทธิ์การเข้าถึง:

Query: อ่านยอดคงเหลือในบัญชี, คำสั่งซื้อที่เปิดอยู่, ประวัติการซื้อขาย
Trade: ส่งและยกเลิกคำสั่งซื้อ
Withdraw: โอนเงิน (ใช้ด้วยความระมัดระวัง)
Deposit: ดูที่อยู่และวิธีการฝากเงิน

3. ระบุการอนุญาต IP (IP whitelisting) (แนะนำสำหรับการใช้งานจริง)

4. จัดเก็บ API Key และ Private Key อย่างปลอดภัย—Kraken จะไม่แสดง Private Key อีกครั้ง

สำหรับการซื้อขายสัญญาซื้อขายล่วงหน้า (Futures) ให้ทำซ้ำขั้นตอนนี้ที่ futures.kraken.com/settings/api สภาพแวดล้อมแซนด์บ็อกซ์ที่ demo-futures.kraken.com ใช้ข้อมูลรับรองที่แยกต่างหาก

การลงนาม HMAC-SHA512 (การใช้งานด้วยตนเอง)

หากไม่ได้ใช้ SDK ให้ดำเนินการยืนยันตัวตนดังนี้:

import requests
import hmac
import hashlib
import base64
import time
import json

class KrakenAuth:
    def __init__(self, api_key, api_secret):
        self.api_key = api_key
        self.api_secret = base64.b64decode(api_secret)
        self.base_url = "https://api.kraken.com"
    
    def generate_signature(self, urlpath, data):
        # Nonce must be higher than any previous nonce used
        nonce = str(int(time.time() * 1000))
        data['nonce'] = nonce
        
        # Create message: nonce + POST data
        message = nonce + json.dumps(data, separators=(',', ':'))
        
        # Create HMAC-SHA512 signature
        signature = hmac.new(
            self.api_secret,
            urlpath.encode() + hashlib.sha256(message.encode()).digest(),
            hashlib.sha512
        ).hexdigest()
        
        return {
            'API-Key': self.api_key,
            'API-Sign': signature,
            'Content-Type': 'application/x-www-form-urlencoded'
        }, data
    
    def private_request(self, method, params=None):
        urlpath = f'/0/private/{method}'
        data = params or {}
        
        headers, signed_data = self.generate_signature(urlpath, data)
        
        response = requests.post(
            f"{self.base_url}{urlpath}",
            headers=headers,
            data=signed_data
        )
        
        return response.json()

# Usage
kraken = KrakenAuth(
    api_key="YOUR_API_KEY",
    api_secret="YOUR_BASE64_ENCODED_PRIVATE_KEY"
)

# Get account balance
balance = kraken.private_request('Balance')
print(balance)

สำคัญ: การจัดการ Nonce

Kraken กำหนดให้ nonces เพิ่มขึ้นอย่างเคร่งครัดต่อคีย์ API หากคุณมีหลายเธรดหรือหลายกระบวนการที่ใช้คีย์เดียวกัน จะเกิดความขัดแย้งและสร้างข้อผิดพลาด "EAPI:Invalid nonce" วิธีแก้ไข:

ใช้คีย์ API ที่แตกต่างกัน สำหรับอัลกอริทึมหรือบริการซื้อขายแต่ละรายการ
นำการซิงโครไนซ์ nonce ไปใช้ ผ่าน Redis หรือฐานข้อมูล หากไม่สามารถหลีกเลี่ยงการใช้คีย์ร่วมกันได้
ใช้การประทับเวลาแบบความละเอียดไมโครวินาที (คูณเวลา Unix ด้วย 1000) เพื่อลดโอกาสการชนกัน

SDK อย่างเป็นทางการ

Kraken มี SDK อย่างเป็นทางการสำหรับ Python และ Node.js พร้อมด้วย SDK ของชุมชนสำหรับ Go, Rust, Julia และภาษาอื่นๆ:

# Python
pip install python-kraken-sdk

# Node.js
npm install @kraken-api/sdk

SDK อย่างเป็นทางการจัดการการยืนยันตัวตน, การจัดการ nonce และการแยกวิเคราะห์ข้อผิดพลาดโดยอัตโนมัติ ใช้งานเหล่านี้เว้นแต่คุณมีความต้องการเฉพาะสำหรับการจัดการ HTTP แบบกำหนดเอง

การซื้อขายแบบสปอตด้วย REST API

Spot REST API มีฟังก์ชันการซื้อขายที่ครอบคลุมผ่านเอนด์พอยต์ที่มีเอกสารประกอบอย่างดี

ข้อมูลตลาด (สาธารณะ)

ดึงคู่การซื้อขายที่มีอยู่:

curl "https://api.kraken.com/0/public/AssetPairs"

รับข้อมูลราคาปัจจุบัน:

curl "https://api.kraken.com/0/public/Ticker?pair=XBTUSD"

Kraken ใช้สัญลักษณ์คู่ที่ไม่เป็นไปตามมาตรฐาน—XBT แทน BTC สำหรับ Bitcoin, XXBT ในเอนด์พอยต์เก่าบางส่วน, ZUSD แทน USD ควรตรวจสอบรหัสสินทรัพย์โดยใช้เอนด์พอยต์ AssetPairs เสมอก่อนทำการซื้อขาย

ดึงความลึกของสมุดคำสั่งซื้อ:

curl "https://api.kraken.com/0/public/Depth?pair=XBTUSD&count=10"

ยอดคงเหลือในบัญชี (ส่วนตัว)

balance = kraken.private_request('Balance')
print(balance)

รูปแบบการตอบกลับใช้รหัสสินทรัพย์เป็นคีย์ (ZUSD สำหรับ USD, XXBT สำหรับ Bitcoin):

{
  "error": [],
  "result": {
    "ZUSD": "1000.50",
    "XXBT": "0.2500"
  }
}

การส่งคำสั่งซื้อ

ส่งคำสั่งซื้อแบบ Limit buy:

order = kraken.private_request('AddOrder', {
    'pair': 'XBTUSD',
    'type': 'buy',
    'ordertype': 'limit',
    'price': '65000.00',
    'volume': '0.01',
    'oflags': 'post'  # Post-only flag
})

print(order)

ประเภทคำสั่งซื้อรวมถึง:

market: ดำเนินการทันทีที่ราคาที่ดีที่สุด
limit: ดำเนินการที่ราคาที่ระบุหรือดีกว่า
stop-loss: ทริกเกอร์คำสั่งซื้อแบบ Market เมื่อราคาทะลุเกณฑ์
take-profit: ตรงข้ามกับ stop-loss
trailing-stop: Stop แบบไดนามิกที่ติดตามการเคลื่อนไหวของราคา

การจัดการคำสั่งซื้อ

รายการคำสั่งซื้อที่เปิดอยู่:

open_orders = kraken.private_request('OpenOrders')
print(open_orders)

ยกเลิกคำสั่งซื้อ:

kraken.private_request('CancelOrder', {
    'txid': 'XXXXXX-XXXXXX-XXXXXX'
})

ยกเลิกคำสั่งซื้อทั้งหมด (การหยุดฉุกเฉิน):

kraken.private_request('CancelAll')

ประวัติการซื้อขาย

สอบถามการซื้อขายที่ดำเนินการแล้ว:

trades = kraken.private_request('TradesHistory', {
    'start': '1704067200',  # Unix timestamp
    'end': '1706659200'
})

เคล็ดลับระดับโปรApidog

ข้อมูลเรียลไทม์ด้วย WebSocket

การเรียกข้อมูลแบบ REST (polling) ทำให้เกิดความหน่วงที่ไม่สามารถยอมรับได้สำหรับการซื้อขายแบบอัลกอริทึม WebSocket API ของ Kraken สตรีมการอัปเดตสมุดคำสั่งซื้อ, การซื้อขาย และกิจกรรมบัญชีแบบเรียลไทม์

การเชื่อมต่อกับ WebSocket สาธารณะ

const WebSocket = require('ws');

const ws = new WebSocket('wss://ws.kraken.com');

ws.on('open', () => {
  console.log('Connected to Kraken public WebSocket');
  
  // Subscribe to ticker for BTC/USD
  ws.send(JSON.stringify({
    event: 'subscribe',
    pair: ['XBT/USD'],
    subscription: {
      name: 'ticker'
    }
  }));
});

ws.on('message', (data) => {
  const message = JSON.parse(data);
  
  // Ticker format: [channelID, tickerData, pair, channelName]
  if (Array.isArray(message) && message[2] === 'XBT/USD') {
    const [channelID, ticker, pair, channelName] = message;
    console.log(`BTC Price: Bid ${ticker.b[0]}, Ask ${ticker.a[0]}`);
  }
});

// Heartbeat every 30 seconds
setInterval(() => {
  ws.send(JSON.stringify({ event: 'ping' }));
}, 30000);

การสมัครสมาชิก WebSocket จะส่งคืนข้อมูลในรูปแบบอาร์เรย์พร้อม ID ช่องที่เป็นตัวเลข แมป ID เหล่านี้กับการสมัครสมาชิกของคุณเพื่อกำหนดเส้นทางข้อมูลให้ถูกต้อง

การสตรีมสมุดคำสั่งซื้อ

สมัครสมาชิกข้อมูลสมุดคำสั่งซื้อ Level 2:

ws.send(JSON.stringify({
  event: 'subscribe',
  pair: ['XBT/USD'],
  subscription: {
    name: 'book',
    depth: 25  // 25, 100, 500, or 1000 levels
  }
}));

ฟีดสมุดคำสั่งซื้อจะส่งสแนปช็อตตามด้วยการอัปเดตแบบเพิ่มหน่วย รักษาสถานะสมุดคำสั่งซื้อภายในเครื่องโดยการใช้เดลต้า:

let orderBook = { asks: {}, bids: {} };

ws.on('message', (data) => {
  const message = JSON.parse(data);
  
  if (message[1] === 'as' || message[1] === 'bs') {
    // Snapshot: initialize order book
    const [channelID, type, asks, bids] = message;
    orderBook.asks = Object.fromEntries(asks.map(([price, volume]) => [price, volume]));
    orderBook.bids = Object.fromEntries(bids.map(([price, volume]) => [price, volume]));
  } else if (message[1] === 'a' || message[1] === 'b') {
    // Update: apply delta
    const [channelID, type, delta] = message;
    const side = type === 'a' ? 'asks' : 'bids';
    
    delta.forEach(([price, volume]) => {
      if (volume === '0.00000000') {
        delete orderBook[side][price];
      } else {
        orderBook[side][price] = volume;
      }
    });
  }
});

การยืนยันตัวตน WebSocket ส่วนตัว

รับโทเค็น WebSocket ผ่าน REST:

token_response = kraken.private_request('GetWebSocketsToken')
token = token_response['result']['token']

เชื่อมต่อกับ WebSocket ส่วนตัว:

const privateWs = new WebSocket('wss://ws-auth.kraken.com');

privateWs.on('open', () => {
  // Authenticate
  privateWs.send(JSON.stringify({
    event: 'subscribe',
    subscription: {
      name: 'ownTrades',
      token: 'YOUR_WEBSOCKET_TOKEN'
    }
  }));
});

privateWs.on('message', (data) => {
  const message = JSON.parse(data);
  
  if (message[1] === 'ownTrades') {
    console.log('Your trade executed:', message[0]);
  }
});

โทเค็น WebSocket ส่วนตัวจะหมดอายุหลังจาก 15 นาที ใช้งานการรีเฟรชโทเค็นอัตโนมัติและตรรกะการเชื่อมต่อใหม่สำหรับระบบการผลิต

การซื้อขายสัญญาซื้อขายล่วงหน้าและคุณสมบัติขั้นสูง

Kraken Futures มีโครงสร้างพื้นฐานแยกต่างหากสำหรับการซื้อขายตราสารอนุพันธ์ พร้อมประเภทคำสั่งซื้อขั้นสูงและการคำนวณมาร์จิ้นพอร์ตโฟลิโอ

การยืนยันตัวตน Futures

Futures ใช้การยืนยันตัวตนแบบ Bearer token ที่แตกต่างจาก Spot HMAC:

import requests
import hmac
import hashlib
import base64
import json

class KrakenFuturesAuth:
    def __init__(self, api_key, api_secret):
        self.api_key = api_key
        self.api_secret = api_secret
        self.base_url = "https://futures.kraken.com/api/v3"
    
    def generate_signature(self, endpoint, method, body=None):
        nonce = str(int(time.time() * 1000))
        message = endpoint + method + nonce
        
        if body:
            message += json.dumps(body, separators=(',', ':'))
        
        signature = base64.b64encode(
            hmac.new(
                base64.b64decode(self.api_secret),
                message.encode(),
                hashlib.sha256
            ).digest()
        ).decode()
        
        return {
            'APIKey': self.api_key,
            'Nonce': nonce,
            'Authent': signature,
            'Content-Type': 'application/json'
        }
    
    def request(self, endpoint, method='GET', body=None):
        url = f"{self.base_url}{endpoint}"
        headers = self.generate_signature(endpoint, method, body)
        
        if method == 'GET':
            response = requests.get(url, headers=headers)
        else:
            response = requests.post(url, headers=headers, json=body)
        
        return response.json()

# Usage
futures = KrakenFuturesAuth('FUTURES_API_KEY', 'FUTURES_SECRET')

การส่งคำสั่งซื้อ Futures

ส่งคำสั่งซื้อแบบ Limit บน Bitcoin perpetual:

order = futures.request('/sendorder', 'POST', {
    'orderType': 'lmt',
    'side': 'buy',
    'size': 1,
    'limitPrice': 65000,
    'symbol': 'PI_XBTUSD'  # Perpetual Inverse BTC/USD
})

สัญลักษณ์ Futures ใช้ข้อตกลงที่แตกต่างกัน:

PI_XBTUSD: Perpetual Inverse Bitcoin/USD
PF_ETHUSD: Perpetual Linear Ethereum/USD
FI_XBTUSD_250228: สัญญาซื้อขายล่วงหน้าที่มีวันหมดอายุแน่นอน ซึ่งจะหมดอายุในวันที่ 28 กุมภาพันธ์ 2025

การดำเนินการแบบแบตช์

Futures API รองรับการส่งคำสั่งซื้อแบบแบตช์:

batch = futures.request('/batchorder', 'POST', {
    'batchOrder': [
        {
            'order': 'send',
            'order_tag': '1',
            'orderType': 'lmt',
            'symbol': 'PI_XBTUSD',
            'side': 'buy',
            'size': 1,
            'limitPrice': 64000
        },
        {
            'order': 'send',
            'order_tag': '2',
            'orderType': 'lmt',
            'symbol': 'PI_XBTUSD',
            'side': 'sell',
            'size': 1,
            'limitPrice': 66000
        }
    ]
})

คุณสมบัติคำสั่งซื้อขั้นสูง

Trailing Stops: ราคา Stop จะปรับตามการเคลื่อนไหวของตลาด
Take Profit / Stop Loss: คำสั่งซื้อแบบ Bracket สำหรับการบริหารความเสี่ยง
Post-Only: ทำให้แน่ใจว่าคำสั่งซื้อเพิ่มสภาพคล่อง (maker fees)
Reduce-Only: ป้องกันไม่ให้สถานะเพิ่มขึ้น

Dead Man's Switch

ยกเลิกคำสั่งซื้อทั้งหมดหากการเชื่อมต่อขาดหาย:

# Set 60-second timeout
kraken.private_request('CancelAllOrdersAfter', {
    'timeout': 60
})

นี่เป็นการสร้างตัวจับเวลาฝั่งเซิร์ฟเวอร์ — หากคุณไม่ส่งสัญญาณ heartbeat ภายใน 60 วินาที Kraken จะยกเลิกคำสั่งซื้อที่เปิดอยู่ทั้งหมดโดยอัตโนมัติ

บทสรุป

API ของ Kraken ให้การเข้าถึงตลาดคริปโตเคอร์เรนซีระดับสถาบันผ่านอินเทอร์เฟซ REST, WebSocket และ Futures โดยเฉพาะ คุณยืนยันตัวตนด้วยลายเซ็น HMAC-SHA512, จัดการลำดับ nonce อย่างระมัดระวัง และปรับขนาดได้ตั้งแต่การซื้อขายสปอตไปจนถึงสัญญาซื้อขายล่วงหน้าแบบมีเลเวอเรจ การจำกัดอัตราแบบแบ่งระดับรองรับกลยุทธ์ตั้งแต่การปรับสมดุลพอร์ตโฟลิโอทั่วไปไปจนถึงการสร้างตลาดความถี่สูง

เริ่มต้นด้วยสภาพแวดล้อมแซนด์บ็อกซ์เพื่อทดสอบการยืนยันตัวตนและการส่งคำสั่งซื้อ ใช้คีย์ API แยกกันสำหรับแต่ละกลยุทธ์การซื้อขายเพื่อหลีกเลี่ยงความขัดแย้งของ nonce นำการเชื่อมต่อ WebSocket มาใช้สำหรับข้อมูลเรียลไทม์ และ dead man's switches สำหรับการบริหารความเสี่ยง ตรวจสอบเฮดเดอร์การจำกัดอัตราและใช้ exponential backoff สำหรับข้อผิดพลาด 429

เมื่อสร้างแอปพลิเคชันซื้อขายคริปโต—ไม่ว่าจะทดสอบเอนด์พอยต์ของ Kraken, แก้ไขข้อผิดพลาดของลายเซ็นการยืนยันตัวตน หรือจัดการการรวม API หลายรายการ—ปรับปรุงขั้นตอนการทำงานการพัฒนาของคุณด้วย Apidog ซึ่งจัดการการทดสอบ API ด้วยภาพ, การสร้างเอกสารอัตโนมัติ และการทำงานร่วมกันเป็นทีม เพื่อให้คุณสามารถมุ่งเน้นไปที่ตรรกะการซื้อขายแทนที่จะต้องต่อสู้กับลายเซ็น HMAC

button