Quelles sont les limites de taux pour l'API Kraken

L'API Kraken applique 15 demandes publiques par minute par IP et 20 demandes privées par minute par compte, avec des limites de taux réinitialisant au début de chaque minute.

Aug 12, 2025 at 08:00 pm

Comprendre les limites de taux de l'API Kraken

L' API Kraken met en œuvre la limitation du taux pour assurer une utilisation équitable et maintenir la stabilité du système pour tous les utilisateurs. Ces limites sont cruciales pour les développeurs et les commerçants qui s'appuient sur des données en temps réel ou des stratégies de trading automatisées. Chaque point de terminaison API a des seuils spécifiques en fonction du type de demande - publique ou privé. Les critères de terminaison publics, tels que ceux qui récupéraient des données de ticker ou des livres de commandes, sont soumis à des limites moins strictes par rapport aux points de terminaison privés, qui impliquent des actions spécifiques au compte telles que la mise en place de commandes ou la vérification des soldes.

Pour les points de terminaison publiques de l'API , Kraken autorise jusqu'à 15 demandes par minute par adresse IP. Cela signifie que si votre application envoie plus de 15 appels dans une fenêtre de 60 secondes à des points de terminaison comme /public/Ticker ou /public/Depth , les demandes suivantes seront rejetées avec un code d'état HTTP 429 trop de demandes . Cette limite est appliquée au niveau du réseau et s'applique indépendamment de l'état d'authentification.

Restrictions privées de point de terminaison API

En ce qui concerne les points de terminaison privés , tels que /private/AddOrder ou /private/Balance , les limites de taux sont liées au compte d'utilisateur plutôt qu'à l'adresse IP. Kraken autorise 20 appels par minute pour des demandes authentifiées. Ces points de terminaison nécessitent des clés et des signatures API valides, et dépasser la limite entraîne le blocage temporaire des autres demandes privées jusqu'à la réinitialisation de la fenêtre suivante suivante.

Il est important de noter que chaque appel API privé consomme une unité , et certaines opérations complexes peuvent consommer plusieurs unités en fonction de la charge de traitement du backend. Par exemple, la mise en place d'un ordre de marge peut compter comme deux appels en raison d'étapes de validation supplémentaires. Les développeurs doivent surveiller leur utilisation par le biais des en-têtes de réponse, en particulier les champs X-BS-Unit-Current , X-BS-Unit-Limit et X-BS-Unit-Reset , qui fournissent un aperçu en temps réel de la consommation actuelle et de la réinitialisation du calendrier.

Gestion des limites de taux dans la pratique

Pour éviter d'atteindre les limites de taux, les développeurs doivent mettre en œuvre des mécanismes de limitation dans leurs applications. Une méthode efficace consiste à utiliser un algorithme de godet de jeton qui suit le nombre de demandes faites et retarde l'exécution à l'approche du seuil. Par exemple:

• Utilisez un retard d'au moins 4 secondes entre les appels API publics pour rester sous la limite de 15 par minute.
• Pour les appels privés, l'espace demande de 3 secondes ou plus pour rester dans le seuil de 20 appels.
• Implémentez le revers exponentiel lors de la réception de 429 réponses, en commençant par une pause de 1 seconde et en doublant le retard après chaque tentative ratée.

De plus, la mise en cache des réponses des points de terminaison public peut réduire considérablement le nombre d'appels API. Par exemple, le stockage des données de ticker pendant 30 secondes avant de rafraîchir évite les demandes redondantes tout en maintenant la fraîcheur des données acceptable.

Configuration des touches API pour des performances optimales

Lors de la création de clés d'API sur Kraken, les utilisateurs peuvent personnaliser les autorisations et les restrictions d'accès IP. Pour optimiser l'utilisation des limites de taux:

• Générez des clés API dédiées pour différents services , tels que l'un pour les données du marché et un autre pour l'exécution des commandes. Cela permet un meilleur suivi et une meilleure isolement de l'utilisation.
• Restreignez chaque clé à des adresses IP spécifiques pour éviter une utilisation non autorisée et assurer une attribution cohérente de limite de taux.
• Activer la liste blanche de requête pour pré-approuver certains critères d'évaluation, ce qui peut améliorer la vitesse de traitement et réduire les frais généraux.

Après avoir généré une clé, testez-la toujours dans un environnement de bac à sable à l'aide d'appels à basse fréquence avant le déploiement de la production. Surveillez les en-têtes X-RateLimit-* dans les réponses de l'API pour vérifier la conformité. Ces en-têtes incluent:

