So erhalten Sie einen Rugcheck API-Schlüssel und verwenden die Rugcheck API

Die Kryptowährungslandschaft ist voller Chancen, aber auch mit erheblichen Risiken behaftet. Rug Pulls und schlecht konzipierte Token können zu erheblichen Verlusten führen. Rugcheck.xyz bietet einen kritischen Dienst, indem es Kryptoprojekte auf potenzielle rote Fahnen analysiert. Seine API ermöglicht es Entwicklern, Tradern und Analysten, programmatisch auf diese Erkenntnisse zuzugreifen und ihre Due-Diligence-Bemühungen zu automatisieren und zu skalieren. Dieser Leitfaden konzentriert sich stark darauf, wie man die Rugcheck.xyz API verwendet, und stattet Sie mit praktischen Python-Beispielen aus.

Ein kurzer Überblick über Rugcheck.xyz und seine API

Was ist Rugcheck.xyz?

Rugcheck.xyz ist eine Plattform, die entwickelt wurde, um Kryptowährungstoken und Smart Contracts auf Anzeichen böswilliger Absichten (wie Rug Pulls oder Honeypots) oder inhärenter Risiken zu untersuchen. Sie untersucht Vertragscode, Liquidität, Tokenomics, Entwickler-Wallets und mehr und liefert Risikobewertungen und detaillierte Berichte.

Warum die API?

Die API gewährt programmatischen Zugriff auf die Analyse-Engine von Rugcheck.xyz und ermöglicht:

• Automatisierung: Integrieren Sie Checks in Trading-Bots oder neue Token-Alert-Systeme.
• Skalierbarkeit: Analysieren Sie zahlreiche Token viel schneller als mit manuellen Checks.
• Anpassung: Erstellen Sie maßgeschneiderte Dashboards und Risikomodelle mithilfe von Rohdaten der API.

So erhalten Sie Ihren Rugcheck.xyz API-Schlüssel – das Wesentliche

