Comment obtenir une clé API Rugcheck et utiliser l'API Rugcheck

Le paysage des cryptomonnaies est plein d'opportunités, mais aussi de risques importants. Les "rug pulls" et les jetons mal conçus peuvent entraîner des pertes substantielles. Rugcheck.xyz fournit un service essentiel en analysant les projets crypto pour détecter les signaux d'alerte potentiels. Son API permet aux développeurs, aux traders et aux analystes d'accéder par programmation à ces informations, automatisant et adaptant leurs efforts de diligence raisonnable. Ce guide se concentrera principalement sur comment utiliser l'API Rugcheck.xyz, en vous équipant d'exemples pratiques en Python.

💡

Vous voulez un excellent outil de test d'API qui génère une belle documentation API ?

Vous voulez une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?

Apidog répond à toutes vos demandes et remplace Postman à un prix beaucoup plus abordable !

button

Aperçu rapide de Rugcheck.xyz et de son API

Qu'est-ce que Rugcheck.xyz ?

Rugcheck.xyz est une plateforme conçue pour examiner les jetons de cryptomonnaie et les contrats intelligents afin de détecter des signes d'intention malveillante (comme les "rug pulls" ou les "honeypots") ou de risques inhérents. Elle examine le code du contrat, la liquidité, la tokenomics, les portefeuilles des développeurs, et plus encore, en fournissant des évaluations des risques et des rapports détaillés.

Pourquoi l'API ?

L'API donne un accès programmatique au moteur d'analyse de Rugcheck.xyz, permettant :

Automatisation : Intégrer des vérifications dans les robots de trading ou les nouveaux systèmes d'alerte de jetons.
Évolutivité : Analyser de nombreux jetons beaucoup plus rapidement que les vérifications manuelles.
Personnalisation : Créer des tableaux de bord et des modèles de risque sur mesure en utilisant les données brutes de l'API.

Obtenir votre clé API Rugcheck.xyz – L'essentiel

Pour utiliser l'API, vous avez besoin d'une clé API. La documentation de l'API Rugcheck.xyz (https://api.rugcheck.xyz/swagger/index.html) implique un système de compte utilisateur pour la gestion des clés via des points de terminaison tels que /user/api-keys.

