Cómo Usar la API de Kraken: Guía Completa para Trading

Imagine tener acceso a uno de los exchanges de criptomonedas más líquidos del mundo a través de una API probada y verdadera que gestiona contratos de futuros y trading al contado. Kraken ofrece precisamente eso, con interfaces WebSocket y REST para un exchange establecido en 2011 que atiende a más de 10 millones de usuarios en 190 países con una extensa liquidez en más de 200 pares de trading.

Las APIs de trading de criptomonedas se dividen en dos categorías: las diseñadas para la conveniencia del retail y las construidas para la fiabilidad institucional. Muchos exchanges priorizan las aplicaciones móviles sobre la estabilidad de la API, lo que resulta en límites de tasa que estrangulan las estrategias algorítmicas y una documentación que se queda atrás de las nuevas características. Kraken elimina estos puntos de fricción al ofrecer acceso a la API por niveles basado en el volumen de trading, entornos de pruebas completos y puntos finales dedicados para traders de alta frecuencia. Puedes construir estrategias automatizadas que escalan desde scripts de aficionados hasta sistemas de grado institucional.

Tabla de Contenidos:

Comprendiendo la Arquitectura de la API de Kraken
Autenticación y Configuración de Claves API
Trading al Contado con la API REST
Datos en Tiempo Real con WebSocket
Trading de Futuros y Características Avanzadas
Conclusión

💡

Construir sistemas automatizados de trading de criptomonedas requiere pruebas de API fiables en puntos finales REST y WebSocket. Apidog proporciona pruebas de API visuales, generación automática de documentación y funciones de colaboración en equipo específicamente diseñadas para exchanges de criptomonedas. Prueba Apidog gratis para optimizar tu desarrollo de API de Kraken, sin necesidad de tarjeta de crédito.

botón

Comprendiendo la Arquitectura de la API de Kraken

Kraken opera tres ecosistemas de API distintos: Spot REST, Futures REST y WebSocket. Comprender estas arquitecturas te ayuda a elegir la ruta de integración correcta.

API REST al Contado (Spot)

La API REST al Contado proporciona acceso a la funcionalidad central del exchange de Kraken. Está organizada en puntos finales públicos (datos de mercado, información de ticker, profundidad del libro de órdenes) y puntos finales privados (saldo de cuenta, gestión de órdenes, financiación). Todas las solicitudes utilizan HTTPS con TLS 1.2 o superior.

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

Los puntos finales públicos no requieren autenticación. Los puntos finales privados utilizan la firma de solicitudes HMAC-SHA512 con claves API. Los formatos de respuesta varían: algunos puntos finales devuelven arrays donde el primer elemento es una cadena de error (diseño heredado), mientras que los puntos finales más nuevos usan objetos JSON estándar.

API REST de Futuros

Kraken Futures opera de forma separada del exchange al contado con su propia infraestructura de API. Admite swaps perpetuos y futuros de vencimiento fijo en criptomonedas con hasta 50x de apalancamiento.

URLs Base:

Producción: https://futures.kraken.com/api/v3
Sandbox: https://demo-futures.kraken.com/api/v3

La API de Futuros utiliza mecanismos de autenticación y estructuras de puntos finales diferentes en comparación con Spot. Necesitas claves API separadas generadas en futures.kraken.com, distintas de tus credenciales de trading al contado.

API WebSocket

Kraken proporciona flujos de datos en tiempo real a través de dos servidores WebSocket:

Público: wss://ws.kraken.com — Datos de mercado, libros de órdenes, trades
Privado: wss://ws-auth.kraken.com — Actualizaciones de cuenta, estado de órdenes, cambios de saldo

A diferencia del sondeo REST, las conexiones WebSocket envían datos a medida que están disponibles, reduciendo la latencia de cientos de milisegundos a decenas de milisegundos. El servidor público no requiere autenticación; el servidor privado requiere un token WebSocket obtenido a través de la API REST.

Limitación de Tasa