Um die API zu verwenden, benötigen Sie einen API-Schlüssel. Die Rugcheck.xyz API-Dokumentation (https://api.rugcheck.xyz/swagger/index.html) impliziert ein Benutzerkontensystem für die Schlüsselverwaltung über Endpunkte wie /user/api-keys.

1. Registrieren/Anmelden: Besuchen Sie die Hauptwebsite von Rugcheck.xyz und erstellen Sie ein Konto oder melden Sie sich an.
2. API-Einstellungen finden: Suchen Sie in Ihrem Benutzer-Dashboard nach einem Abschnitt "API", "Entwickler" oder "API-Schlüssel".
3. Schlüssel generieren: Erstellen Sie einen neuen API-Schlüssel. Sie können ihn möglicherweise benennen, um die Identifizierung zu erleichtern.
4. Schützen Sie Ihren Schlüssel: Kopieren Sie den generierten Schlüssel und speichern Sie ihn sicher (z. B. Passwort-Manager, Umgebungsvariable). Exponieren Sie ihn niemals in öffentlichen Code-Repositories oder clientseitigen Anwendungen.

Alle API-Anfragen erfordern, dass dieser Schlüssel im X-API-KEY-Header gesendet wird.

Bevor wir uns in den Code stürzen, hier einige primäre Endpunkte, mit denen wir arbeiten werden (siehe Swagger-Dokumente für ausführliche Details):

• GET /tokens/scan/{chain}/{contractAddress}: Führt einen Echtzeit-Scan eines Tokens durch. Gibt Risikostufen, Warnungen, Vertragsdetails, Liquiditätsinformationen usw. zurück.
• GET /tokens/source-code/{chain}/{contractAddress}: Ruft den verifizierten Smart-Contract-Quellcode und die ABI eines Tokens ab.
• GET /wallets/risk-rating/{chain}/{walletAddress}: Beurteilt das Risikoprofil einer bestimmten Wallet-Adresse.
• GET /tokens/search: Sucht nach Token nach Name oder Symbol.
• GET /utils/chains: Listet alle von der API unterstützten Blockchain-Netzwerke auf.

Die Base URL für alle Anfragen ist: https://api.rugcheck.xyz

So verwenden Sie die Rugcheck.xyz API: Ausführliche Python-Beispiele

Hier werden wir praktisch. Wir verwenden Python mit der requests-Bibliothek.

Voraussetzungen:

• Python 3.x installiert.
• requests-Bibliothek: pip install requests
• Ihr Rugcheck.xyz API-Schlüssel.

1. Einrichtung und Kern-API-Aufruffunktion

Zuerst richten wir unsere Umgebung ein und erstellen eine wiederverwendbare Funktion zur Verarbeitung von API-Aufrufen. Es ist Best Practice, Ihren API-Schlüssel als Umgebungsvariable zu speichern.Python

import requests
import json
import os

# Load API key from environment variable for security
API_KEY = os.getenv('RUGCHECK_API_KEY')
BASE_URL = "https://api.rugcheck.xyz"

if not API_KEY:
    print("Error: RUGCHECK_API_KEY environment variable not set.")
    # You might want to exit or raise an exception here in a real application
    # For demonstration, we'll allow it to proceed but calls will fail.
    # API_KEY = "YOUR_FALLBACK_API_KEY_FOR_TESTING_ONLY" # Not recommended for actual use

HEADERS = {
    "X-API-KEY": API_KEY,
    "Accept": "application/json" # Good practice to specify accepted response type
}

def make_api_request(endpoint, params=None):
    """
    Makes a GET request to the Rugcheck.xyz API.
    
    Args:
        endpoint (str): The API endpoint path (e.g., "/utils/chains").
        params (dict, optional): Query parameters for the request.
        
    Returns:
        dict or None: The JSON response as a Python dictionary, or None if an error occurs.
    """
    if not API_KEY or API_KEY == "YOUR_FALLBACK_API_KEY_FOR_TESTING_ONLY":
        print("Error: API Key is not properly configured.")
        return None
        
    url = f"{BASE_URL}{endpoint}"
    try:
        response = requests.get(url, headers=HEADERS, params=params, timeout=30) # 30-second timeout
        response.raise_for_status()  # Raises HTTPError for bad responses (4xx or 5xx)
        return response.json()
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}")
        print(f"Status Code: {response.status_code}")
        try:
            # Try to print error details from API if available in JSON
            print(f"Error Response: {response.json()}")
        except json.JSONDecodeError:
            print(f"Error Response (not JSON): {response.text}")
    except requests.exceptions.ConnectionError as conn_err:
        print(f"Connection error occurred: {conn_err}")
    except requests.exceptions.Timeout as timeout_err:
        print(f"Timeout error occurred: {timeout_err}")
    except requests.exceptions.RequestException as req_err:
        print(f"An unexpected error occurred with the request: {req_err}")
    except json.JSONDecodeError: # If response.json() fails for non-HTTPError cases
        print("Failed to decode JSON response from API.")
        print(f"Response content: {response.text if 'response' in locals() else 'No response object'}")
    return None

Wichtig: Damit die folgenden Beispiele ausgeführt werden können, stellen Sie sicher, dass RUGCHECK_API_KEY in Ihrer Umgebung festgelegt ist. Sie benötigen außerdem gültige Vertragsadressen und Wallet-Adressen für die jeweiligen Chains.

2. Beispiel 1: Deep Dive in Token Scan (/tokens/scan/{chain}/{contractAddress})

Dies ist einer der leistungsstärksten Endpunkte. Scannen wir einen Token und zerlegen die Antwort.Python

