Kraken API nutzen: Vollständige Anleitung für den Handel

Stellen Sie sich vor, Sie hätten über eine bewährte API, die Futures-Kontrakte und Spot-Handel verwaltet, Zugang zu einer der liquidesten Kryptowährungsbörsen der Welt. Kraken bietet genau das und stellt WebSocket- und REST-Schnittstellen zu einer Börse bereit, die 2011 gegründet wurde und über 10 Millionen Nutzern in 190 Ländern mit umfangreicher Liquidität in über 200 Handelspaaren dient.

Kryptowährungshandels-APIs lassen sich in zwei Kategorien einteilen: solche, die für die Bequemlichkeit von Privatanlegern entwickelt wurden, und solche, die für institutionelle Zuverlässigkeit gebaut wurden. Viele Börsen priorisieren mobile Apps gegenüber der API-Stabilität, was zu Ratenbegrenzungen führt, die algorithmische Strategien drosseln, und zu einer Dokumentation, die den Funktionsfreigaben hinterherhinkt. Kraken beseitigt diese Reibungspunkte, indem es gestuften API-Zugang basierend auf dem Handelsvolumen, umfassende Sandbox-Umgebungen und dedizierte Endpunkte für Hochfrequenzhändler anbietet. Sie können automatisierte Strategien entwickeln, die von Hobby-Skripten bis hin zu Systemen auf institutionellem Niveau skalieren.

Inhaltsverzeichnis:

• Kraken's API-Architektur verstehen
• Authentifizierung und API-Schlüssel-Einrichtung
• Spot-Handel mit der REST-API
• Echtzeitdaten mit WebSocket
• Futures-Handel und erweiterte Funktionen
• Fazit

Kraken's API-Architektur verstehen

Kraken betreibt drei unterschiedliche API-Ökosysteme: Spot REST, Futures REST und WebSocket. Das Verständnis dieser Architekturen hilft Ihnen, den richtigen Integrationspfad zu wählen.

Spot-REST-API

Die Spot-REST-API bietet Zugriff auf die Kernfunktionalität der Kraken-Börse. Sie ist in öffentliche Endpunkte (Marktdaten, Ticker-Informationen, Orderbuchtiefe) und private Endpunkte (Kontostand, Auftragsverwaltung, Finanzierung) unterteilt. Alle Anfragen verwenden HTTPS mit TLS 1.2 oder höher.

Basis-URL: https://api.kraken.com/0

Öffentliche Endpunkte erfordern keine Authentifizierung. Private Endpunkte verwenden die HMAC-SHA512-Anforderungssignierung mit API-Schlüsseln. Die Antwortformate variieren – einige Endpunkte geben Arrays zurück, bei denen das erste Element eine Fehlerzeichenfolge ist (veraltetes Design), während neuere Endpunkte Standard-JSON-Objekte verwenden.

Futures-REST-API

Kraken Futures arbeitet getrennt von der Spot-Börse mit einer eigenen API-Infrastruktur. Es unterstützt Perpetual Swaps und Termingeschäfte mit fester Laufzeit auf Kryptowährungen mit bis zu 50-facher Hebelwirkung.

Basis-URLs:

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

Die Futures-API verwendet im Vergleich zur Spot-API unterschiedliche Authentifizierungsmechanismen und Endpunktstrukturen. Sie benötigen separate API-Schlüssel, die unter futures.kraken.com generiert werden und sich von Ihren Spot-Handelsanmeldeinformationen unterscheiden.

WebSocket-API

Kraken stellt Echtzeit-Datenströme über zwei WebSocket-Server bereit:

• Öffentlich: wss://ws.kraken.com — Marktdaten, Orderbücher, Trades
• Privat: wss://ws-auth.kraken.com — Kontoaktualisierungen, Auftragsstatus, Saldoänderungen

Im Gegensatz zum REST-Polling übertragen WebSocket-Verbindungen Daten, sobald sie verfügbar sind, wodurch die Latenz von Hunderten von Millisekunden auf Zehner von Millisekunden reduziert wird. Der öffentliche Server erfordert keine Authentifizierung; der private Server erfordert ein WebSocket-Token, das über die REST-API bezogen wird.

Ratenbegrenzung

Kraken implementiert eine gestaffelte Ratenbegrenzung:

• Starter: 60 Aufrufe pro Minute (öffentlich), 30 Aufrufe pro Minute (privat)
• Intermediate: 125 Aufrufe pro Minute (öffentlich), 60 Aufrufe pro Minute (privat)
• Pro: 250+ Aufrufe pro Minute basierend auf dem 30-Tage-Handelsvolumen

