Guide d'authentification

Apprenez à vous authentifier avec Smart Money API en utilisant des clés API, des tokens JWT et OAuth 2.0. Sécurisez vos intégrations avec des méthodes d'authentification standard et des meilleures pratiques.

Aperçu

Smart Money API prend en charge plusieurs méthodes d'authentification pour différents cas d'utilisation. Choisissez la méthode qui correspond le mieux à votre intégration :

Clés API (principale) : Envoyez votre clé dans l'en-tête X-API-Key pour tous les appels d'API REST. C'est la méthode recommandée pour les bots et les utilisations serveur à serveur.

Session JWT (alternative) : Les sessions navigateur/dashboard s'authentifient avec un JWT de session via Authorization: Bearer, valable pendant 24 heures. Les clients programmatiques devraient préférer X-API-Key.

OAuth 2.0 : Authentification de niveau entreprise pour les applications multi-utilisateurs et les intégrations tierces. Les utilisateurs autorisent votre application à accéder à leurs données.

Toutes les requêtes API doivent être effectuées via HTTPS. Les requêtes HTTP non chiffrées seront rejetées. De plus, ne commettez jamais de clés API dans le contrôle de version ou ne les partagez pas publiquement.

Clés API

Les clés API sont des identifiants uniques attribués à votre compte. Chaque clé représente un ensemble unique de permissions et de quotas. Vous pouvez générer plusieurs clés pour différentes applications ou environnements (développement, staging, production).

Génération d'une clé API

Générez des clés API depuis votre console de compte :

Accédez à Smart Money Console
Sélectionnez "Clés API" dans la barre latérale
Cliquez sur "Générer une nouvelle clé"
Choisissez le type de clé (Développement, Staging, Production)
Définissez la limite de débit et les fonctionnalités
Copiez et stockez la clé en toute sécurité

Sauvegardez votre clé API immédiatement ! Vous ne pourrez plus la visualiser. Si vous la perdez, vous devrez générer une nouvelle clé.

Format de la clé

Les clés API suivent un format standard :

Format de la clé

sk_live_4e3e4d0f1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z
sk_test_8f4g5h6i7j8k9l0m1n2o3p4q5r6s7t8u9v0w1x2y3z4a5b6c7d8e9f
sk_dev_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z6a7b

Les préfixes des clés indiquent l'environnement :

sk_live_ — Clés de production avec quota complet

sk_test_ — Clés de test avec quota réduit et données de développement

sk_dev_ — Clés de développement personnel avec données de bac à sable

En-tête X-API-Key (principale)

Envoyez votre clé API dans l'en-tête X-API-Key pour toutes les requêtes API. Ne placez jamais votre clé dans une URL.

En-tête HTTP

HTTP

GET /v1/whales/events HTTP/1.1
Host: api.smartmoneyapi.com
X-API-Key: sm_your_key
Content-Type: application/json

Exemple cURL

Shell

curl -X GET https://api.smartmoneyapi.com/v1/whales/events \
  -H "X-API-Key: sm_your_key" \
  -H "Content-Type: application/json"

Exemple Python

Python

import requests

api_key = "sm_your_key"
headers = {
    "X-API-Key": api_key,
    "Content-Type": "application/json"
}

response = requests.get(
    "https://api.smartmoneyapi.com/v1/whales/events",
    headers=headers
)

data = response.json()

Authentification par token JWT

Pour les sessions de longue durée et la communication serveur à serveur, échangez votre clé API contre un token JWT. Les tokens JWT durent 24 heures et réduisent le besoin de stocker votre clé API dans le code de l'application.

Obtenir un token JWT

POSTez votre clé API à l'endpoint JWT pour obtenir un token :

cURL

curl -X POST https://api.smartmoneyapi.com/auth/jwt \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "sk_live_4e3e4d0f1b2c3d4e5f6g7h8i9j0k1l2m"
  }'

Réponse JWT

JSON

{
  "success": true,
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
  "expires_in": 86400,
  "token_type": "Bearer"
}

Utilisation du token JWT

Utilisez le token JWT dans l'en-tête Authorization comme pour les clés API :

Python

import requests
import json
from datetime import datetime, timedelta

class JWTAuth:
    def __init__(self, api_key):
        self.api_key = api_key
        self.token = None
        self.token_expires = None

    def get_valid_token(self):
        # Vérifiez si le token actuel est toujours valide
        if self.token and self.token_expires > datetime.now():
            return self.token

        # Obtenez un nouveau token
        response = requests.post(
            "https://api.smartmoneyapi.com/auth/jwt",
            json={"api_key": self.api_key}
        )

        data = response.json()
        self.token = data["token"]
        self.token_expires = datetime.now() + timedelta(seconds=data["expires_in"])

        return self.token

    def request(self, method, url, **kwargs):
        token = self.get_valid_token()
        headers = kwargs.get("headers", {})
        headers["Authorization"] = f"Bearer {token}"
        kwargs["headers"] = headers

        return requests.request(method, url, **kwargs)

# Utilisation
auth = JWTAuth("sk_live_4e3e4d0f1b2c3d4e5f6g7h8i9j0k1l2m")
response = auth.request(
    "GET",
    "https://api.smartmoneyapi.com/v1/whales/events"
)
print(response.json())

OAuth 2.0

OAuth 2.0 est destiné aux applications qui ont besoin d'accéder à plusieurs comptes utilisateurs. Les utilisateurs accordent à votre application la permission d'accéder à leurs données sans partager leurs clés API.