Inscription/Connexion : Visitez le site Web principal de Rugcheck.xyz et créez un compte ou connectez-vous.
Trouver les paramètres de l'API : Recherchez une section "API", "Développeur" ou "Clés API" dans votre tableau de bord utilisateur.
Générer une clé : Créez une nouvelle clé API. Vous pourrez peut-être lui donner un nom pour une identification plus facile.
Sécuriser votre clé : Copiez la clé générée et stockez-la en toute sécurité (par exemple, gestionnaire de mots de passe, variable d'environnement). Ne l'exposez jamais dans les référentiels de code publics ou les applications côté client.

Toutes les requêtes API nécessitent que cette clé soit envoyée dans l'en-tête X-API-KEY.

Avant de plonger dans le code, voici quelques points de terminaison principaux avec lesquels nous allons travailler (reportez-vous aux documents Swagger pour des détails exhaustifs) :

GET /tokens/scan/{chain}/{contractAddress} : Effectue une analyse en temps réel d'un jeton. Renvoie les niveaux de risque, les avertissements, les détails du contrat, les informations sur la liquidité, etc.
GET /tokens/source-code/{chain}/{contractAddress} : Récupère le code source du contrat intelligent vérifié d'un jeton et l'ABI.
GET /wallets/risk-rating/{chain}/{walletAddress} : Évalue le profil de risque d'une adresse de portefeuille donnée.
GET /tokens/search : Recherche des jetons par nom ou symbole.
GET /utils/chains : Liste tous les réseaux blockchain pris en charge par l'API.

L'URL de base pour toutes les requêtes est : https://api.rugcheck.xyz

Comment utiliser l'API Rugcheck.xyz : exemples Python approfondis

C'est là que nous devenons pratiques. Nous utiliserons Python avec la bibliothèque requests.

Prérequis :

Python 3.x installé.
Bibliothèque requests : pip install requests
Votre clé API Rugcheck.xyz.

1. Configuration et fonction d'appel d'API de base

Tout d'abord, configurons notre environnement et créons une fonction réutilisable pour gérer les appels d'API. Il est préférable de stocker votre clé API en tant que variable d'environnement.Python

import requests
import json
import os

# Charger la clé API à partir de la variable d'environnement pour la sécurité
API_KEY = os.getenv('RUGCHECK_API_KEY')
BASE_URL = "https://api.rugcheck.xyz"

if not API_KEY:
    print("Erreur : la variable d'environnement RUGCHECK_API_KEY n'est pas définie.")
    # Vous voudrez peut-être quitter ou lever une exception ici dans une véritable application
    # Pour la démonstration, nous allons l'autoriser à continuer, mais les appels échoueront.
    # API_KEY = "YOUR_FALLBACK_API_KEY_FOR_TESTING_ONLY" # Non recommandé pour une utilisation réelle

HEADERS = {
    "X-API-KEY": API_KEY,
    "Accept": "application/json" # Bonne pratique pour spécifier le type de réponse accepté
}

def make_api_request(endpoint, params=None):
    """
    Effectue une requête GET vers l'API Rugcheck.xyz.
    
    Args:
        endpoint (str): Le chemin du point de terminaison de l'API (par exemple, "/utils/chains").
        params (dict, optional): Paramètres de requête pour la requête.
        
    Returns:
        dict or None: La réponse JSON sous forme de dictionnaire Python, ou None si une erreur se produit.
    """
    if not API_KEY or API_KEY == "YOUR_FALLBACK_API_KEY_FOR_TESTING_ONLY":
        print("Erreur : la clé API n'est pas correctement configurée.")
        return None
        
    url = f"{BASE_URL}{endpoint}"
    try:
        response = requests.get(url, headers=HEADERS, params=params, timeout=30) # Délai d'attente de 30 secondes
        response.raise_for_status()  # Lève HTTPError pour les mauvaises réponses (4xx ou 5xx)
        return response.json()
    except requests.exceptions.HTTPError as http_err:
        print(f"Une erreur HTTP s'est produite : {http_err}")
        print(f"Code d'état : {response.status_code}")
        try:
            # Essayez d'imprimer les détails de l'erreur de l'API si disponible en JSON
            print(f"Réponse d'erreur : {response.json()}")
        except json.JSONDecodeError:
            print(f"Réponse d'erreur (pas JSON) : {response.text}")
    except requests.exceptions.ConnectionError as conn_err:
        print(f"Une erreur de connexion s'est produite : {conn_err}")
    except requests.exceptions.Timeout as timeout_err:
        print(f"Une erreur de délai d'attente s'est produite : {timeout_err}")
    except requests.exceptions.RequestException as req_err:
        print(f"Une erreur inattendue s'est produite avec la requête : {req_err}")
    except json.JSONDecodeError: # Si response.json() échoue pour les cas non-HTTPError
        print("Impossible de décoder la réponse JSON de l'API.")
        print(f"Contenu de la réponse : {response.text if 'response' in locals() else 'Aucun objet de réponse'}")
    return None

Important : Pour que les exemples suivants s'exécutent, assurez-vous que RUGCHECK_API_KEY est défini dans votre environnement. Vous aurez également besoin d'adresses de contrat et d'adresses de portefeuille valides pour les chaînes respectives.

2. Exemple 1 : Plongée en profondeur dans l'analyse des jetons (/tokens/scan/{chain}/{contractAddress})

C'est l'un des points de terminaison les plus puissants. Analysons un jeton et disséquons la réponse.Python

def get_token_scan_details(chain, contract_address, include_dex=True, include_events=False):
    """
    Analyse un jeton et imprime des informations détaillées.
    """
    print(f"\n--- Analyse du jeton : {contract_address} sur {chain} ---")
    endpoint = f"/tokens/scan/{chain}/{contract_address}"
    params = {
        "includeDexScreenerData": str(include_dex).lower(), # L'API attend la chaîne "true" ou "false"
        "includeSignificantEvents": str(include_events).lower()
    }
    
    data = make_api_request(endpoint, params=params)
    
    if data:
        print(f"ID de l'analyse : {data.get('id')}")
        print(f"Niveau de risque : {data.get('riskLevel')}")
        
        trust_score_data = data.get('trustScore', {})
        print(f"Score de confiance : {trust_score_data.get('value')} ({trust_score_data.get('rating')})")

        print("\nArnaques trouvées :")
        scams = data.get('scams', [])
        if scams:
            for scam in scams:
                print(f"  - Type : {scam.get('type')}, Gravité : {scam.get('severity')}, Message : {scam.get('message')}")
        else:
            print("  Aucun indicateur d'arnaque spécifique trouvé par cette analyse.")

        print("\nAvertissements :")
        warnings = data.get('warnings', [])
        if warnings:
            for warning in warnings:
                print(f"  - Type : {warning.get('type')}, Gravité : {warning.get('severity')}, Message : {warning.get('message')}")
        else:
            print("  Aucun avertissement trouvé par cette analyse.")

        contract_details = data.get('contractDetails', {})
        print("\nDétails du contrat :")
        print(f"  Nom : {contract_details.get('name')}")
        print(f"  Symbole : {contract_details.get('symbol')}")
        print(f"  Décimales : {contract_details.get('decimals')}")
        print(f"  Propriétaire : {contract_details.get('ownerAddress')}")
        print(f"  Créateur : {contract_details.get('creatorAddress')}")
        print(f"  Vérifié : {contract_details.get('isVerified')}")
        if contract_details.get('isProxy'):
            print(f"  Implémentation du proxy : {contract_details.get('proxyImplementationAddress')}")
        
        taxes = data.get('taxes', {})
        print("\nImpôts :")
        print(f"  Taxe d'achat : {taxes.get('buyTax')}%")
        print(f"  Taxe de vente : {taxes.get('sellTax')}%")
        print(f"  Taxe de transfert : {taxes.get('transferTax')}%")
        if taxes.get('isBuyTaxModifiable') or taxes.get('isSellTaxModifiable') or taxes.get('isTransferTaxModifiable'):
            print("  Avertissement : une ou plusieurs taxes peuvent être modifiables.")

        liquidity = data.get('liquidityDetails', {})
        print("\nDétails de la liquidité :")
        if liquidity.get('dexes'):
            for dex in liquidity['dexes']:
                print(f"  DEX : {dex.get('name')} ({dex.get('pairAddress')})")
                print(f"    Liquidité : {dex.get('liquidityAmountInUsd')} USD")
                print(f"    Offre totale de LP : {dex.get('totalSupply')}")
                if dex.get('locks'):
                    for lock in dex['locks']:
                        print(f"      Verrou : Montant {lock.get('amountLocked')} jusqu'au {lock.get('unlockDate')}, Fournisseur : {lock.get('vendorName')}")
                else:
                    print("      Aucun verrou LP explicite trouvé pour ce DEX.")
        else:
            print("  Aucune information de liquidité DEX trouvée.")
            
        holder_analysis = data.get('holderAnalysis', {})
        print("\nAnalyse des détenteurs :")
        print(f"  Nombre de détenteurs : {holder_analysis.get('holderCount')}")
        if holder_analysis.get('topHolders'):
            print("  Principaux détenteurs :")
            for i, holder in enumerate(holder_analysis['topHolders'][:3]): # Afficher les 3 premiers pour plus de brièveté
                print(f"    {i+1}. Adresse : {holder.get('address')}, Solde : {holder.get('balance')}, % de l'offre : {holder.get('percentage')}%")
        
        if include_dex and 'dexScreenerData' in data and data['dexScreenerData']:
            dex_data = data['dexScreenerData']
            print("\nDonnées DEX Screener :")
            print(f"  Prix (USD) : {dex_data.get('priceUsd')}")
            print(f"  FDV (USD) : {dex_data.get('fdv')}")
            print(f"  Volume (24h USD) : {dex_data.get('volume', {}).get('h24')}")
            # Ajoutez d'autres champs selon les besoins
            
        # Vous pouvez de même traiter 'significantEvents' si include_events était True
        # print(json.dumps(data, indent=2)) # Pour imprimer la réponse brute complète pour l'exploration
    else:
        print("Impossible de récupérer les détails de l'analyse du jeton.")

# --- Exemple d'utilisation pour l'analyse des jetons ---
# Remplacez par une adresse de contrat et une chaîne valides de la liste prise en charge (par exemple, 'bsc', 'ethereum')
# Pour BSC (jetons BEP-20) : par exemple, contrat WBNB "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
# Pour Ethereum (jetons ERC-20) : par exemple, contrat USDC "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
# test_chain = "bsc"
# test_contract = "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c" # WBNB sur BSC (exemple)
# get_token_scan_details(test_chain, test_contract, include_dex=True)

Interprétation des résultats de l'analyse :

riskLevel : Donne une idée immédiate du danger potentiel. "CRITIQUE" ou "ÉLEVÉ" justifient une extrême prudence.
trustScore : Un score numérique qui peut être suivi ou comparé.
scams et warnings : Ces tableaux sont cruciaux. Ils détaillent des problèmes spécifiques tels que HONEYPOT, PROXY_CONTRACT, HIGH_TAXES, OWNERSHIP_NOT_RENOUNCED, BLACKLIST_FUNCTIONS, etc. Examinez toujours ces messages attentivement.
taxes : Des taxes élevées ou modifiables sont des signaux d'alerte.
liquidityDetails : Recherchez une liquidité importante non verrouillée ou une grande partie détenue par le déployeur. La liquidité verrouillée est un bon signe, mais vérifiez la durée du verrouillage et le fournisseur.
holderAnalysis : Une forte concentration de jetons dans quelques portefeuilles (en particulier les portefeuilles du déployeur ou de l'équipe s'ils ne sont pas acquis) peut être risquée.

3. Exemple 2 : Récupération du code source (/tokens/source-code/{chain}/{contractAddress})

Savoir si un contrat est vérifié et pouvoir inspecter son code source est essentiel.Python

def get_token_source_code(chain, contract_address):
    """
    Récupère et affiche des informations sur le code source d'un jeton.
    """
    print(f"\n--- Récupération du code source pour : {contract_address} sur {chain} ---")
    endpoint = f"/tokens/source-code/{chain}/{contract_address}"
    
    data = make_api_request(endpoint)
    
    if data:
        print(f"Nom du contrat : {data.get('contractName')}")
        print(f"Est vérifié : {data.get('isVerified')}")
        
        if data.get('isVerified'):
            # L'ABI peut être très long, alors imprimez simplement un extrait ou sa présence
            print(f"ABI : {'Présent' if data.get('abi') else 'Non disponible'}") 
            
            source_code = data.get('sourceCode')
            if isinstance(source_code, str):
                print(f"Extrait du code source (500 premiers caractères) :\n{source_code[:500]}...")
                # Dans une application réelle, vous pourriez enregistrer cela dans un fichier :
                # with open(f"{contract_address}_source.sol", "w") as f:
                # f.write(source_code)
                # print(f"Le code source complet a été enregistré dans {contract_address}_source.sol")
            elif isinstance(source_code, dict): # Pour les sources multi-fichiers
                print("Code source (plusieurs fichiers) :")
                for filename, content in source_code.items():
                    print(f"  Fichier : {filename}, Extrait (200 premiers caractères) : {content.get('content', '')[:200]}...")
            else:
                print("Code source : Non disponible ou format inattendu.")
        else:
            print("Le code source du contrat n'est pas vérifié ou n'est pas disponible.")
    else:
        print("Impossible de récupérer les informations du code source.")

# --- Exemple d'utilisation pour le code source ---
# test_chain_eth = "ethereum"
# usdc_contract_eth = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" # USDC sur Ethereum (vérifié)
# get_token_source_code(test_chain_eth, usdc_contract_eth)

4. Exemple 3 : Évaluation des risques du portefeuille (/wallets/risk-rating/{chain}/{walletAddress})

L'analyse des portefeuilles associés à un projet (par exemple, le déployeur, les portefeuilles de l'équipe) peut révéler des risques.Python