Das Überschreiten der Limits führt zu HTTP 429-Fehlern mit Retry-After-Headern, die angeben, wann Sie Anfragen wieder aufnehmen können.

Authentifizierung und API-Schlüssel-Einrichtung

Kraken verwendet die HMAC-SHA512-Authentifizierung mit Nonce-basierter Replay-Schutz. Dies erfordert eine sorgfältige Implementierung, um „Invalid nonce“-Fehler zu vermeiden, die in Multithread-Anwendungen häufig auftreten.

API-Schlüssel generieren

Navigieren Sie in Ihrem Kraken-Dashboard zu Konto → Sicherheit → API:

1. Klicken Sie auf „Neuen Schlüssel generieren“
2. Berechtigungen auswählen:

• Abfrage: Kontostand, offene Aufträge, Handelsverlauf lesen
• Handel: Aufträge platzieren und stornieren
• Auszahlung: Gelder transferieren (vorsichtig verwenden)
• Einzahlung: Einzahlungsadressen und -methoden anzeigen

3.  IP-Whitelisting angeben (für die Produktion empfohlen)

4.  API-Schlüssel und Privaten Schlüssel sicher speichern – Kraken zeigt den Privaten Schlüssel nie wieder an

Für den Futures-Handel wiederholen Sie diesen Vorgang unter futures.kraken.com/settings/api. Die Sandbox-Umgebung unter demo-futures.kraken.com verwendet separate Anmeldeinformationen.

HMAC-SHA512-Signierung (manuelle Implementierung)

Wenn Sie kein SDK verwenden, implementieren Sie die Authentifizierung wie folgt:

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)

Kritisch: Nonce-Verwaltung

Kraken erfordert streng aufsteigende Nonces pro API-Schlüssel. Wenn Sie mehrere Threads oder Prozesse haben, die denselben Schlüssel verwenden, kommt es zu Konflikten und „EAPI:Invalid nonce“-Fehlern. Lösungen:

1. Verwenden Sie unterschiedliche API-Schlüssel für jeden Handelsalgorithmus oder Dienst
2. Implementieren Sie die Nonce-Synchronisierung über Redis oder eine Datenbank, wenn die gemeinsame Nutzung von Schlüsseln unvermeidlich ist
3. Verwenden Sie Zeitstempel mit Mikrosekundenpräzision (Unix-Zeit mit 1000 multiplizieren), um die Kollisionswahrscheinlichkeit zu reduzieren

Offizielle SDKs

Kraken bietet offizielle Python- und Node.js-SDKs sowie Community-SDKs für Go, Rust, Julia und andere Sprachen:

# Python
pip install python-kraken-sdk

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

Offizielle SDKs übernehmen Authentifizierung, Nonce-Verwaltung und Fehleranalyse automatisch. Verwenden Sie sie, es sei denn, Sie haben spezielle Anforderungen für die benutzerdefinierte HTTP-Behandlung.

Spot-Handel mit der REST-API

Die Spot-REST-API bietet umfassende Handelsfunktionen über gut dokumentierte Endpunkte.

Marktdaten (Öffentlich)

Verfügbare Handelspaare abrufen:

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

Ticker-Informationen abrufen:

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

Kraken verwendet nicht-standardisierte Paarsymbole – XBT anstelle von BTC für Bitcoin, XXBT in einigen älteren Endpunkten, ZUSD anstelle von USD. Überprüfen Sie die Asset-Codes immer mit dem AssetPairs-Endpunkt, bevor Sie handeln.

Orderbuchtiefe abrufen:

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

Kontostand (Privat)

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

Das Antwortformat verwendet Asset-Codes als Schlüssel (ZUSD für USD, XXBT für Bitcoin):

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

Aufträge platzieren

Eine Limit-Kauforder platzieren:

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

print(order)

Auftragstypen umfassen:

• market: Sofort zum besten verfügbaren Preis ausführen
• limit: Zum angegebenen Preis oder besser ausführen
• stop-loss: Marktauftrag auslösen, wenn der Preis eine Schwelle überschreitet
• take-profit: Das Gegenteil von Stop-Loss
• trailing-stop: Dynamischer Stop, der den Preisbewegungen folgt

Auftragsverwaltung

Offene Aufträge auflisten:

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

Einen Auftrag stornieren:

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

