Cara Menggunakan Kraken API untuk Perdagangan Kripto yang Mulus

The Kraken API menyediakan antarmuka yang kuat bagi pengembang ke salah satu bursa mata uang kripto terkemuka di dunia. Baik Anda sedang membangun aplikasi perdagangan, memantau pasar, atau mengelola portofolio mata uang kripto, panduan ini akan membantu Anda menavigasi hal-hal penting dari kemampuan API Kraken dan pendekatan implementasi.

💡

Sebelum menyelami Kraken API, lihat Apidog—alat gratis yang menyederhanakan pengujian dan integrasi API. Antarmuka Apidog yang mudah digunakan memudahkan untuk melakukan debug dan mengoptimalkan alur kerja API Anda, sehingga menghemat waktu dan tenaga Anda.

button

Apa itu Kraken API?

API Kraken memungkinkan pengembang untuk mengakses fungsionalitas bursa secara terprogram melalui antarmuka RESTful. Dengan API ini, Anda dapat:

Mengakses data pasar waktu nyata (harga, buku pesanan, perdagangan)
Menempatkan dan mengelola pesanan perdagangan
Memantau saldo dan posisi akun
Memproses deposit dan penarikan
Mengakses data perdagangan historis

Menyiapkan Akses API

Membuat Akun Kraken Anda

Sebelum menggunakan API, Anda perlu:

Mendaftar akun Kraken di kraken.com
Menyelesaikan persyaratan verifikasi berdasarkan kebutuhan penggunaan Anda
Mengaktifkan autentikasi dua faktor (2FA) untuk keamanan yang ditingkatkan

Membuat Kunci API

Untuk berinteraksi dengan API, buat kunci API dengan izin yang sesuai:

Masuk ke akun Kraken Anda
Navigasi ke Connection & API

3. Klik Generate New Key

4. Atur izin yang sesuai:

Query: Akses hanya baca ke informasi akun
Trade: Kemampuan untuk menempatkan dan membatalkan pesanan
Deposit: Hasilkan alamat deposit
Withdraw: Buat permintaan penarikan

⚠️ PERINGATAN KEAMANAN
- Simpan kunci API dengan aman dan jangan pernah membagikan kunci pribadi Anda
- Batasi izin kunci API hanya untuk apa yang diperlukan
- Pertimbangkan untuk menerapkan batasan alamat IP

Memahami Struktur API

Kraken API diatur ke dalam struktur logis:

URL Dasar dan Titik Akhir API

Semua permintaan API dimulai dengan URL dasar: https://api.kraken.com

Versi API saat ini ditandai dengan /0/ di jalur URL, diikuti oleh salah satu dari:

/public/ - Titik akhir yang tidak memerlukan autentikasi
/private/ - Titik akhir yang memerlukan autentikasi dengan kunci API Anda

Format Respons

Semua respons API mengikuti format JSON standar:

{
  "error": [],
  "result": { /* Data respons */ }
}

Membuat Permintaan API Pertama Anda

Permintaan API Publik

Titik akhir publik menyediakan data pasar tanpa memerlukan autentikasi.

Contoh: Mendapatkan Informasi Ticker

import requests

# Dapatkan informasi ticker untuk Bitcoin dalam USD
response = requests.get('https://api.kraken.com/0/public/Ticker?pair=XBTUSD')
ticker_data = response.json()

if not ticker_data['error']:
    btc_data = ticker_data['result']['XXBTZUSD']
    print(f"Harga Perdagangan Terakhir BTC/USD: {btc_data['c'][0]}")
    print(f"Volume 24 jam BTC/USD: {btc_data['v'][1]}")
else:
    print(f"Kesalahan: {ticker_data['error']}")

Contoh: Data Buku Pesanan

fetch('https://api.kraken.com/0/public/Depth?pair=ETHUSD&count=5')
  .then(response => response.json())
  .then(data => {
    if (data.error.length === 0) {
      const orderbook = data.result.XETHZUSD;
      console.log("Penawaran Teratas 5 Buku Pesanan ETH/USD:", orderbook.bids);
      console.log("Permintaan Teratas 5 Buku Pesanan ETH/USD:", orderbook.asks);
    }
  });

Autentikasi API Privat

Titik akhir privat memerlukan autentikasi dengan kunci API Anda melalui proses yang melibatkan:

Menghasilkan nonce (angka yang meningkat)
Membuat tanda tangan permintaan menggunakan HMAC-SHA512
Mengirim permintaan dengan kunci API dan tanda tangan Anda

Implementasi Autentikasi

import time
import base64
import hashlib
import hmac
import urllib.parse
import requests

