Limitation de débit et quotas

Comprenez les limites de débit de l'API Smart Money, les quotas quotidiens pour chaque niveau d'abonnement et les stratégies d'optimisation pour maximiser votre utilisation de l'API.

Aperçu

L'API Smart Money applique des quotas de requêtes quotidiennes pour garantir la qualité du service et l'équité entre tous les utilisateurs. Chaque niveau d'abonnement inclut une limite quotidienne différente. Si vous dépassez votre quota quotidien, vous recevez une erreur 429 Too Many Requests jusqu'à ce que votre quota soit réinitialisé à minuit UTC.

Les limites de débit sont appliquées par clé API. Chaque clé a son propre quota indépendant. Vous pouvez générer plusieurs clés pour différentes applications et surveiller l'utilisation de chacune séparément.

Quotas par niveau d'abonnement

Niveau Requêtes quotidiennes Prix Fonctionnalités
Gratuit 20 requêtes/jour $0 BTC, ETH, SOL, taux de financement, liquidations
Trader 400 requêtes/jour 29 $/mois Tous les symboles, positions des baleines, données OI
Pro 4 000 requêtes/jour 79 $/mois Scores de confirmation, données on-chain, webhooks
Entreprise Personnalisé Personnalisé Support dédié, intégrations personnalisées

En-têtes de réponse de limitation de débit

Chaque réponse de l'API inclut des en-têtes indiquant l'état actuel de votre quota :

En-têtes HTTP
X-Requests-Limit: 200 X-Requests-Remaining: 147 X-Requests-Reset: 1711116000 X-Requests-Reset-ISO: 2026-03-22T00:00:00Z
En-tête Description
X-Requests-Limit Total de requêtes autorisées par jour (par exemple, 200 pour Trader)
X-Requests-Remaining Requêtes restantes dans la journée en cours
X-Requests-Reset Horodatage Unix de la réinitialisation du quota
X-Requests-Reset-ISO Horodatage ISO 8601 de la réinitialisation du quota

Vérification du quota avant de faire des requêtes

Python
import requests from datetime import datetime def check_quota_before_request(api_key): response = requests.head( "https://api.smartmoneyapi.com/v1/whales/events", headers={"Authorization": f"Bearer {api_key}"} ) limit = int(response.headers.get("X-Requests-Limit", 0)) remaining = int(response.headers.get("X-Requests-Remaining", 0)) reset_unix = int(response.headers.get("X-Requests-Reset", 0)) reset_time = datetime.fromtimestamp(reset_unix) percent_used = (limit - remaining) / limit * 100 print(f"Quota: {remaining}/{limit} requests ({percent_used:.1f}% utilisées)") print(f"Réinitialisation à : {reset_time}") if remaining < 5: print("AVERTISSEMENT : Limite de quota approchée !") return False return True # Vérification avant de faire des requêtes if check_quota_before_request("sk_live_abc123xyz789"): print("Sécurité de procéder aux appels API")

Fenêtre de limitation quotidienne

Les limites de débit fonctionnent sur une fenêtre glissante de 24 heures. Votre quota est réinitialisé quotidiennement à minuit UTC (00:00 UTC). L'heure exacte de réinitialisation est fournie dans l'en-tête X-Requests-Reset-ISO .

Exemple : Niveau Trader (400 requêtes/jour)

  • Jour 1 (21 mars) : 200 requêtes disponibles à 00:00 UTC
  • 10:30 UTC : 75 requêtes effectuées, 125 restantes
  • 15:45 UTC : 100 requêtes supplémentaires effectuées, 25 restantes
  • 23:59 UTC : Encore 25 requêtes restantes (ne peuvent pas être reportées)
  • Jour 2 (22 mars, 00:00 UTC) : Quota réinitialisé à 200

Stratégies d'optimisation

1. Mettre en cache les réponses de l'API

Les positions des baleines ne changent pas chaque seconde. Mettez en cache les résultats pendant 30 à 60 secondes et servez les données mises en cache au lieu de faire de nouveaux appels API.