Alle Aufträge stornieren (Notstopp):

kraken.private_request('CancelAll')

Handelsverlauf

Ausgeführte Trades abfragen:

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

Profi-TippApidog

Echtzeitdaten mit WebSocket

REST-Polling führt zu einer inakzeptablen Latenz für den algorithmischen Handel. Krakens WebSocket-API streamt Echtzeit-Orderbuchaktualisierungen, Trades und Kontoereignisse.

Verbindung zu öffentlichem WebSocket herstellen

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-Abonnements geben Daten im Array-Format mit numerischen Kanal-IDs zurück. Ordnen Sie diese IDs Ihren Abonnements zu, um Daten korrekt weiterzuleiten.

Orderbuch-Streaming

Level-2-Orderbuchdaten abonnieren:

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

Der Buch-Feed sendet Snapshots, gefolgt von inkrementellen Aktualisierungen. Pflegen Sie den lokalen Orderbuchstatus, indem Sie Deltas anwenden:

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

Private WebSocket-Authentifizierung

Ein WebSocket-Token über REST erhalten:

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

Verbindung zu privatem WebSocket herstellen:

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

Private WebSocket-Tokens laufen nach 15 Minuten ab. Implementieren Sie eine automatische Token-Aktualisierungs- und Wiederverbindungslogik für Produktionssysteme.

Futures-Handel und erweiterte Funktionen

Kraken Futures bietet eine separate Infrastruktur für den Derivatehandel mit erweiterten Auftragstypen und Portfolio-Margin-Berechnung.

Futures-Authentifizierung

Futures verwenden die Bearer-Token-Authentifizierung, die sich von Spot-HMAC unterscheidet:

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-Auftragsplatzierung

Eine Limit-Order für Bitcoin Perpetual platzieren:

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

Futures-Symbole verwenden unterschiedliche Konventionen:

• PI_XBTUSD: Perpetueller inverser Bitcoin/USD
• PF_ETHUSD: Perpetueller linearer Ethereum/USD
• FI_XBTUSD_250228: Termingeschäfte mit fester Laufzeit, die am 28. Februar 2025 auslaufen

Batch-Operationen

Die Futures-API unterstützt die Batch-Auftragseinreichung:

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

Erweiterte Auftragsfunktionen

• Trailing Stops: Stop-Preis passt sich an Marktbewegungen an
• Take Profit / Stop Loss: Bracket-Orders für das Risikomanagement
• Post-Only: Stellt sicher, dass Aufträge Liquidität hinzufügen (Maker-Gebühren)
• Reduce-Only: Verhindert eine Erhöhung der Position

Totmannschalter

Alle Aufträge stornieren, wenn die Verbindung verloren geht:

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

Dies erstellt einen serverseitigen Timer – wenn Sie innerhalb von 60 Sekunden keinen Heartbeat senden, storniert Kraken automatisch alle offenen Aufträge.

Fazit

Krakens API bietet institutionellen Zugang zu Kryptowährungsmärkten über REST-, WebSocket- und dedizierte Futures-Schnittstellen. Sie authentifizieren sich mit HMAC-SHA512-Signaturen, verwalten Nonce-Sequenzen sorgfältig und skalieren vom Spot-Handel bis hin zu gehebelten Futures. Die gestuften Ratenbegrenzungen berücksichtigen Strategien von der gelegentlichen Portfolio-Neuausrichtung bis zum Hochfrequenz-Market-Making.

Beginnen Sie mit der Sandbox-Umgebung, um die Authentifizierung und Auftragsplatzierung zu testen. Verwenden Sie separate API-Schlüssel für jede Handelsstrategie, um Nonce-Konflikte zu vermeiden. Implementieren Sie WebSocket-Verbindungen für Echtzeitdaten und Totmannschalter für das Risikomanagement. Überwachen Sie die Ratenbegrenzungs-Header und implementieren Sie einen exponentiellen Backoff für 429-Fehler.

Beim Aufbau von Krypto-Handelsanwendungen – sei es beim Testen von Kraken-Endpunkten, beim Debuggen von Authentifizierungssignaturen oder beim Verwalten mehrerer API-Integrationen – optimieren Sie Ihren Entwicklungs-Workflow mit Apidog. Es übernimmt visuelles API-Testen, automatisierte Dokumentationsgenerierung und Teamkollaboration, sodass Sie sich auf die Handelslogik konzentrieren können, anstatt mit HMAC-Signaturen zu kämpfen.