Kraken implementa una limitación de tasa basada en niveles:

Starter (Inicial): 60 llamadas por minuto (público), 30 llamadas por minuto (privado)
Intermediate (Intermedio): 125 llamadas por minuto (público), 60 llamadas por minuto (privado)
Pro (Profesional): 250+ llamadas por minuto basadas en el volumen de trading de 30 días

Exceder los límites resulta en errores HTTP 429 con cabeceras Retry-After que indican cuándo puedes reanudar las solicitudes.

API de trading de criptomonedas de Kraken

Autenticación y Configuración de Claves API

Kraken utiliza autenticación HMAC-SHA512 con protección de repetición basada en nonce. Esto requiere una implementación cuidadosa para evitar los errores de "Invalid nonce" comunes en aplicaciones multi-hilo.

Generación de Claves API

Navega a Cuenta → Seguridad → API en tu panel de control de Kraken:

Haz clic en "Generar Nueva Clave"
Selecciona permisos:

Consulta: Leer saldo de cuenta, órdenes abiertas, historial de trades
Trading: Colocar y cancelar órdenes
Retirar: Transferir fondos (usar con precaución)
Depositar: Ver direcciones y métodos de depósito

3. Especifica el whitelisting de IP (recomendado para producción)

4. Guarda la Clave API y la Clave Privada de forma segura; Kraken nunca volverá a mostrar la Clave Privada

Para el trading de Futuros, repite este proceso en futures.kraken.com/settings/api. El entorno sandbox en demo-futures.kraken.com utiliza credenciales separadas.

Firma HMAC-SHA512 (Implementación Manual)

Si no utilizas un SDK, implementa la autenticación de la siguiente manera:

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)

Crítico: Gestión de Nonce

Kraken requiere nonces estrictamente crecientes por clave API. Si tienes múltiples hilos o procesos utilizando la misma clave, estos entrarán en conflicto y generarán errores de "EAPI:Invalid nonce". Soluciones:

Usa diferentes claves API para cada algoritmo o servicio de trading
Implementa la sincronización de nonces a través de Redis o una base de datos si compartir claves es inevitable
Usa marcas de tiempo con precisión de microsegundos (multiplica el tiempo Unix por 1000) para reducir la probabilidad de colisión

SDKs Oficiales

Kraken proporciona SDKs oficiales de Python y Node.js, con SDKs de la comunidad para Go, Rust, Julia y otros lenguajes:

# Python
pip install python-kraken-sdk

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

Los SDKs oficiales manejan la autenticación, la gestión de nonces y el análisis de errores automáticamente. Úsalos a menos que tengas requisitos específicos para un manejo HTTP personalizado.

Trading al Contado con la API REST

La API REST al Contado proporciona una funcionalidad de trading completa a través de puntos finales bien documentados.

Datos de Mercado (Público)

Recuperar pares de trading disponibles:

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

Obtener información del ticker:

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

Kraken utiliza símbolos de par no estándar: XBT en lugar de BTC para Bitcoin, XXBT en algunos puntos finales heredados, ZUSD en lugar de USD. Siempre verifica los códigos de activos utilizando el punto final AssetPairs antes de operar.

Obtener profundidad del libro de órdenes:

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

Saldo de Cuenta (Privado)

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

El formato de respuesta utiliza códigos de activos como claves (ZUSD para USD, XXBT para Bitcoin):

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

Realización de Órdenes

Colocar una orden de compra limitada:

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

print(order)

Los tipos de órdenes incluyen:

market: Ejecutar inmediatamente al mejor precio disponible
limit: Ejecutar al precio especificado o mejor
stop-loss: Activar orden de mercado cuando el precio cruza un umbral
take-profit: Opuesto a stop-loss
trailing-stop: Stop dinámico que sigue los movimientos del precio

Gestión de Órdenes

Listar órdenes abiertas:

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

Cancelar una orden:

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

Cancelar todas las órdenes (parada de emergencia):