def get_wallet_risk_rating(chain, wallet_address):
    """
    Récupère et affiche l'évaluation des risques pour un portefeuille.
    """
    print(f"\n--- Obtention de l'évaluation des risques pour le portefeuille : {wallet_address} sur {chain} ---")
    endpoint = f"/wallets/risk-rating/{chain}/{wallet_address}"
    
    data = make_api_request(endpoint)
    
    if data:
        print(f"Niveau de risque global du portefeuille : {data.get('riskLevel')}")
        print(f"Résumé : {data.get('summary')}")
        
        print("\nJetons associés avec risque :")
        associated_tokens = data.get('associatedTokens', [])
        if associated_tokens:
            for token_info in associated_tokens:
                print(f"  - Jeton : {token_info.get('symbol')} ({token_info.get('contractAddress')})")
                print(f"    Chaîne : {token_info.get('chain')}")
                print(f"    Niveau de risque : {token_info.get('riskLevel')}")
                print(f"    Rôle : {token_info.get('roleInTokenContext')} (par exemple, Déployeur, Propriétaire)")
        else:
            print("  Aucun jeton associé avec un risque notable trouvé lié à ce portefeuille par l'analyse.")
            
        # D'autres champs comme 'activitySummary', 'knownAssociations' pourraient également être analysés.
        # print(json.dumps(data, indent=2)) # Pour une réponse complète
    else:
        print("Impossible de récupérer l'évaluation des risques du portefeuille.")