def kraken_request(api_key, api_sec, endpoint, data=None):
    """Buat permintaan terautentikasi ke Kraken API"""
    if data is None:
        data = {}
        
    api_url = "https://api.kraken.com"
    
    # Tambahkan nonce ke data
    data['nonce'] = str(int(time.time() * 1000))
    
    # Enkode data untuk tanda tangan
    encoded_data = urllib.parse.urlencode(data)
    
    # Buat tanda tangan
    signature_data = (data['nonce'] + encoded_data).encode()
    message = endpoint.encode() + hashlib.sha256(signature_data).digest()
    signature = hmac.new(base64.b64decode(api_sec), message, hashlib.sha512)
    signature_digest = base64.b64encode(signature.digest()).decode()
    
    # Atur header
    headers = {
        'API-Key': api_key,
        'API-Sign': signature_digest
    }
    
    # Kirim permintaan
    response = requests.post(api_url + endpoint, headers=headers, data=data)
    return response.json()

Fungsionalitas API Inti

Informasi Akun

Memeriksa Saldo Akun

balance = kraken_request(api_key, api_secret, "/0/private/Balance")

if not balance['error']:
    for asset, amount in balance['result'].items():
        print(f"{asset}: {amount}")

Manajemen Pesanan

Menempatkan Pesanan Pasar

# Parameter untuk membeli 0,01 BTC dengan harga pasar
order_params = {
    'pair': 'XBTUSD',
    'type': 'buy',
    'ordertype': 'market',
    'volume': '0.01'
}

order_result = kraken_request(api_key, api_secret, "/0/private/AddOrder", order_params)

if not order_result['error']:
    print(f"Pesanan ditempatkan! ID Transaksi: {order_result['result']['txid'][0]}")

Menempatkan Pesanan Batas

# Parameter untuk menjual 0,01 BTC dengan harga $50.000
limit_params = {
    'pair': 'XBTUSD',
    'type': 'sell',
    'ordertype': 'limit',
    'price': '50000',
    'volume': '0.01'
}

limit_result = kraken_request(api_key, api_secret, "/0/private/AddOrder", limit_params)

Menanyakan Pesanan Terbuka

open_orders = kraken_request(api_key, api_secret, "/0/private/OpenOrders")

if not open_orders['error']:
    orders = open_orders['result']['open']
    for order_id, details in orders.items():
        print(f"ID: {order_id}")
        print(f"Jenis: {details['descr']['type']} {details['descr']['ordertype']}")
        print(f"Pasangan: {details['descr']['pair']}")

Menggunakan APIdog dengan Kraken API

APIdog menawarkan platform yang kuat untuk mengembangkan, menguji, dan mendokumentasikan integrasi Kraken API Anda. Berikut cara memanfaatkan APIdog untuk pengembangan yang disederhanakan:

Menyiapkan Kraken API di APIdog

Buat Proyek Baru

Luncurkan APIdog dan buat proyek baru
Siapkan lingkungan untuk pengujian Kraken API

Konfigurasikan Variabel Lingkungan

Buat variabel untuk API_KEY, API_SECRET, dan API_URL
Atur API_URL ke https://api.kraken.com

Impor atau Buat Titik Akhir

Impor spesifikasi Kraken API atau buat koleksi secara manual
Atur titik akhir ke dalam folder logis (Data Pasar, Perdagangan, Akun, dll.)

Menerapkan Autentikasi Kraken di APIdog

APIdog memudahkan untuk menyiapkan autentikasi khusus Kraken:

Buat Skrip Pra-permintaan untuk menghasilkan autentikasi yang diperlukan:

// Skrip pra-permintaan untuk autentikasi Kraken
const crypto = require('crypto-js');

// Dapatkan variabel lingkungan
const apiKey = pm.environment.get("API_KEY");
const apiSecret = pm.environment.get("API_SECRET");

// Tambahkan nonce ke badan permintaan
const nonce = Date.now() * 1000;
pm.request.body.update({
    mode: 'urlencoded',
    urlencoded: [
        ...pm.request.body.urlencoded.all(),
        {key: 'nonce', value: nonce.toString()}
    ]
});

// Dapatkan jalur permintaan
const path = pm.request.url.getPathWithQuery().replace(/\?.*/, '');

// Buat tanda tangan
const postData = pm.request.body.urlencoded.toString();
const message = path + crypto.SHA256(nonce.toString() + postData).toString();
const signature = crypto.enc.Base64.stringify(
    crypto.HmacSHA512(message, crypto.enc.Base64.parse(apiSecret))
);

// Atur header
pm.request.headers.add({key: 'API-Key', value: apiKey});
pm.request.headers.add({key: 'API-Sign', value: signature});

Menguji dan Mendokumentasikan dengan APIdog

Buat Permintaan Pengujian

Siapkan permintaan untuk operasi umum seperti mendapatkan data ticker, menempatkan pesanan, dll.
Gunakan pembuat permintaan untuk mengonfigurasi parameter yang tepat

Tambahkan Skrip Pengujian

Validasi respons API dengan skrip pengujian
Periksa kesalahan dan struktur data yang diharapkan

// Contoh skrip pengujian untuk titik akhir saldo
pm.test("Status respons adalah 200", () => {
  pm.response.to.have.status(200);
});

pm.test("Tidak ada kesalahan yang dikembalikan", () => {
  const response = pm.response.json();
  pm.expect(response.error).to.be.an('array').that.is.empty;
});

