Cara Menggunakan Kraken API: Panduan Lengkap untuk Trading

Bayangkan memiliki akses ke salah satu bursa mata uang kripto paling likuid di dunia melalui API yang teruji dan terpercaya yang mengelola kontrak berjangka dan perdagangan spot. Kraken menyediakan hal tersebut, menawarkan antarmuka WebSocket dan REST ke bursa yang didirikan pada tahun 2011 dan melayani lebih dari 10 juta pengguna di 190 negara dengan likuiditas yang luas di lebih dari 200 pasangan perdagangan.

API perdagangan mata uang kripto terbagi menjadi dua kategori: yang dirancang untuk kenyamanan ritel dan yang dibangun untuk keandalan institusional. Banyak bursa memprioritaskan aplikasi seluler di atas stabilitas API, mengakibatkan batasan tarif yang memperlambat strategi algoritmik dan dokumentasi yang tertinggal dari rilis fitur. Kraken menghilangkan titik-titik gesekan ini dengan menawarkan akses API berjenjang berdasarkan volume perdagangan, lingkungan sandbox yang komprehensif, dan titik akhir khusus untuk pedagang frekuensi tinggi. Anda membangun strategi otomatis yang dapat diskalakan dari skrip hobi hingga sistem kelas institusional.

Daftar Isi:

• Memahami Arsitektur API Kraken
• Otentikasi dan Penyiapan Kunci API
• Perdagangan Spot dengan API REST
• Data Real-Time dengan WebSocket
• Perdagangan Berjangka dan Fitur Tingkat Lanjut
• Kesimpulan

Memahami Arsitektur API Kraken

Kraken mengoperasikan tiga ekosistem API yang berbeda: Spot REST, Futures REST, dan WebSocket. Memahami arsitektur ini membantu Anda memilih jalur integrasi yang tepat.

API REST Spot

API REST Spot menyediakan akses ke fungsionalitas bursa inti Kraken. Ini diatur menjadi titik akhir publik (data pasar, informasi ticker, kedalaman buku pesanan) dan titik akhir pribadi (saldo akun, manajemen pesanan, pendanaan). Semua permintaan menggunakan HTTPS dengan TLS 1.2 atau lebih tinggi.

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

Titik akhir publik tidak memerlukan otentikasi. Titik akhir pribadi menggunakan penandatanganan permintaan HMAC-SHA512 dengan kunci API. Format respons bervariasi—beberapa titik akhir mengembalikan array di mana elemen pertama adalah string kesalahan (desain lama), sementara titik akhir yang lebih baru menggunakan objek JSON standar.

API REST Berjangka

Kraken Futures beroperasi secara terpisah dari bursa spot dengan infrastruktur API-nya sendiri. Ini mendukung perpetual swap dan kontrak berjangka dengan jatuh tempo tetap pada mata uang kripto dengan leverage hingga 50x.

URL Dasar:

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

API Berjangka menggunakan mekanisme otentikasi dan struktur titik akhir yang berbeda dibandingkan dengan Spot. Anda memerlukan kunci API terpisah yang dibuat di futures.kraken.com, berbeda dari kredensial perdagangan spot Anda.

API WebSocket

Kraken menyediakan aliran data real-time melalui dua server WebSocket:

• Publik: wss://ws.kraken.com — Data pasar, buku pesanan, perdagangan
• Pribadi: wss://ws-auth.kraken.com — Pembaruan akun, status pesanan, perubahan saldo

Tidak seperti polling REST, koneksi WebSocket mendorong data saat tersedia, mengurangi latensi dari ratusan milidetik menjadi puluhan milidetik. Server publik tidak memerlukan otentikasi; server pribadi memerlukan token WebSocket yang diperoleh melalui API REST.

Pembatasan Tarif (Rate Limiting)

Kraken menerapkan pembatasan tarif berbasis tingkatan:

• Pemula: 60 panggilan per menit (publik), 30 panggilan per menit (pribadi)
• Menengah: 125 panggilan per menit (publik), 60 panggilan per menit (pribadi)
• Pro: 250+ panggilan per menit berdasarkan volume perdagangan 30 hari

Melebihi batasan akan menghasilkan kesalahan HTTP 429 dengan header `Retry-After` yang menunjukkan kapan Anda dapat melanjutkan permintaan.

Otentikasi dan Penyiapan Kunci API

Kraken menggunakan otentikasi HMAC-SHA512 dengan perlindungan replay berbasis nonce. Ini memerlukan implementasi yang cermat untuk menghindari kesalahan "Invalid nonce" yang umum dalam aplikasi multi-thread.