# --- Exemple d'utilisation pour l'évaluation des risques du portefeuille ---
# Remplacez par une adresse de portefeuille et une chaîne réelles
# Exemple : Une adresse de portefeuille de déployeur que vous étudiez
# test_wallet_chain = "bsc"
# test_wallet_address = "0x000000000000000000000000000000000000dead" # Exemple, utilisez-en un réel
# get_wallet_risk_rating(test_wallet_chain, test_wallet_address)

5. Exemple 4 : Recherche de jetons (/tokens/search)

Si vous n'avez qu'un nom ou un symbole de jeton, vous pouvez essayer de trouver son adresse de contrat.Python

def search_for_token(query, chain=None, page_size=5):
    """
    Recherche des jetons et affiche les résultats.
    """
    print(f"\n--- Recherche de jetons avec la requête : '{query}' ---")
    endpoint = "/tokens/search"
    params = {
        "query": query,
        "pageSize": page_size
    }
    if chain:
        params["chain"] = chain
        print(f"Filtrage par chaîne : {chain}")
        
    data = make_api_request(endpoint, params=params)
    
    if data and 'items' in data:
        tokens_found = data['items']
        print(f"Jetons trouvés {len(tokens_found)} (affichage jusqu'à {page_size}) :")
        if tokens_found:
            for token in tokens_found:
                print(f"  Nom : {token.get('name')} ({token.get('symbol')})")
                print(f"    Contrat : {token.get('contractAddress')}")
                print(f"    Chaîne : {token.get('chain')}")
                print(f"    Niveau de risque : {token.get('riskLevel')}")
                print(f"    Lien DEX Screener : {token.get('dexScreenerLink')}")
                print("-" * 20)
        else:
            print("Aucun jeton trouvé correspondant à votre requête.")
        
        # Les détails de la pagination sont également disponibles si vous souhaitez implémenter une pagination complète
        # print(f"Nombre total d'éléments : {data.get('totalItems')}, Page : {data.get('pageNumber')}, Nombre total de pages : {data.get('totalPages')}")
    else:
        print("Impossible d'effectuer la recherche de jetons ou aucun élément trouvé.")