kraken.private_request('CancelAll')

Historial de Trades

Consultar trades ejecutados:

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

ProTipApidog

Probando puntos finales de API con Apidog

Datos en Tiempo Real con WebSocket

El sondeo REST introduce una latencia inaceptable para el trading algorítmico. La API WebSocket de Kraken transmite actualizaciones en tiempo real del libro de órdenes, trades y eventos de cuenta.

Conexión a WebSocket Público

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

Las suscripciones a WebSocket devuelven datos en formato de array con IDs de canal numéricos. Mapea estos IDs a tus suscripciones para enrutar los datos correctamente.

Streaming del Libro de Órdenes

Suscribirse a datos del libro de órdenes de Nivel 2:

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

El feed del libro de órdenes envía instantáneas seguidas de actualizaciones incrementales. Mantén el estado local del libro de órdenes aplicando los deltas:

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

Autenticación de WebSocket Privado

Obtener un token WebSocket a través de REST:

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

Conectarse a WebSocket privado:

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

Los tokens de WebSocket privado expiran después de 15 minutos. Implementa una lógica de actualización automática de tokens y reconexión para sistemas de producción.

Trading de Futuros y Características Avanzadas

Kraken Futures proporciona una infraestructura separada para el trading de derivados con tipos de órdenes avanzadas y margen de cartera.

Autenticación de Futuros

Los Futuros utilizan autenticación de token Bearer distinta de la HMAC al Contado:

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

Realización de Órdenes de Futuros

Colocar una orden limitada en un futuro perpetuo de Bitcoin:

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

Los símbolos de Futuros utilizan diferentes convenciones:

PI_XBTUSD: Bitcoin/USD Inverso Perpetuo
PF_ETHUSD: Ethereum/USD Lineal Perpetuo
FI_XBTUSD_250228: Futuro de vencimiento fijo que expira el 28 de febrero de 2025

Operaciones por Lotes

La API de Futuros admite el envío de órdenes por lotes:

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

Características Avanzadas de Órdenes

Trailing Stops (Stops Dinámicos): El precio de stop se ajusta con el movimiento del mercado
Take Profit / Stop Loss (Tomar Ganancias / Detener Pérdidas): Órdenes de bracket para la gestión de riesgos
Post-Only (Solo Publicar): Asegura que las órdenes añadan liquidez (tarifas de maker)
Reduce-Only (Solo Reducir): Evita que la posición aumente

Interruptor de Hombre Muerto (Dead Man's Switch)

Cancela todas las órdenes si se pierde la conexión:

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

Esto crea un temporizador en el lado del servidor: si no envías un latido (heartbeat) en 60 segundos, Kraken cancela automáticamente todas las órdenes abiertas.

Conclusión

La API de Kraken proporciona acceso de grado institucional a los mercados de criptomonedas a través de interfaces REST, WebSocket y de Futuros dedicadas. Te autenticas con firmas HMAC-SHA512, gestionas secuencias de nonce cuidadosamente y escalas desde el trading al contado hasta los futuros apalancados. Los límites de tasa por niveles se adaptan a estrategias desde el reequilibrio casual de cartera hasta la creación de mercado de alta frecuencia.

Comienza con el entorno sandbox para probar la autenticación y la realización de órdenes. Utiliza claves API separadas para cada estrategia de trading para evitar conflictos de nonce. Implementa conexiones WebSocket para datos en tiempo real e interruptores de hombre muerto para la gestión de riesgos. Monitorea los encabezados de límite de tasa e implementa retroceso exponencial para errores 429.

Al construir aplicaciones de trading de criptomonedas, ya sea probando puntos finales de Kraken, depurando firmas de autenticación o gestionando múltiples integraciones de API, optimiza tu flujo de trabajo de desarrollo con Apidog. Maneja pruebas visuales de API, generación automática de documentación y colaboración en equipo para que puedas concentrarte en la lógica de trading en lugar de lidiar con firmas HMAC.

botón