Comment utiliser l'API Kraken: Guide Complet pour le Trading

Imaginez avoir accès à l'une des plateformes d'échange de cryptomonnaies les plus liquides au monde via une API éprouvée qui gère les contrats à terme et le trading au comptant. Kraken offre précisément cela, proposant des interfaces WebSocket et REST à une bourse établie en 2011 et servant plus de 10 millions d'utilisateurs dans 190 pays, avec une liquidité étendue sur plus de 200 paires de trading.

Les API de trading de cryptomonnaies se divisent en deux catégories : celles conçues pour la commodité des particuliers et celles construites pour la fiabilité institutionnelle. De nombreuses bourses privilégient les applications mobiles au détriment de la stabilité de l'API, ce qui entraîne des limites de débit qui ralentissent les stratégies algorithmiques et une documentation qui accuse un retard par rapport aux nouvelles fonctionnalités. Kraken élimine ces points de friction en offrant un accès API échelonné en fonction du volume de trading, des environnements de test (sandbox) complets et des points de terminaison dédiés aux traders haute fréquence. Vous pouvez ainsi créer des stratégies automatisées qui évoluent des scripts d'amateurs aux systèmes de niveau institutionnel.

Table des matières :

• Comprendre l'architecture API de Kraken
• Authentification et configuration de la clé API
• Trading au comptant avec l'API REST
• Données en temps réel avec WebSocket
• Trading de contrats à terme et fonctionnalités avancées
• Conclusion

Comprendre l'architecture API de Kraken

Kraken opère trois écosystèmes API distincts : Spot REST, Futures REST et WebSocket. Comprendre ces architectures vous aide à choisir le bon chemin d'intégration.

API REST Spot

L'API REST Spot donne accès aux fonctionnalités principales de la bourse de Kraken. Elle est organisée en points de terminaison publics (données de marché, informations sur le ticker, profondeur du carnet d'ordres) et en points de terminaison privés (solde du compte, gestion des ordres, financement). Toutes les requêtes utilisent HTTPS avec TLS 1.2 ou supérieur.

URL de base : https://api.kraken.com/0

Les points de terminaison publics ne nécessitent aucune authentification. Les points de terminaison privés utilisent la signature de requête HMAC-SHA512 avec des clés API. Les formats de réponse varient : certains points de terminaison renvoient des tableaux où le premier élément est une chaîne d'erreur (conception héritée), tandis que les points de terminaison plus récents utilisent des objets JSON standard.

API REST Futures

Kraken Futures fonctionne séparément de la bourse au comptant avec sa propre infrastructure API. Elle prend en charge les swaps perpétuels et les contrats à terme à échéance fixe sur les cryptomonnaies avec un effet de levier allant jusqu'à 50x.

URLs de base :

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

L'API Futures utilise des mécanismes d'authentification et des structures de points de terminaison différents de ceux du Spot. Vous avez besoin de clés API distinctes générées sur futures.kraken.com, différentes de vos identifiants de trading au comptant.

API WebSocket

Kraken fournit des flux de données en temps réel via deux serveurs WebSocket :

• Public : wss://ws.kraken.com — Données de marché, carnets d'ordres, transactions
• Privé : wss://ws-auth.kraken.com — Mises à jour de compte, état des ordres, changements de solde

Contrairement à l'interrogation REST, les connexions WebSocket poussent les données dès qu'elles sont disponibles, réduisant la latence de centaines de millisecondes à des dizaines de millisecondes. Le serveur public ne nécessite aucune authentification ; le serveur privé nécessite un jeton WebSocket obtenu via l'API REST.

Limitation de débit

Kraken implémente une limitation de débit par paliers :

• Débutant : 60 appels par minute (public), 30 appels par minute (privé)
• Intermédiaire : 125 appels par minute (public), 60 appels par minute (privé)
• Pro : 250+ appels par minute basés sur le volume de trading sur 30 jours

Le dépassement des limites entraîne des erreurs HTTP 429 avec des en-têtes Retry-After indiquant quand vous pouvez reprendre les requêtes.

Authentification et configuration de la clé API

Kraken utilise l'authentification HMAC-SHA512 avec une protection contre la relecture basée sur un nonce. Cela nécessite une implémentation soignée pour éviter les erreurs "Invalid nonce" courantes dans les applications multi-threadées.

Génération de clés API

Accédez à Compte → Sécurité → API dans votre tableau de bord Kraken :