# --- Exemple d'utilisation pour la recherche de jetons ---
# search_for_token("CAKE", chain="bsc")
# search_for_token("Shiba Inu") # Recherche large sur les chaînes

6. Exemple 5 : Liste des chaînes prises en charge (/utils/chains)

Un appel utilitaire simple pour obtenir une liste des chaînes prises en charge par l'API. Cela peut être utile pour valider les entrées de l'utilisateur ou renseigner des listes déroulantes dans une application.Python

def list_supported_chains():
    """
    Liste toutes les chaînes prises en charge par l'API Rugcheck.xyz.
    """
    print("\n--- Blockchains prises en charge par l'API Rugcheck.xyz ---")
    endpoint = "/utils/chains"
    data = make_api_request(endpoint)
    
    if data:
        for chain_info in data:
            print(f"  ID : {chain_info.get('id'):<15} Nom : {chain_info.get('name'):<20} Natif : {chain_info.get('nativeCurrencySymbol')}")
    else:
        print("Impossible de récupérer les chaînes prises en charge.")

# --- Exemple d'utilisation pour la liste des chaînes ---
# list_supported_chains()

Exécution des exemples :

Pour exécuter ces exemples :

Enregistrez le code en tant que fichier Python (par exemple, rugcheck_user.py).
Définissez votre clé API : export RUGCHECK_API_KEY="YOUR_ACTUAL_API_KEY" (sur Linux/macOS) ou définissez-la dans les variables d'environnement de votre système (Windows).
Décommentez les lignes d'exemple d'utilisation à la fin de chaque bloc de fonction que vous souhaitez tester.
Exécutez à partir de votre terminal : python rugcheck_user.py