pm.test("Data saldo ada", () => {
  const response = pm.response.json();
  pm.expect(response.result).to.exist.and.to.be.an('object');
});

Hasilkan Dokumentasi

Gunakan alat dokumentasi APIdog untuk membuat panduan API yang komprehensif
Sertakan contoh, deskripsi, dan sampel respons

Bagikan dan Berkolaborasi

Bagikan koleksi Kraken API Anda dengan anggota tim
Gunakan fitur kolaborasi APIdog untuk pengembangan tim

Server Mock APIdog untuk Pengembangan

Saat mengembangkan, Anda dapat menggunakan server mock APIdog untuk mensimulasikan respons Kraken API:

Buat contoh respons untuk setiap titik akhir
Konfigurasikan aturan respons berdasarkan parameter permintaan
Uji aplikasi Anda terhadap respons mock sebelum ditayangkan

Pendekatan ini memungkinkan siklus pengembangan yang lebih cepat dan melindungi Anda dari mencapai batas laju API selama pengembangan.

Praktik Terbaik untuk Integrasi Kraken API

Pembatasan Laju dan Optimalisasi

Kraken menerapkan batas laju tertentu:

Titik akhir publik: 1 permintaan per detik
Titik akhir privat: 15-20 permintaan per menit

Untuk menangani ini secara efektif:

Terapkan pembatasan dalam kode Anda
Gunakan WebSocket untuk data waktu nyata alih-alih panggilan REST API yang sering
Batch kueri bila memungkinkan

Penanganan Kesalahan

Terapkan penanganan kesalahan yang kuat untuk interaksi API:

def safe_api_call(api_function, max_retries=3):
    """Pembungkus untuk panggilan API dengan logika coba lagi"""
    retries = 0
    while retries < max_retries:
        try:
            response = api_function()
            
            if 'error' in response and response['error']:
                error = response['error'][0]
                
                # Tangani pembatasan laju
                if 'EAPI:Rate limit' in error:
                    sleep_time = (2 ** retries)  # Mundur eksponensial
                    time.sleep(sleep_time)
                    retries += 1
                    continue
                else:
                    return None
            
            return response['result']
            
        except Exception as e:
            time.sleep(2 ** retries)
            retries += 1
    
    return None

Pertimbangan Keamanan

Simpan kredensial API dengan aman - Jangan pernah menyandikannya secara permanen dalam aplikasi Anda
Terapkan batasan IP di pengaturan kunci API Kraken Anda
Gunakan izin minimum yang diperlukan untuk setiap kunci API
Pantau penggunaan API untuk akses tidak sah
Rotasi kunci API secara berkala

Kasus Penggunaan Umum

Pemantauan Data Pasar

def monitor_price(pair, interval=60):
    """Pantau harga secara berkala"""
    while True:
        response = requests.get(f'https://api.kraken.com/0/public/Ticker?pair={pair}')
        data = response.json()
        
        if not data['error']:
            for p, info in data['result'].items():
                price = info['c'][0]
                print(f"Harga saat ini {pair}: {price}")
        
        time.sleep(interval)

Bot Perdagangan Sederhana

def simple_trading_strategy(pair, api_key, api_secret):
    """Contoh strategi perdagangan sederhana"""
    # Dapatkan saldo akun
    balance = kraken_request(api_key, api_secret, "/0/private/Balance")
    
    # Dapatkan harga saat ini
    ticker = requests.get(f'https://api.kraken.com/0/public/Ticker?pair={pair}')
    ticker_data = ticker.json()
    
    if not ticker_data['error']:
        current_price = float(ticker_data['result'][pair]['c'][0])
        
        # Strategi sederhana: beli jika harga turun 5% dari kemarin
        yesterday_close = float(ticker_data['result'][pair]['o'])
        
        if current_price < yesterday_close * 0.95:
            print(f"Harga turun lebih dari 5% - peluang membeli")
            # Terapkan logika beli

Kesimpulan

Kraken API menyediakan alat yang ampuh untuk perdagangan mata uang kripto dan manajemen portofolio. Panduan ini telah membahas hal-hal penting dari akses API, autentikasi, dan operasi umum. Dengan memanfaatkan alat seperti APIdog untuk pengembangan dan pengujian, Anda dapat membangun aplikasi yang kuat yang berinteraksi dengan mulus dengan bursa Kraken.

Ingatlah untuk selalu merujuk ke dokumentasi resmi Kraken API untuk informasi terbaru dan referensi titik akhir terperinci. Saat Anda menjadi lebih nyaman dengan dasar-dasarnya, Anda dapat menjelajahi fitur-fitur canggih seperti koneksi WebSocket untuk data waktu nyata dan strategi perdagangan yang lebih canggih.

Baik Anda sedang membangun pelacak portofolio pribadi, menerapkan perdagangan algoritmik, atau membuat solusi mata uang kripto tingkat perusahaan, menguasai Kraken API membuka kemungkinan signifikan dalam ekosistem aset digital.