Flux OAuth 2.0

Smart Money API prend en charge le flux Authorization Code pour les applications web :

L'utilisateur clique sur le bouton "Connecter avec Smart Money"
Le navigateur redirige vers la page d'autorisation
L'utilisateur accorde la permission à votre application
Le navigateur redirige avec un code d'autorisation
Votre backend échange le code contre un token d'accès
Vous pouvez maintenant accéder aux données de l'utilisateur en son nom

Étape 1 : Demande d'autorisation

Redirigez l'utilisateur vers l'endpoint d'autorisation :

URL

https://auth.smartmoneyapi.com/authorize?
client_id=YOUR_CLIENT_ID&
redirect_uri=https://yourapp.com/callback&
response_type=code&
scope=whale_positions+funding_rates+liquidations&
state=random_state_string

Étape 2 : Échange de token

Après que l'utilisateur a accordé la permission, échangez le code contre un token d'accès :

cURL

curl -X POST https://auth.smartmoneyapi.com/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=authorization_code&code=AUTH_CODE&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&redirect_uri=https://yourapp.com/callback"

Réponse OAuth Token

JSON

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "rt_1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p",
  "scope": "whale_positions funding_rates liquidations"
}

Meilleures pratiques de sécurité

Stockez les clés en toute sécurité

Ne commettez jamais de clés API dans le contrôle de version, ne les codez pas en dur dans les applications ou ne les partagez pas dans la documentation. Utilisez des variables d'environnement ou des services de gestion de clés sécurisés comme AWS Secrets Manager, HashiCorp Vault ou similaires.

Utilisez uniquement HTTPS

Toutes les requêtes API doivent utiliser HTTPS (TLS 1.2 ou supérieur). Les requêtes HTTP seront rejetées. Cela garantit que votre clé API et vos données sont chiffrées en transit.

Limitez les permissions des clés

Créez des clés API distinctes pour différentes applications et environnements. Utilisez les portées pour limiter ce que chaque clé peut accéder. N'utilisez pas de clés de production en développement.

Surveillez l'utilisation des clés

Revoyez régulièrement l'utilisation de l'API dans votre console. Configurez des alertes pour les activités inhabituelles ou les quotas approchant des limites. Supprimez les clés que vous n'utilisez plus.

Rotation des clés

Faites tourner régulièrement vos clés API pour réduire le risque de compromission. Nous recommandons de faire tourner les clés tous les 90 jours :

Générez une nouvelle clé API dans votre console
Mettez à jour vos applications pour utiliser la nouvelle clé
Testez que tout fonctionne correctement
Supprimez l'ancienne clé de votre console

Portées & Permissions

Lors de la création de clés API ou de l'utilisation d'OAuth, spécifiez les ressources accessibles par votre clé :

Portée	Description	Niveau
whale_positions	Lire les positions des portefeuilles de baleines	Trader+
funding_rates	Lire les données de taux de financement	Free+
liquidations	Lire les flux de liquidations	Free+
open_interest	Lire les données d'intérêt ouvert	Trader+
confirmation_scores	Lire les scores de confirmation IA	Pro+
on_chain	Lire les métriques on-chain	Pro+

Exemples de code d'authentification

Intégration Python complète

Python

import requests
from typing import Optional, Dict
from datetime import datetime, timedelta

class SmartMoneyAuth:
    """Gère toutes les méthodes d'authentification pour Smart Money API"""

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.smartmoneyapi.com"
        self.jwt_token = None
        self.jwt_expires = None

    def get_jwt_token(self) -> str:
        """Obtenir ou actualiser le token JWT"""
        if self.jwt_token and self.jwt_expires > datetime.now():
            return self.jwt_token

        response = requests.post(
            f"{self.base_url}/auth/jwt",
            json={"api_key": self.api_key}
        )
        data = response.json()
        self.jwt_token = data["token"]
        self.jwt_expires = datetime.now() + timedelta(seconds=data["expires_in"] - 300)
        return self.jwt_token

    def headers_bearer(self) -> Dict:
        """Obtenir les en-têtes pour l'authentification Bearer"""
        return {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

    def headers_jwt(self) -> Dict:
        """Obtenir les en-têtes pour l'authentification JWT"""
        token = self.get_jwt_token()
        return {
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json"
        }

    def request(self, method: str, endpoint: str, use_jwt: bool = False, **kwargs) -> Dict:
        """Effectuer une requête authentifiée"""
        headers = self.headers_jwt() if use_jwt else self.headers_bearer()
        response = requests.request(
            method,
            f"{self.base_url}{endpoint}",
            headers=headers,
            **kwargs
        )
        return response.json()

# Utilisation
auth = SmartMoneyAuth("sk_live_abc123xyz789")

# Méthode Bearer token
whales = auth.request("GET", "/v1/whales/events?symbol=BTCUSDT")

# Méthode JWT (auto-actualisé)
whales_jwt = auth.request("GET", "/v1/whales/events?symbol=BTCUSDT", use_jwt=True)

print(f"Found {whales['data']['total']} whale positions")

Besoin d'aide ?

Consultez notre documentation API ou contactez le support si vous avez besoin d'assistance pour l'authentification.

Référence API

Générez votre première clé API

Commencez avec Smart Money API. Créez votre compte et générez des identifiants d'authentification en quelques minutes.

Accéder à la Console