La API de Kraken proporciona a los desarrolladores una interfaz potente para uno de los principales exchanges de criptomonedas del mundo. Tanto si estás creando aplicaciones de trading, monitorizando mercados o gestionando carteras de criptomonedas, esta guía te ayudará a navegar por los aspectos esenciales de las capacidades de la API de Kraken y los enfoques de implementación.
¿Qué es la API de Kraken?
La API de Kraken permite a los desarrolladores acceder mediante programación a la funcionalidad del exchange a través de una interfaz RESTful. Con esta API, puedes:
- Acceder a datos de mercado en tiempo real (precios, libros de órdenes, operaciones)
- Colocar y gestionar órdenes de trading
- Monitorizar saldos y posiciones de la cuenta
- Procesar depósitos y retiradas
- Acceder a datos históricos de trading
Configuración para el acceso a la API
Creación de tu cuenta de Kraken
Antes de usar la API, necesitarás:
- Registrarte para obtener una cuenta de Kraken en kraken.com
- Completar los requisitos de verificación según tus necesidades de uso
- Activar la autenticación de dos factores (2FA) para mejorar la seguridad
Generación de claves API
Para interactuar con la API, crea claves API con los permisos apropiados:
- Inicia sesión en tu cuenta de Kraken
- Navega a Connection & API
3. Haz clic en Generate New Key
4. Establece los permisos apropiados:
- Query: Acceso de solo lectura a la información de la cuenta
- Trade: Capacidad para colocar y cancelar órdenes
- Deposit: Generar direcciones de depósito
- Withdraw: Crear solicitudes de retirada
⚠️ ADVERTENCIA DE SEGURIDAD
- Almacena las claves API de forma segura y nunca compartas tu clave privada
- Restringe los permisos de la clave API solo a lo necesario
- Considera la posibilidad de implementar restricciones de dirección IP
Comprensión de la estructura de la API
La API de Kraken está organizada en una estructura lógica:
URL base y endpoints de la API
Todas las solicitudes de la API comienzan con la URL base: https://api.kraken.com
La versión actual de la API está designada por /0/ en la ruta de la URL, seguida de:
- /public/ - Endpoints que no requieren autenticación
- /private/ - Endpoints que requieren autenticación con tu clave API
Formato de respuesta
Todas las respuestas de la API siguen un formato JSON estándar:
{
"error": [],
"result": { /* Datos de la respuesta */ }
}
Realización de tus primeras solicitudes a la API
Solicitudes de la API pública
Los endpoints públicos proporcionan datos de mercado sin necesidad de autenticación.
Ejemplo: Obtención de información del ticker
import requests
# Obtener información del ticker para Bitcoin en 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"Precio de la última operación de BTC/USD: {btc_data['c'][0]}")
print(f"Volumen de BTC/USD en 24h: {btc_data['v'][1]}")
else:
print(f"Error: {ticker_data['error']}")
Ejemplo: Datos del libro de órdenes
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("Libro de órdenes de ETH/USD 5 mejores ofertas:", orderbook.bids);
console.log("Libro de órdenes de ETH/USD 5 mejores peticiones:", orderbook.asks);
}
});
Autenticación de la API privada
Los endpoints privados requieren autenticación con tus claves API a través de un proceso que implica:
- Generar un nonce (número creciente)
- Crear una firma de solicitud utilizando HMAC-SHA512
- Enviar la solicitud con tu clave API y firma
Implementación de la autenticación
import time
import base64
import hashlib
import hmac
import urllib.parse
import requests
def kraken_request(api_key, api_sec, endpoint, data=None):
"""Realizar una solicitud autenticada a la API de Kraken"""
if data is None:
data = {}
api_url = "https://api.kraken.com"
# Añadir nonce a los datos
data['nonce'] = str(int(time.time() * 1000))
# Codificar los datos para la firma
encoded_data = urllib.parse.urlencode(data)
# Crear firma
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()
# Establecer encabezados
headers = {
'API-Key': api_key,
'API-Sign': signature_digest
}
# Enviar solicitud
response = requests.post(api_url + endpoint, headers=headers, data=data)
return response.json()
Funcionalidad principal de la API
Información de la cuenta
Comprobación del saldo de la cuenta
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}")
Gestión de órdenes
Colocación de una orden de mercado
# Parámetros para comprar 0.01 BTC al precio de mercado
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"¡Orden colocada! ID de transacción: {order_result['result']['txid'][0]}")
Colocación de una orden limitada
# Parámetros para vender 0.01 BTC a $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)
Consulta de órdenes abiertas
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"Tipo: {details['descr']['type']} {details['descr']['ordertype']}")
print(f"Par: {details['descr']['pair']}")Uso de APIdog con la API de Kraken
APIdog ofrece una plataforma potente para desarrollar, probar y documentar tus integraciones de la API de Kraken. Aquí te mostramos cómo aprovechar APIdog para un desarrollo optimizado:
Configuración de la API de Kraken en APIdog
Crear un nuevo proyecto
- Inicia APIdog y crea un nuevo proyecto
- Configura un entorno para las pruebas de la API de Kraken
Configurar variables de entorno
- Crea variables para
API_KEY,API_SECRETyAPI_URL - Establece la API_URL en
https://api.kraken.com
Importar o crear endpoints
- Importa la especificación de la API de Kraken o crea colecciones manualmente
- Organiza los endpoints en carpetas lógicas (Datos de mercado, Trading, Cuenta, etc.)
Implementación de la autenticación de Kraken en APIdog
APIdog facilita la configuración de la autenticación personalizada de Kraken:
- Crea un Script de pre-solicitud para generar la autenticación necesaria:
// Script de pre-solicitud para la autenticación de Kraken
const crypto = require('crypto-js');
// Obtener variables de entorno
const apiKey = pm.environment.get("API_KEY");
const apiSecret = pm.environment.get("API_SECRET");
// Añadir nonce al cuerpo de la solicitud
const nonce = Date.now() * 1000;
pm.request.body.update({
mode: 'urlencoded',
urlencoded: [
...pm.request.body.urlencoded.all(),
{key: 'nonce', value: nonce.toString()}
]
});
// Obtener la ruta de la solicitud
const path = pm.request.url.getPathWithQuery().replace(/\?.*/, '');
// Crear firma
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))
);
// Establecer encabezados
pm.request.headers.add({key: 'API-Key', value: apiKey});
pm.request.headers.add({key: 'API-Sign', value: signature});
Pruebas y documentación con APIdog
Crear solicitudes de prueba
- Configura solicitudes para operaciones comunes como obtener datos del ticker, colocar órdenes, etc.
- Utiliza el constructor de solicitudes para configurar los parámetros adecuados
Añadir scripts de prueba
- Valida las respuestas de la API con scripts de prueba
- Comprueba si hay errores y estructuras de datos esperadas
// Ejemplo de script de prueba para el endpoint de saldo
pm.test("El estado de la respuesta es 200", () => {
pm.response.to.have.status(200);
});
pm.test("No se devuelven errores", () => {
const response = pm.response.json();
pm.expect(response.error).to.be.an('array').that.is.empty;
});
pm.test("Existen datos de saldo", () => {
const response = pm.response.json();
pm.expect(response.result).to.exist.and.to.be.an('object');
});
Generar documentación
- Utiliza las herramientas de documentación de APIdog para crear guías completas de la API
- Incluye ejemplos, descripciones y muestras de respuestas
Compartir y colaborar
- Comparte tu colección de la API de Kraken con los miembros del equipo
- Utiliza las funciones de colaboración de APIdog para el desarrollo en equipo
Servidores Mock de APIdog para el desarrollo
Durante el desarrollo, puedes utilizar los servidores mock de APIdog para simular las respuestas de la API de Kraken:
- Crea respuestas de ejemplo para cada endpoint
- Configura reglas de respuesta basadas en los parámetros de la solicitud
- Prueba tu aplicación con respuestas mock antes de ponerla en marcha
Este enfoque permite ciclos de desarrollo más rápidos y te protege de alcanzar los límites de velocidad de la API durante el desarrollo.
Mejores prácticas para la integración de la API de Kraken
Limitación de velocidad y optimización
Kraken implementa límites de velocidad específicos:
- Endpoints públicos: 1 solicitud por segundo
- Endpoints privados: 15-20 solicitudes por minuto
Para gestionarlos eficazmente:
- Implementa la limitación en tu código
- Utiliza WebSockets para datos en tiempo real en lugar de llamadas frecuentes a la API REST
- Procesa las consultas por lotes cuando sea posible
Manejo de errores
Implementa un manejo de errores robusto para las interacciones de la API:
def safe_api_call(api_function, max_retries=3):
"""Wrapper para llamadas a la API con lógica de reintento"""
retries = 0
while retries < max_retries:
try:
response = api_function()
if 'error' in response and response['error']:
error = response['error'][0]
# Manejar la limitación de velocidad
if 'EAPI:Rate limit' in error:
sleep_time = (2 ** retries) # Retroceso exponencial
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
Consideraciones de seguridad
- Almacena las credenciales de la API de forma segura - Nunca las codifiques en tus aplicaciones
- Implementa restricciones de IP en la configuración de tu clave API de Kraken
- Utiliza los permisos mínimos requeridos para cada clave API
- Monitoriza el uso de la API para detectar accesos no autorizados
- Rota las claves API periódicamente
Casos de uso comunes
Monitorización de datos de mercado
def monitor_price(pair, interval=60):
"""Monitorizar el precio a intervalos regulares"""
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"{pair} precio actual: {price}")
time.sleep(interval)
Bot de trading simple
def simple_trading_strategy(pair, api_key, api_secret):
"""Ejemplo de una estrategia de trading simple"""
# Obtener el saldo de la cuenta
balance = kraken_request(api_key, api_secret, "/0/private/Balance")
# Obtener el precio actual
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])
# Estrategia simple: comprar si el precio ha bajado un 5% desde ayer
yesterday_close = float(ticker_data['result'][pair]['o'])
if current_price < yesterday_close * 0.95:
print(f"El precio ha bajado más de un 5% - oportunidad de compra")
# Implementar la lógica de compra
Conclusión
La API de Kraken proporciona herramientas potentes para el trading de criptomonedas y la gestión de carteras. Esta guía ha cubierto los aspectos esenciales del acceso a la API, la autenticación y las operaciones comunes. Al aprovechar herramientas como APIdog para el desarrollo y las pruebas, puedes crear aplicaciones robustas que interactúen a la perfección con el exchange de Kraken.
Recuerda consultar siempre la documentación oficial de la API de Kraken para obtener la información más actualizada y referencias detalladas de los endpoints. A medida que te sientas más cómodo con los conceptos básicos, puedes explorar funciones avanzadas como las conexiones WebSocket para datos en tiempo real y estrategias de trading más sofisticadas.
Tanto si estás creando un rastreador de cartera personal, implementando trading algorítmico o creando soluciones de criptomonedas de nivel empresarial, dominar la API de Kraken abre importantes posibilidades en el ecosistema de activos digitales.