Membuat Kunci API

Navigasi ke Akun → Keamanan → API di dasbor Kraken Anda:

1. Klik "Buat Kunci Baru"
2. Pilih izin:

• Query: Membaca saldo akun, pesanan terbuka, riwayat perdagangan
• Trade: Menempatkan dan membatalkan pesanan
• Withdraw: Mentransfer dana (gunakan dengan hati-hati)
• Deposit: Melihat alamat dan metode setoran

3.  Tentukan daftar putih IP (direkomendasikan untuk produksi)

4.  Simpan Kunci API dan Kunci Pribadi dengan aman—Kraken tidak akan pernah menampilkan Kunci Pribadi lagi

Untuk perdagangan Berjangka, ulangi proses ini di futures.kraken.com/settings/api. Lingkungan sandbox di demo-futures.kraken.com menggunakan kredensial terpisah.

Penandatanganan HMAC-SHA512 (Implementasi Manual)

Jika tidak menggunakan SDK, implementasikan otentikasi sebagai berikut:

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 harus lebih tinggi dari nonce sebelumnya yang digunakan
        nonce = str(int(time.time() * 1000))
        data['nonce'] = nonce
        
        # Buat pesan: nonce + data POST
        message = nonce + json.dumps(data, separators=(',', ':'))
        
        # Buat tanda tangan HMAC-SHA512
        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()

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

# Dapatkan saldo akun
balance = kraken.private_request('Balance')
print(balance)

Penting: Manajemen Nonce

Kraken memerlukan nonce yang terus meningkat secara ketat per kunci API. Jika Anda memiliki beberapa thread atau proses yang menggunakan kunci yang sama, mereka akan berkonflik dan menghasilkan kesalahan "EAPI:Invalid nonce". Solusi:

1. Gunakan kunci API yang berbeda untuk setiap algoritma atau layanan perdagangan
2. Terapkan sinkronisasi nonce melalui Redis atau database jika berbagi kunci tidak dapat dihindari
3. Gunakan stempel waktu presisi mikrodetik (kalikan waktu Unix dengan 1000) untuk mengurangi kemungkinan tabrakan

SDK Resmi

Kraken menyediakan SDK Python dan Node.js resmi, dengan SDK komunitas untuk Go, Rust, Julia, dan bahasa lainnya:

# Python
pip install python-kraken-sdk

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

SDK resmi menangani otentikasi, manajemen nonce, dan penguraian kesalahan secara otomatis. Gunakan SDK tersebut kecuali Anda memiliki persyaratan khusus untuk penanganan HTTP kustom.

Perdagangan Spot dengan API REST

API REST Spot menyediakan fungsionalitas perdagangan yang komprehensif melalui titik akhir yang terdokumentasi dengan baik.

Data Pasar (Publik)

Ambil pasangan perdagangan yang tersedia:

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

Dapatkan informasi ticker:

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

Kraken menggunakan simbol pasangan non-standar—XBT alih-alih BTC untuk Bitcoin, XXBT di beberapa titik akhir lama, ZUSD alih-alih USD. Selalu verifikasi kode aset menggunakan titik akhir AssetPairs sebelum berdagang.

Ambil kedalaman buku pesanan:

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

Saldo Akun (Pribadi)

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

Format respons menggunakan kode aset sebagai kunci (ZUSD untuk USD, XXBT untuk Bitcoin):

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

Menempatkan Pesanan

Tempatkan pesanan beli limit:

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

print(order)

Jenis pesanan meliputi:

• market: Eksekusi segera pada harga terbaik yang tersedia
• limit: Eksekusi pada harga yang ditentukan atau lebih baik
• stop-loss: Memicu pesanan pasar ketika harga melewati ambang batas
• take-profit: Kebalikan dari stop-loss
• trailing-stop: Stop dinamis yang mengikuti pergerakan harga

Manajemen Pesanan

Daftar pesanan terbuka:

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

Batalkan pesanan:

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

Batalkan semua pesanan (penghentian darurat):

kraken.private_request('CancelAll')

Riwayat Perdagangan

Permintaan perdagangan yang dieksekusi:

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

ProTipApidog

Data Real-Time dengan WebSocket

Polling REST memperkenalkan latensi yang tidak dapat diterima untuk perdagangan algoritmik. API WebSocket Kraken mengalirkan pembaruan buku pesanan, perdagangan, dan peristiwa akun secara real-time.

Menghubungkan ke WebSocket Publik