Partie 5 : Meilleures pratiques et conseils avancés

Sécurité de la clé API : Réitérez : Utilisez des variables d'environnement ou un service de gestion des secrets. Ne codez jamais en dur les clés.
Limitation du débit : Tenez compte des limites de débit de l'API. Si vous obtenez des erreurs 429 Too Many Requests, ralentissez vos requêtes. Implémentez un algorithme d'attente exponentielle pour les nouvelles tentatives. La documentation de l'API ou les détails de votre plan doivent spécifier les limites.
Gestion des erreurs : La fonction make_api_request inclut une gestion des erreurs de base. Développez-la selon vos besoins pour votre application (par exemple, enregistrement des erreurs dans un fichier, logique de nouvelle tentative spécifique pour certains codes d'erreur).
Reportez-vous à Swagger : L'interface utilisateur Swagger (https://api.rugcheck.xyz/swagger/index.html) est votre source définitive pour tous les points de terminaison, paramètres, corps de requête et schémas de réponse. Vérifiez-la souvent pour les mises à jour.
Mise en cache : Pour les données qui ne changent pas fréquemment (comme le code source d'un contrat déployé ou un résultat d'analyse, sauf si forceRescan est utilisé), envisagez de mettre en cache les réponses de l'API pour améliorer les performances et réduire le volume des appels d'API.
Comprendre les limites : Les outils automatisés comme Rugcheck.xyz sont incroyablement précieux, mais pas infaillibles. Ils identifient les schémas connus et les risques potentiels. Les escrocs sophistiqués peuvent concevoir de nouvelles techniques. Combinez toujours les données de l'API avec vos propres recherches (DYOR) et votre esprit critique.
Interprétation des données : L'API fournit des données ; vous fournissez l'interprétation. Comprenez ce que chaque champ signifie (par exemple, un "avertissement" concernant OWNERSHIP_NOT_RENOUNCED est un facteur de risque important).

Conclusion

L'API Rugcheck.xyz offre un moyen robuste et détaillé d'évaluer par programmation les risques associés aux projets de cryptomonnaie. En maîtrisant son utilisation grâce à un codage pratique, comme démontré dans ce guide, vous pouvez améliorer considérablement votre processus de diligence raisonnable, créer des systèmes de trading automatisés plus sûrs et contribuer à un écosystème DeFi plus transparent. N'oubliez pas de toujours utiliser ces outils de manière responsable et en conjonction avec des recherches approfondies. La puissance de l'API réside dans votre capacité à interroger, analyser et interpréter efficacement la richesse des données qu'elle fournit.

💡

button