• X-RateLimit-Limit : le nombre total de demandes autorisées par minute.
• X-RateLimit-Remaining : le nombre de demandes laissées dans la fenêtre actuelle.
• X-RateLimit-Reset : Timestamp Unix indiquant quand le compteur se réinitialise.

L'analyse de ces en-têtes permet un réglage dynamique de la fréquence de demande sans retard de codage rigide.

Gestion des erreurs de limite de taux programme

Lorsqu'une limite de taux est dépassée, Kraken renvoie une réponse JSON avec le code d'erreur EAPI:Rate limit exceeded . Les applications doivent gérer cela gracieusement. Une routine de gestion des erreurs robuste comprend:

• Vérification du code d'état HTTP et du corps de réponse pour les indicateurs de limite de taux.
• Enregistrement de l'événement avec les détails de l'horodatage et des points de terminaison pour le débogage.
• Utiliser l'exécution jusqu'à l'heure de réinitialisation indiquée dans X-BS-Unit-Reset .
• Réessayant la demande uniquement après la période de refroidissement.

Par exemple, dans Python, vous pouvez utiliser la bibliothèque requests pour inspecter les en-têtes et gérer les retards:

 import requests
 import time Response = reques.get ('https://api.kraken.com/0/public/ticker', params = {'paire': 'xbtusd'})



Si réponse.status_code == 429:


reset_time = int(response.headers.get('X-BS-Unit-Reset', 0)) sleep_duration = max(reset_time - int(time.time()), 1) time.sleep(sleep_duration)
 Cela garantit que l'application respecte les limites de taux et évite les échecs répétés.
 
Meilleures pratiques pour les applications à haute fréquence

Les applications nécessitant des mises à jour fréquentes de données, telles que les robots de trading algorithmique, doivent adopter des stratégies avancées:

• Demandes de lots dans la mesure du possible. Par exemple, récupérer plusieurs paires d'actifs en un seul appel à /public/Ticker au lieu de faire des demandes individuelles.
• Utilisez des flux WebSocket pour des données en temps réel. L'API WebSocket de Kraken fournit des mises à jour, des métiers et des tickers de commandes sans consommer des limites de taux de repos.
• Distribuez la charge sur plusieurs adresses IP à l'aide de serveurs proxy ou d'instances cloud, chacune avec sa propre allocation de limite de taux public.
• Planifiez les opérations intensives pendant les heures hors pointe pour minimiser la concurrence des ressources.

Les connexions WebSocket elles-mêmes ont des limites - Kraken permet jusqu'à 10 connexions simultanées par IP . Chaque connexion peut s'abonner à plusieurs canaux, mais les taux de messages excessifs peuvent déclencher la déconnexion.

Questions fréquemment posées

Kraken différencie-t-il les niveaux d'API en fonction du niveau de compte?

Non, Kraken n'offre pas de limites de taux d'API à plusieurs niveaux en fonction du niveau de vérification du compte ou du volume de trading. Tous les utilisateurs reçoivent les mêmes limites de référence: 15 appels publics par minute par IP et 20 appels privés par minute par compte . Il n'y a pas de plans API premium avec des quotas accrus.

Puis-je augmenter ma limite de taux en contactant le support de Kraken?

Kraken ne fournit pas d'options pour augmenter les limites de taux pour les comptes individuels. Les limites sont fixées pour maintenir la stabilité de la plate-forme. Les utilisateurs ayant besoin d'un débit plus élevé sont encouragés à optimiser leur code, à utiliser des lignes WebSockets ou à distribuer des demandes sur plusieurs IP.

Les demandes d'API échouées comptent-elles pour la limite de taux?

Oui, toutes les demandes envoyées à l'API , y compris celles qui échouent en raison de paramètres non valides ou d'erreurs d'authentification, comptent vers la limite de taux. Seules les demandes authentifiées et traitées uniquement avec succès les en-têtes de limite de taux de retour, mais le contre-incréments indépendamment du résultat.

Comment les fenêtres de la limite de taux sont-elles calculées - interruption ou fixe?

Kraken utilise des fenêtres à temps fixe basées sur la minute d'horloge . Le compteur se réinitialise au début de chaque minute (par exemple,: 00 secondes). Si vous passez 15 appels publics à 12h00, vous devez attendre jusqu'à 12h01h00 pour en faire plus, même si seulement 5 secondes se sont écoulées.