const WebSocket = require('ws');

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

ws.on('open', () => {
  console.log('Terhubung ke WebSocket publik Kraken');
  
  // Berlangganan ticker untuk BTC/USD
  ws.send(JSON.stringify({
    event: 'subscribe',
    pair: ['XBT/USD'],
    subscription: {
      name: 'ticker'
    }
  }));
});

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

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

Langganan WebSocket mengembalikan data dalam format array dengan ID saluran numerik. Petakan ID ini ke langganan Anda untuk merutekan data dengan benar.

Streaming Buku Pesanan

Berlangganan data buku pesanan Level 2:

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

Umpan buku mengirimkan snapshot diikuti dengan pembaruan inkremental. Pertahankan status buku pesanan lokal dengan menerapkan delta:

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

ws.on('message', (data) => {
  const message = JSON.parse(data);
  
  if (message[1] === 'as' || message[1] === 'bs') {
    // Snapshot: inisialisasi buku pesanan
    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') {
    // Pembaruan: terapkan 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;
      }
    });
  }
});

Otentikasi WebSocket Pribadi

Dapatkan token WebSocket melalui REST:

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

Hubungkan ke WebSocket pribadi:

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

privateWs.on('open', () => {
  // Otentikasi
  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('Perdagangan Anda dieksekusi:', message[0]);
  }
});

Token WebSocket pribadi kedaluwarsa setelah 15 menit. Terapkan logika penyegaran token otomatis dan koneksi ulang untuk sistem produksi.

Perdagangan Berjangka dan Fitur Tingkat Lanjut

Kraken Futures menyediakan infrastruktur terpisah untuk perdagangan derivatif dengan jenis pesanan tingkat lanjut dan margining portofolio.

Otentikasi Berjangka

Berjangka menggunakan otentikasi token Bearer yang berbeda dari 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()

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

Penempatan Pesanan Berjangka

Tempatkan pesanan limit pada Bitcoin perpetual:

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

Simbol berjangka menggunakan konvensi yang berbeda:

• PI_XBTUSD: Bitcoin/USD Inverse Perpetual
• PF_ETHUSD: Ethereum/USD Linear Perpetual
• FI_XBTUSD_250228: Kontrak berjangka jatuh tempo tetap yang kedaluwarsa 28 Februari 2025

Operasi Batch

API Berjangka mendukung pengiriman pesanan batch:

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
        }
    ]
})

Fitur Pesanan Tingkat Lanjut

• Trailing Stops: Harga stop menyesuaikan dengan pergerakan pasar
• Take Profit / Stop Loss: Pesanan bracket untuk manajemen risiko
• Post-Only: Memastikan pesanan menambah likuiditas (biaya maker)
• Reduce-Only: Mencegah posisi meningkat

Dead Man's Switch

Batalkan semua pesanan jika koneksi terputus:

# Atur batas waktu 60 detik
kraken.private_request('CancelAllOrdersAfter', {
    'timeout': 60
})

Ini menciptakan penghitung waktu sisi server—jika Anda tidak mengirim heartbeat dalam waktu 60 detik, Kraken secara otomatis membatalkan semua pesanan terbuka.

Kesimpulan

API Kraken menyediakan akses tingkat institusional ke pasar mata uang kripto melalui antarmuka REST, WebSocket, dan Futures khusus. Anda melakukan otentikasi dengan tanda tangan HMAC-SHA512, mengelola urutan nonce dengan hati-hati, dan skalakan dari perdagangan spot ke berjangka dengan leverage. Batasan tarif berjenjang mengakomodasi strategi mulai dari penyeimbangan portofolio kasual hingga pembuatan pasar frekuensi tinggi.

Mulailah dengan lingkungan sandbox untuk menguji otentikasi dan penempatan pesanan. Gunakan kunci API terpisah untuk setiap strategi perdagangan untuk menghindari konflik nonce. Terapkan koneksi WebSocket untuk data real-time dan dead man's switch untuk manajemen risiko. Pantau header batas tarif dan terapkan exponential backoff untuk kesalahan 429.

Saat membangun aplikasi perdagangan kripto—baik menguji titik akhir Kraken, men-debug tanda tangan otentikasi, atau mengelola beberapa integrasi API—sederhanakan alur kerja pengembangan Anda dengan Apidog. Ini menangani pengujian API visual, pembuatan dokumentasi otomatis, dan kolaborasi tim sehingga Anda dapat fokus pada logika perdagangan daripada bergulat dengan tanda tangan HMAC.