1. Cliquez sur "Générer une nouvelle clé"
2. Sélectionnez les permissions :

• Interroger : Lire le solde du compte, les ordres ouverts, l'historique des transactions
• Trader : Placer et annuler des ordres
• Retirer : Transférer des fonds (à utiliser avec prudence)
• Déposer : Afficher les adresses et méthodes de dépôt

3. Spécifiez la liste blanche d'IP (recommandé pour la production)

4. Stockez la clé API et la clé privée en toute sécurité — Kraken n'affichera plus jamais la clé privée

Pour le trading de contrats à terme (Futures), répétez ce processus sur futures.kraken.com/settings/api. L'environnement de test (sandbox) à demo-futures.kraken.com utilise des identifiants distincts.

Signature HMAC-SHA512 (Implémentation manuelle)

Si vous n'utilisez pas de SDK, implémentez l'authentification comme suit :

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):
        # Le nonce doit être supérieur à tout nonce précédemment utilisé
        nonce = str(int(time.time() * 1000))
        data['nonce'] = nonce
        
        # Créer le message : nonce + données POST
        message = nonce + json.dumps(data, separators=(',', ':'))
        
        # Créer la signature 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()

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

# Obtenir le solde du compte
balance = kraken.private_request('Balance')
print(balance)

Important : Gestion du Nonce

Kraken exige des nonces strictement croissants par clé API. Si vous avez plusieurs threads ou processus utilisant la même clé, ils entreront en conflit et généreront des erreurs "EAPI:Invalid nonce". Solutions :

1. Utilisez des clés API différentes pour chaque algorithme ou service de trading.
2. Implémentez la synchronisation des nonces via Redis ou une base de données si le partage de clés est inévitable.
3. Utilisez des horodatages de précision microseconde (multipliez le temps Unix par 1000) pour réduire la probabilité de collision.

SDKs officiels

Kraken fournit des SDKs officiels Python et Node.js, avec des SDKs communautaires pour Go, Rust, Julia et d'autres langages :

# Python
pip install python-kraken-sdk

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

Les SDKs officiels gèrent automatiquement l'authentification, la gestion des nonces et l'analyse des erreurs. Utilisez-les sauf si vous avez des exigences spécifiques pour une gestion HTTP personnalisée.

Trading au comptant avec l'API REST

L'API REST Spot offre des fonctionnalités de trading complètes via des points de terminaison bien documentés.

Données de marché (Publiques)

Récupérer les paires de trading disponibles :

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

Obtenir les informations du ticker :

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

Kraken utilise des symboles de paire non standard — XBT au lieu de BTC pour le Bitcoin, XXBT dans certains points de terminaison hérités, ZUSD au lieu de USD. Vérifiez toujours les codes d'actifs en utilisant le point de terminaison AssetPairs avant de trader.

Récupérer la profondeur du carnet d'ordres :

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

Solde du compte (Privé)

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

Le format de réponse utilise des codes d'actifs comme clés (ZUSD pour USD, XXBT pour Bitcoin) :

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

Placer des ordres

Placer un ordre d'achat à cours limité :

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

print(order)

Les types d'ordres incluent :

• market : Exécuter immédiatement au meilleur prix disponible
• limit : Exécuter au prix spécifié ou mieux
• stop-loss : Déclencher un ordre au marché lorsque le prix franchit un seuil
• take-profit : L'opposé du stop-loss
• trailing-stop : Stop dynamique qui suit les mouvements de prix

Gestion des ordres

Lister les ordres ouverts :

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

Annuler un ordre :

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