Python
import requests import time class CachedClient: def __init__(self, api_key, cache_ttl=60): self.api_key = api_key self.cache_ttl = cache_ttl self.cache = {} self.cache_time = {} def get_whale_positions(self, symbol): cache_key = f"whales:{symbol}" now = time.time() # Retourner les données mises en cache si elles sont encore fraîches if cache_key in self.cache: age = now - self.cache_time[cache_key] if age < self.cache_ttl: print(f"Servi depuis le cache (âge : {age:.1f}s)") return self.cache[cache_key] # Récupérer des données fraîches response = requests.get( f"https://api.smartmoneyapi.com/v1/whales/events?symbol={symbol}", headers={"Authorization": f"Bearer {self.api_key}"} ) data = response.json() self.cache[cache_key] = data self.cache_time[cache_key] = now return data # Utilisation : Mise en cache pendant 60 secondes client = CachedClient("sk_live_abc123xyz789", cache_ttl=60) whales1 = client.get_whale_positions("BTCUSDT") # Appel API whales2 = client.get_whale_positions("BTCUSDT") # Depuis le cache whales3 = client.get_whale_positions("BTCUSDT") # Depuis le cache

2. Utiliser WebSocket pour les données en temps réel

Les connexions WebSocket fournissent des mises à jour instantanées sans compter dans votre limite de débit. Abonnez-vous aux flux et recevez les mises à jour en temps réel, réduisant ainsi le nombre d'appels REST API nécessaires.

3. Regrouper les requêtes stratégiquement

Faites une seule requête avec plusieurs symboles lorsque cela est possible au lieu de faire des requêtes séparées pour chaque symbole. Cela réduit les appels API jusqu'à 10 fois.

4. Utiliser le filtrage au moment de la requête

Appliquez des filtres (symbole, échange, taille minimale de position) dans les paramètres de requête pour obtenir exactement les données dont vous avez besoin, évitant ainsi le post-traitement.

Gestion des erreurs de limitation de débit

Réessayer avec un délai exponentiel

Python
import requests import time def request_with_retry(url, api_key, max_retries=5): for attempt in range(max_retries): try: response = requests.get( url, headers={"Authorization": f"Bearer {api_key}"}, timeout=10 ) if response.status_code == 200: return response.json() elif response.status_code == 429: # Limite de débit atteinte - délai exponentiel wait_time = min(2 ** attempt, 300) # Maximum 5 minutes reset_time = response.headers.get("X-Requests-Reset-ISO") print(f"Limite de débit atteinte. Réessai dans {wait_time}s (réinitialisation à {reset_time})") time.sleep(wait_time) elif response.status_code >= 500: # Erreur serveur - réessayer wait_time = 2 ** attempt print(f"Erreur serveur {response.status_code}. Réessai dans {wait_time}s") time.sleep(wait_time) else: # Autre erreur - ne pas réessayer raise Exception(f"HTTP {response.status_code}: {response.text}") except requests.exceptions.Timeout: wait_time = 2 ** attempt print(f"Timeout. Réessai dans {wait_time}s") time.sleep(wait_time) raise Exception("Nombre maximum de réessais dépassé") # Utilisation data = request_with_retry( "https://api.smartmoneyapi.com/v1/whales/events", "sk_live_abc123xyz789" ) print(data)

Prêt à passer à la version supérieure ?

Le niveau gratuit ne suffit pas ? Passez à Trader ou Pro pour des quotas plus élevés et accéder à des fonctionnalités avancées comme les scores de confirmation et les données on-chain.

Voir les tarifs

Optimisez votre utilisation de l'API dès aujourd'hui

Mettez en œuvre la mise en cache, utilisez WebSocket pour les données en temps réel et gérez les limites de débit avec élégance.

Lire la documentation
Commencez gratuitement — 200 appels/jour, sans carte

Obtenez les flux de baleines en direct, les taux de financement, les intérêts ouverts et les données on-chain sur 3 échanges via une seule API. Niveau gratuit, sans carte de crédit, passez à la version supérieure à tout moment.

Commencez gratuitement →
Essayez la console API en direct → (aucun compte nécessaire)
Obtenez votre clé API en 30 secondes

Prêt à construire ? Obtenez une clé API gratuite (200 appels/jour, sans carte) et commencez à récupérer les données de baleines, de financement et on-chain en direct.

Obtenez votre clé API →