def get_token_scan_details(chain, contract_address, include_dex=True, include_events=False):
    """
    Scans a token and prints detailed information.
    """
    print(f"\n--- Scanning Token: {contract_address} on {chain} ---")
    endpoint = f"/tokens/scan/{chain}/{contract_address}"
    params = {
        "includeDexScreenerData": str(include_dex).lower(), # API expects string "true" or "false"
        "includeSignificantEvents": str(include_events).lower()
    }
    
    data = make_api_request(endpoint, params=params)
    
    if data:
        print(f"Scan ID: {data.get('id')}")
        print(f"Risk Level: {data.get('riskLevel')}")
        
        trust_score_data = data.get('trustScore', {})
        print(f"Trust Score: {trust_score_data.get('value')} ({trust_score_data.get('rating')})")

        print("\nScams Found:")
        scams = data.get('scams', [])
        if scams:
            for scam in scams:
                print(f"  - Type: {scam.get('type')}, Severity: {scam.get('severity')}, Message: {scam.get('message')}")
        else:
            print("  No specific scam indicators found by this scan.")

        print("\nWarnings:")
        warnings = data.get('warnings', [])
        if warnings:
            for warning in warnings:
                print(f"  - Type: {warning.get('type')}, Severity: {warning.get('severity')}, Message: {warning.get('message')}")
        else:
            print("  No warnings found by this scan.")

        contract_details = data.get('contractDetails', {})
        print("\nContract Details:")
        print(f"  Name: {contract_details.get('name')}")
        print(f"  Symbol: {contract_details.get('symbol')}")
        print(f"  Decimals: {contract_details.get('decimals')}")
        print(f"  Owner: {contract_details.get('ownerAddress')}")
        print(f"  Creator: {contract_details.get('creatorAddress')}")
        print(f"  Verified: {contract_details.get('isVerified')}")
        if contract_details.get('isProxy'):
            print(f"  Proxy Implementation: {contract_details.get('proxyImplementationAddress')}")
        
        taxes = data.get('taxes', {})
        print("\nTaxes:")
        print(f"  Buy Tax: {taxes.get('buyTax')}%")
        print(f"  Sell Tax: {taxes.get('sellTax')}%")
        print(f"  Transfer Tax: {taxes.get('transferTax')}%")
        if taxes.get('isBuyTaxModifiable') or taxes.get('isSellTaxModifiable') or taxes.get('isTransferTaxModifiable'):
            print("  Warning: One or more taxes may be modifiable.")

        liquidity = data.get('liquidityDetails', {})
        print("\nLiquidity Details:")
        if liquidity.get('dexes'):
            for dex in liquidity['dexes']:
                print(f"  DEX: {dex.get('name')} ({dex.get('pairAddress')})")
                print(f"    Liquidity: {dex.get('liquidityAmountInUsd')} USD")
                print(f"    Total LP Supply: {dex.get('totalSupply')}")
                if dex.get('locks'):
                    for lock in dex['locks']:
                        print(f"      Lock: Amount {lock.get('amountLocked')} until {lock.get('unlockDate')}, Vendor: {lock.get('vendorName')}")
                else:
                    print("      No explicit LP locks found for this DEX.")
        else:
            print("  No DEX liquidity information found.")
            
        holder_analysis = data.get('holderAnalysis', {})
        print("\nHolder Analysis:")
        print(f"  Holder Count: {holder_analysis.get('holderCount')}")
        if holder_analysis.get('topHolders'):
            print("  Top Holders:")
            for i, holder in enumerate(holder_analysis['topHolders'][:3]): # Display top 3 for brevity
                print(f"    {i+1}. Address: {holder.get('address')}, Balance: {holder.get('balance')}, % Supply: {holder.get('percentage')}%")
        
        if include_dex and 'dexScreenerData' in data and data['dexScreenerData']:
            dex_data = data['dexScreenerData']
            print("\nDEX Screener Data:")
            print(f"  Price (USD): {dex_data.get('priceUsd')}")
            print(f"  FDV (USD): {dex_data.get('fdv')}")
            print(f"  Volume (24h USD): {dex_data.get('volume', {}).get('h24')}")
            # Add more fields as needed
            
        # You can similarly process 'significantEvents' if include_events was True
        # print(json.dumps(data, indent=2)) # To print the full raw response for exploration
    else:
        print("Failed to retrieve token scan details.")