Annuler tous les ordres (arrêt d'urgence) :

kraken.private_request('CancelAll')

Historique des transactions

Interroger les transactions exécutées :

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

Conseil de proApidog

Données en temps réel avec WebSocket

L'interrogation REST introduit une latence inacceptable pour le trading algorithmique. L'API WebSocket de Kraken diffuse des mises à jour de carnet d'ordres, des transactions et des événements de compte en temps réel.

Connexion au WebSocket public

const WebSocket = require('ws');

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

ws.on('open', () => {
  console.log('Connecté au WebSocket public de Kraken');
  
  // S'abonner au ticker pour BTC/USD
  ws.send(JSON.stringify({
    event: 'subscribe',
    pair: ['XBT/USD'],
    subscription: {
      name: 'ticker'
    }
  }));
});

ws.on('message', (data) => {
  const message = JSON.parse(data);
  
  // Format du ticker : [ID du canal, données du ticker, paire, nom du canal]
  if (Array.isArray(message) && message[2] === 'XBT/USD') {
    const [channelID, ticker, pair, channelName] = message;
    console.log(`Prix BTC : Offre ${ticker.b[0]}, Demande ${ticker.a[0]}`);
  }
});

// Battement de cœur toutes les 30 secondes
setInterval(() => {
  ws.send(JSON.stringify({ event: 'ping' }));
}, 30000);

Les abonnements WebSocket renvoient les données sous forme de tableau avec des ID de canal numériques. Mappez ces ID à vos abonnements pour acheminer correctement les données.

Diffusion du carnet d'ordres

S'abonner aux données de carnet d'ordres de niveau 2 :

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

Le flux du carnet envoie des instantanés suivis de mises à jour incrémentielles. Maintenez l'état local du carnet d'ordres en appliquant les deltas :

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

ws.on('message', (data) => {
  const message = JSON.parse(data);
  
  if (message[1] === 'as' || message[1] === 'bs') {
    // Instantané : initialiser le carnet d'ordres
    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') {
    // Mise à jour : appliquer le 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;
      }
    });
  }
});

Authentification WebSocket privée

Obtenir un jeton WebSocket via REST :

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

Connecter au WebSocket privé :

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

privateWs.on('open', () => {
  // Authentifier
  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('Votre transaction exécutée :', message[0]);
  }
});

Les jetons WebSocket privés expirent après 15 minutes. Implémentez une logique de rafraîchissement automatique des jetons et de reconnexion pour les systèmes en production.

Trading de contrats à terme et fonctionnalités avancées

Kraken Futures fournit une infrastructure distincte pour le trading de dérivés avec des types d'ordres avancés et une marge de portefeuille.

Authentification Futures

Les Futures utilisent une authentification par jeton Bearer distincte de l'HMAC Spot :

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()

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

Placement d'ordres Futures

Placer un ordre à cours limité sur un Bitcoin perpétuel :

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

Les symboles Futures utilisent des conventions différentes :

• PI_XBTUSD : Bitcoin/USD perpétuel inversé
• PF_ETHUSD : Ethereum/USD linéaire perpétuel
• FI_XBTUSD_250228 : Contrats à terme à échéance fixe expirant le 28 février 2025

Opérations par lots

L'API Futures prend en charge la soumission d'ordres par lots :

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

Fonctionnalités d'ordre avancées

• Stop suiveur : Le prix stop s'ajuste aux mouvements du marché
• Take Profit / Stop Loss : Ordres bracket pour la gestion des risques
• Post-Only : Garantit que les ordres ajoutent de la liquidité (frais de maker)
• Reduce-Only : Empêche la position d'augmenter

Interrupteur de l'homme mort (Dead Man's Switch)

Annuler tous les ordres si la connexion est perdue :

# Définir un délai de 60 secondes
kraken.private_request('CancelAllOrdersAfter', {
    'timeout': 60
})

Cela crée une minuterie côté serveur — si vous n'envoyez pas de battement de cœur dans les 60 secondes, Kraken annule automatiquement tous les ordres ouverts.

Conclusion

L'API de Kraken offre un accès de niveau institutionnel aux marchés des cryptomonnaies via REST, WebSocket et des interfaces Futures dédiées. Vous vous authentifiez avec des signatures HMAC-SHA512, gérez les séquences de nonces avec soin et passez du trading au comptant aux contrats à terme à effet de levier. Les limites de débit échelonnées s'adaptent aux stratégies allant du rééquilibrage de portefeuille occasionnel à la tenue de marché haute fréquence.

Commencez par l'environnement de test (sandbox) pour vérifier l'authentification et le placement des ordres. Utilisez des clés API distinctes pour chaque stratégie de trading afin d'éviter les conflits de nonces. Implémentez des connexions WebSocket pour les données en temps réel et des interrupteurs de l'homme mort pour la gestion des risques. Surveillez les en-têtes de limite de débit et implémentez un retour exponentiel pour les erreurs 429.

Lorsque vous créez des applications de trading de crypto — que ce soit pour tester les points de terminaison de Kraken, déboguer les signatures d'authentification ou gérer plusieurs intégrations d'API — simplifiez votre flux de travail de développement avec Apidog. Il gère les tests API visuels, la génération automatisée de documentation et la collaboration d'équipe afin que vous puissiez vous concentrer sur la logique de trading au lieu de vous battre avec les signatures HMAC.