Les contrats perpétuels OKX représentent l'un des marchés de derivatives crypto les plus liquides au monde, avec des milliards de dollars de volume quotidien. Pour les traders algorithmiques, les chercheurs quantitatifs et les développeurs de robots de trading, l'accès programmatique à ces données est essentiel.
Ce guide technique vous explique comment interagir avec l'API REST et WebSocket d'OKX pour récupérer les données de vos contrats perpétuels.
---
Comprendre l'API OKX
OKX propose deux interfaces principales pour accéder aux données de marché :
L'API REST convient parfaitement aux requêtes ponctuelles et aux opérations de trading moins fréquentes. Pour le streaming de données en temps réel, les WebSockets offrent une latence minimale et une consommation de bande passante optimisée.
L'endpoint de base pour l'API REST est
https://www.okx.com. Pour les WebSockets, utilisez
wss://ws.okx.com:8443.
---
Configuration Initiale
Avant de commencer, vous devez créer une clé API dans votre tableau de bord OKX. Assurez-vous de sélectionner les autorisations appropriées : lecture seule pour la récupération de données, ou trading si vous souhaitez également exécuter des ordres.
Conservez votre
apiKey,
secretKey et
passphrase en sécurité. Ne les partagez jamais et ne les incluez jamais dans du code versionné.
---
Récupérer les Données de Marché avec l'API REST
Liste des Contrats Perpétuels Disponibles
import requests
import hashlib
import hmac
import datetime
import base64
BASE_URL = "https://www.okx.com"
API_KEY = "votre_api_key"
SECRET_KEY = "votre_secret_key"
PASSPHRASE = "votre_passphrase"
def get_instruments(instType="SWAP"):
"""Récupère la liste des contrats perpétuels disponibles."""
endpoint = "/api/v5/public/instruments"
params = {"instType": instType}
response = requests.get(
f"{BASE_URL}{endpoint}",
params=params
)
if response.status_code == 200:
data = response.json()
if data.get("code") == "0":
return data["data"]
else:
print(f"Erreur: {data}")
return None
else:
print(f"Erreur HTTP: {response.status_code}")
return None
Exemple d'utilisation
perpetuals = get_instruments("SWAP")
if perpetuals:
for contract in perpetuals[:5]:
print(f"Symbole: {contract['instId']}, "
f"Prix spot: {contract['last']}, "
f"Funding rate: {contract['fundingRate']}")
Ce code retourne tous les contrats SWAP (perpétuels) disponibles avec leurs caractéristiques : symbole, prix actuel, taux de funding, et limites de position.
---
Récupérer le Carnet d'Ordres (Order Book)
def get_orderbook(instId="BTC-USDT-SWAP", depth=25):
"""Récupère le carnet d'ordres pour un contrat perpétuel."""
endpoint = "/api/v5/market/books"
params = {
"instId": instId,
"sz": depth # Nombre de niveaux de prix
}
response = requests.get(
f"{BASE_URL}{endpoint}",
params=params
)
if response.status_code == 200:
data = response.json()
if data.get("code") == "0":
return data["data"][0]
else:
print(f"Erreur: {data}")
return None
return None
Exemple d'utilisation
orderbook = get_orderbook("BTC-USDT-SWAP", 20)
if orderbook:
print(f"Ask le plus bas: {orderbook['asks'][0]}")
print(f"Bid le plus haut: {orderbook['bids'][0]}")
---
Récupérer les Données Historiques (Klines/Candlesticks)
def get_candles(instId="BTC-USDT-SWAP", period="1H", limit=100):
"""Récupère l'historique des chandeliers Japanese."""
endpoint = "/api/v5/market/history-candles"
params = {
"instId": instId,
"bar": period, # 1m, 5m, 15m, 1H, 4H, 1D
"limit": limit # Maximum 100
}
response = requests.get(
f"{BASE_URL}{endpoint}",
params=params
)
if response.status_code == 200:
data = response.json()
if data.get("code") == "0":
return data["data"]
return None
return None
Exemple d'utilisation
candles = get_candles("ETH-USDT-SWAP", "1H", 50)
if candles:
for candle in candles[:3]:
timestamp, open_price, high, low, close, volume = candle[:6]
print(f"{timestamp} | O: {open_price} H: {high} L: {low} C: {close} V: {volume}")
---
Connexion WebSocket pour le Temps Réel
L'API WebSocket est indispensable pour les applications nécessitant des mises à jour en temps réel avec une latence minimale.
import json
import websocket
import threading
import time
class OKXWebSocket:
def __init__(self):
self.ws = None
self.subscriptions = []
def connect(self):
"""Établit la connexion WebSocket."""
url = "wss://ws.okx.com:8443/ws/v5/public"
self.ws = websocket.WebSocketApp(
url,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close,
on_open=self.on_open
)
# Démarrer dans un thread séparé
thread = threading.Thread(target=self.ws.run_forever)
thread.daemon = True
thread.start()
def on_open(self, ws):
print("Connexion WebSocket établie")
def on_message(self, ws, message):
data = json.loads(message)
# Traiter les données reçues
if "data" in data:
for item in data["data"]:
print(f"Tick: {item}")
def on_error(self, ws, error):
print(f"Erreur WebSocket: {error}")
def on_close(self, ws):
print("Connexion WebSocket fermée")
def subscribe(self, channel, instId):
"""S'abonne à un canal pour un instrument."""
subscribe_msg = {
"op": "subscribe",
"args": [{
"channel": channel,
"instId": instId
}]
}
self.ws.send(json.dumps(subscribe_msg))
self.subscriptions.append({"channel": channel, "instId": instId})
print(f"Abonné à {channel} pour {instId}")
Exemple d'utilisation
ws_client = OKXWebSocket()
ws_client.connect()
time.sleep(1) # Attendre la connexion
S'abonner aux ticks BTC-USDT
ws_client.subscribe("tickers", "BTC-USDT-SWAP")
ws_client.subscribe("books5", "ETH-USDT-SWAP") # Order book 5 niveaux
---
Erreurs Courantes et Solutions
**Erreur 10001 - "System error"**
Cette erreur survient généralement lors d'un pic de charge serveur. Implémentez un retry exponentiel avec un délai initial de 1 seconde et un maximum de 3 tentatives. Vérifiez également que votre clé API dispose des permissions nécessaires.
import time
def request_with_retry(func, max_retries=3, initial_delay=1):
"""Wrapper pour réessayer les requêtes échouées."""
delay = initial_delay
for attempt in range(max_retries):
try:
result = func()
if result is not None:
return result
except Exception as e:
print(f"Tentative {attempt + 1} échouée: {e}")
if attempt < max_retries - 1:
time.sleep(delay)
delay *= 2 # Backoff exponentiel
return None
**Erreur 51115 - "Price is beyond the limit"**
Le prix de votre ordre dépasse les limites de prix autorisées par OKX. Calculez d'abord le prix spot actuel et appliquez une marge de sécurité de 2% avant de soumettre l'ordre.
**Erreur 5812 - "Signature verification failed"**
Ce problème survient lors de l'authentification pour les endpoints privés. Assurez-vous que le timestamp de la requête est synchronisé avec le serveur. Utilisez
str(time.time()) comme valeur, et vérifiez que le body de la requête est encodé correctement en JSON.
---
Limites de Taux et Meilleures Pratiques
L'API OKX impose des limites de requêtes selon votre niveau de vérification KYC :
| Niveau | Requêtes/secondes | WebSocket simultanées |
|--------|-------------------|------------------------|
| Non vérifié | 20 | 25 |
| Vérifié niveau 1 | 60 | 50 |
| Vérifié niveau 2+ | 200 | 100 |
Pour optimiser l'utilisation, regroupez vos requêtes REST et privilégiez le WebSocket pour le streaming de données en continu. Mettez en cache les données de instruments qui changent rarement.
---
Considérations de Sécurité
Protégez vos identifiants API en utilisant des variables d'environnement plutôt que de les hardcoder. Configurez des restrictions IP sur vos clés si possible. Pour le trading en production, utilisez des comptes dédiés avec des limites de retrait appropriées.
Testez toujours vos stratégies en mode papier (sandbox) avant de les déployer avec des fonds réels. L'environnement de test OKX utilise
https://www.okx.com mais avec des clés distinctes disponibles dans votre tableau de bord développeur.
---
Ce guide couvre les fondamentaux de l'accès programmatique aux données des contrats perpétuels OKX. Pour approfondir, consultez la documentation officielle OKX qui détaille les endpoints de trading, les positions et la gestion des ordres.
Ressources connexes
Articles connexes