# --- Usage Example for Token Scan ---
# Replace with a valid contract address and chain from the supported list (e.g., 'bsc', 'ethereum')
# For BSC (BEP-20 tokens): e.g., WBNB contract "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
# For Ethereum (ERC-20 tokens): e.g., USDC contract "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
# test_chain = "bsc"
# test_contract = "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c" # WBNB on BSC (example)
# get_token_scan_details(test_chain, test_contract, include_dex=True)

Interpretation der Scan-Ergebnisse:

• riskLevel: Gibt ein sofortiges Gefühl der potenziellen Gefahr. "CRITICAL" oder "HIGH" erfordern äußerste Vorsicht.
• trustScore: Ein numerischer Wert, der verfolgt oder als Benchmark verwendet werden kann.
• scams und warnings: Diese Arrays sind entscheidend. Sie detaillieren spezifische Probleme wie HONEYPOT, PROXY_CONTRACT, HIGH_TAXES, OWNERSHIP_NOT_RENOUNCED, BLACKLIST_FUNCTIONS usw. Überprüfen Sie diese Nachrichten immer sorgfältig.
• taxes: Hohe oder modifizierbare Steuern sind rote Fahnen.
• liquidityDetails: Achten Sie auf erhebliche ungesperrte Liquidität oder einen großen Teil, der vom Bereitsteller gehalten wird. Gesperrte Liquidität ist ein gutes Zeichen, aber überprüfen Sie die Sperrdauer und den Anbieter.
• holderAnalysis: Eine hohe Konzentration von Token in wenigen Wallets (insbesondere den Wallets des Bereitstellers oder des Teams, wenn sie nicht vergeben sind) kann riskant sein.

3. Beispiel 2: Abrufen des Quellcodes (/tokens/source-code/{chain}/{contractAddress})

Zu wissen, ob ein Vertrag verifiziert ist und seinen Quellcode einsehen zu können, ist von entscheidender Bedeutung.Python

def get_token_source_code(chain, contract_address):
    """
    Retrieves and displays information about a token's source code.
    """
    print(f"\n--- Retrieving Source Code for: {contract_address} on {chain} ---")
    endpoint = f"/tokens/source-code/{chain}/{contract_address}"
    
    data = make_api_request(endpoint)
    
    if data:
        print(f"Contract Name: {data.get('contractName')}")
        print(f"Is Verified: {data.get('isVerified')}")
        
        if data.get('isVerified'):
            # The ABI can be very long, so just print a snippet or its presence
            print(f"ABI: {'Present' if data.get('abi') else 'Not available'}") 
            
            source_code = data.get('sourceCode')
            if isinstance(source_code, str):
                print(f"Source Code Snippet (first 500 chars):\n{source_code[:500]}...")
                # In a real app, you might save this to a file:
                # with open(f"{contract_address}_source.sol", "w") as f:
                # f.write(source_code)
                # print(f"Full source code saved to {contract_address}_source.sol")
            elif isinstance(source_code, dict): # For multi-file sources
                print("Source Code (multiple files):")
                for filename, content in source_code.items():
                    print(f"  File: {filename}, Snippet (first 200 chars): {content.get('content', '')[:200]}...")
            else:
                print("Source Code: Not available or unexpected format.")
        else:
            print("Contract source code is not verified or not available.")
    else:
        print("Failed to retrieve source code information.")

# --- Usage Example for Source Code ---
# test_chain_eth = "ethereum"
# usdc_contract_eth = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" # USDC on Ethereum (verified)
# get_token_source_code(test_chain_eth, usdc_contract_eth)

4. Beispiel 3: Wallet-Risikobewertung (/wallets/risk-rating/{chain}/{walletAddress})

Die Analyse von Wallets, die mit einem Projekt verbunden sind (z. B. Bereitsteller, Team-Wallets), kann Risiken aufdecken.Python

def get_wallet_risk_rating(chain, wallet_address):
    """
    Retrieves and displays the risk rating for a wallet.
    """
    print(f"\n--- Getting Risk Rating for Wallet: {wallet_address} on {chain} ---")
    endpoint = f"/wallets/risk-rating/{chain}/{wallet_address}"
    
    data = make_api_request(endpoint)
    
    if data:
        print(f"Overall Wallet Risk Level: {data.get('riskLevel')}")
        print(f"Summary: {data.get('summary')}")
        
        print("\nAssociated Tokens with Risk:")
        associated_tokens = data.get('associatedTokens', [])
        if associated_tokens:
            for token_info in associated_tokens:
                print(f"  - Token: {token_info.get('symbol')} ({token_info.get('contractAddress')})")
                print(f"    Chain: {token_info.get('chain')}")
                print(f"    Risk Level: {token_info.get('riskLevel')}")
                print(f"    Role: {token_info.get('roleInTokenContext')} (e.g., Deployer, Owner)")
        else:
            print("  No associated tokens with notable risk found linked to this wallet by the scan.")
            
        # Other fields like 'activitySummary', 'knownAssociations' could also be parsed.
        # print(json.dumps(data, indent=2)) # For full response
    else:
        print("Failed to retrieve wallet risk rating.")

# --- Usage Example for Wallet Risk Rating ---
# Replace with a real wallet address and chain
# Example: A deployer wallet address you are investigating
# test_wallet_chain = "bsc"
# test_wallet_address = "0x000000000000000000000000000000000000dead" # Example, use a real one
# get_wallet_risk_rating(test_wallet_chain, test_wallet_address)

5. Beispiel 4: Suchen nach Token (/tokens/search)

Wenn Sie nur einen Token-Namen oder ein Symbol haben, können Sie versuchen, seine Vertragsadresse zu finden.Python

def search_for_token(query, chain=None, page_size=5):
    """
    Searches for tokens and displays results.
    """
    print(f"\n--- Searching for tokens with query: '{query}' ---")
    endpoint = "/tokens/search"
    params = {
        "query": query,
        "pageSize": page_size
    }
    if chain:
        params["chain"] = chain
        print(f"Filtering by chain: {chain}")
        
    data = make_api_request(endpoint, params=params)
    
    if data and 'items' in data:
        tokens_found = data['items']
        print(f"Found {len(tokens_found)} token(s) (showing up to {page_size}):")
        if tokens_found:
            for token in tokens_found:
                print(f"  Name: {token.get('name')} ({token.get('symbol')})")
                print(f"    Contract: {token.get('contractAddress')}")
                print(f"    Chain: {token.get('chain')}")
                print(f"    Risk Level: {token.get('riskLevel')}")
                print(f"    DEX Screener Link: {token.get('dexScreenerLink')}")
                print("-" * 20)
        else:
            print("No tokens found matching your query.")
        
        # Pagination details are also available if you want to implement full pagination
        # print(f"Total Items: {data.get('totalItems')}, Page: {data.get('pageNumber')}, Total Pages: {data.get('totalPages')}")
    else:
        print("Failed to perform token search or no items found.")

# --- Usage Example for Token Search ---
# search_for_token("CAKE", chain="bsc")
# search_for_token("Shiba Inu") # Broad search across chains

6. Beispiel 5: Auflisten der unterstützten Chains (/utils/chains)

Ein einfacher Dienstaufruf, um eine Liste der Chains abzurufen, die die API unterstützt. Dies kann nützlich sein, um Benutzereingaben zu validieren oder Dropdowns in einer Anwendung zu füllen.Python

def list_supported_chains():
    """
    Lists all chains supported by the Rugcheck.xyz API.
    """
    print("\n--- Supported Blockchains by Rugcheck.xyz API ---")
    endpoint = "/utils/chains"
    data = make_api_request(endpoint)
    
    if data:
        for chain_info in data:
            print(f"  ID: {chain_info.get('id'):<15} Name: {chain_info.get('name'):<20} Native: {chain_info.get('nativeCurrencySymbol')}")
    else:
        print("Failed to retrieve supported chains.")

# --- Usage Example for Listing Chains ---
# list_supported_chains()

Ausführen der Beispiele:

Um diese Beispiele auszuführen:

1. Speichern Sie den Code als Python-Datei (z. B. rugcheck_user.py).
2. Legen Sie Ihren API-Schlüssel fest: export RUGCHECK_API_KEY="YOUR_ACTUAL_API_KEY" (unter Linux/macOS) oder legen Sie ihn in den Umgebungsvariablen Ihres Systems fest (Windows).
3. Entfernen Sie die Kommentarzeichen der Nutzungsbeispielzeilen am Ende jedes Funktionsblocks, den Sie testen möchten.
4. Führen Sie über Ihr Terminal aus: python rugcheck_user.py

Teil 5: Best Practices und erweiterte Tipps

• API-Schlüsselsicherheit: Wiederholen: Verwenden Sie Umgebungsvariablen oder einen Dienst zur Geheimnisverwaltung. Schlüssel niemals fest codieren.
• Ratenbegrenzung: Achten Sie auf API-Ratenlimits. Wenn Sie 429 Too Many Requests-Fehler erhalten, verlangsamen Sie Ihre Anfragen. Implementieren Sie exponentielles Backoff für Wiederholungen. Die API-Dokumentation oder Ihre Plan-Details sollten Limits angeben.
• Fehlerbehandlung: Die Funktion make_api_request enthält eine grundlegende Fehlerbehandlung. Erweitern Sie dies nach Bedarf für Ihre Anwendung (z. B. Protokollieren von Fehlern in einer Datei, spezifische Wiederholungslogik für bestimmte Fehlercodes).
• Beziehen Sie sich auf Swagger: Die Swagger-Benutzeroberfläche (https://api.rugcheck.xyz/swagger/index.html) ist Ihre endgültige Quelle für alle Endpunkte, Parameter, Anforderungstexte und Antwortschemata. Überprüfen Sie sie häufig auf Aktualisierungen.
• Caching: Für Daten, die sich nicht häufig ändern (wie z. B. Quellcode eines bereitgestellten Vertrags oder ein Scan-Ergebnis, es sei denn, forceRescan wird verwendet), sollten Sie das Caching von API-Antworten in Betracht ziehen, um die Leistung zu verbessern und das API-Aufrufvolumen zu reduzieren.
• Einschränkungen verstehen: Automatisierte Tools wie Rugcheck.xyz sind unglaublich wertvoll, aber nicht unfehlbar. Sie identifizieren bekannte Muster und potenzielle Risiken. Erfahrene Betrüger können neue Techniken entwickeln. Kombinieren Sie API-Daten immer mit Ihren eigenen Recherchen (DYOR) und kritischem Denken.
• Dateninterpretation: Die API liefert Daten; Sie liefern die Interpretation. Verstehen Sie, was jedes Feld bedeutet (z. B. ist eine "Warnung" über OWNERSHIP_NOT_RENOUNCED ein erheblicher Risikofaktor).

Fazit

Die Rugcheck.xyz API bietet eine robuste und detaillierte Möglichkeit, die mit Kryptowährungsprojekten verbundenen Risiken programmatisch zu bewerten. Indem Sie ihre Verwendung durch praktisches Codieren beherrschen, wie in diesem Leitfaden gezeigt, können Sie Ihren Due-Diligence-Prozess erheblich verbessern, sicherere automatisierte Handelssysteme erstellen und zu einem transparenteren DeFi-Ökosystem beitragen. Denken Sie daran, solche Tools immer verantwortungsvoll und in Verbindung mit umfassender Recherche zu verwenden. Die Leistungsfähigkeit der API liegt in Ihrer Fähigkeit, die Fülle an Daten, die sie liefert, effektiv abzufragen, zu parsen und zu interpretieren.