Blog

Cómo Obtener una Clave API de Rugcheck y Usar la API de Rugcheck

Mark Ponomarev

Mark Ponomarev

4 June 2025

Cómo Obtener una Clave API de Rugcheck y Usar la API de Rugcheck

El panorama de las criptomonedas está lleno de oportunidades, pero también de riesgos significativos. Las "rug pulls" (estafas de alfombra) y los tokens mal diseñados pueden provocar pérdidas sustanciales. Rugcheck.xyz ofrece un servicio fundamental al analizar proyectos criptográficos en busca de posibles señales de alerta. Su API permite a desarrolladores, traders y analistas acceder programáticamente a esta información, automatizando y escalando sus esfuerzos de debida diligencia. Esta guía se centrará en gran medida en cómo usar la API de Rugcheck.xyz, proporcionándote ejemplos prácticos en Python.

💡
¿Quieres una excelente herramienta de prueba de API que genere documentación de API hermosa?

¿Quieres una plataforma integrada y todo en uno para que tu equipo de desarrolladores trabaje con máxima productividad?

¡Apidog satisface todas tus demandas y reemplaza a Postman a un precio mucho más asequible!
button

Una Breve Descripción General de Rugcheck.xyz y su API

¿Qué es Rugcheck.xyz?

Rugcheck.xyz es una plataforma diseñada para examinar tokens y contratos inteligentes de criptomonedas en busca de signos de intención maliciosa (como rug pulls o honeypots) o riesgos inherentes. Examina el código del contrato, la liquidez, la tokenomics, las billeteras de los desarrolladores y más, proporcionando evaluaciones de riesgo e informes detallados.

¿Por qué la API?

La API otorga acceso programático al motor analítico de Rugcheck.xyz, permitiendo:

Obteniendo tu Clave API de Rugcheck.xyz – Lo Esencial

Para usar la API, necesitas una clave API. La documentación de la API de Rugcheck.xyz (https://api.rugcheck.xyz/swagger/index.html) implica un sistema de cuentas de usuario para la gestión de claves a través de endpoints como /user/api-keys.

  1. Registrarse/Iniciar Sesión: Visita el sitio web principal de Rugcheck.xyz y crea una cuenta o inicia sesión.
  2. Encontrar Configuración de API: Busca una sección "API", "Desarrollador" o "Claves API" en tu panel de usuario.
  3. Generar Clave: Crea una nueva clave API. Es posible que puedas nombrarla para una identificación más fácil.
  4. Protege tu Clave: Copia la clave generada y guárdala de forma segura (por ejemplo, gestor de contraseñas, variable de entorno). Nunca la expongas en repositorios de código públicos o aplicaciones del lado del cliente.

Todas las solicitudes a la API requieren que esta clave se envíe en el encabezado X-API-KEY.

Antes de sumergirnos en el código, aquí tienes algunos endpoints principales con los que trabajaremos (consulta la documentación de Swagger para detalles exhaustivos):

La URL Base para todas las solicitudes es: https://api.rugcheck.xyz

Cómo Usar la API de Rugcheck.xyz: Ejemplos Detallados en Python

Aquí es donde nos ponemos prácticos. Usaremos Python con la librería requests.

Requisitos Previos:

1. Configuración y Función Principal de Llamada a la API

Primero, configuremos nuestro entorno y creemos una función reutilizable para manejar las llamadas a la API. Es una buena práctica almacenar tu clave API como una variable de entorno.Python

import requests
import json
import os

# Carga la clave API desde una variable de entorno por seguridad
API_KEY = os.getenv('RUGCHECK_API_KEY')
BASE_URL = "https://api.rugcheck.xyz"

if not API_KEY:
    print("Error: La variable de entorno RUGCHECK_API_KEY no está configurada.")
    # En una aplicación real, podrías querer salir o lanzar una excepción aquí
    # Para demostración, permitiremos que continúe, pero las llamadas fallarán.
    # API_KEY = "YOUR_FALLBACK_API_KEY_FOR_TESTING_ONLY" # No recomendado para uso real

HEADERS = {
    "X-API-KEY": API_KEY,
    "Accept": "application/json" # Buena práctica especificar el tipo de respuesta aceptado
}

def make_api_request(endpoint, params=None):
    """
    Realiza una solicitud GET a la API de Rugcheck.xyz.

    Args:
        endpoint (str): La ruta del endpoint de la API (ej., "/utils/chains").
        params (dict, optional): Parámetros de consulta para la solicitud.

    Returns:
        dict or None: La respuesta JSON como un diccionario de Python, o None si ocurre un error.
    """
    if not API_KEY or API_KEY == "YOUR_FALLBACK_API_KEY_FOR_TESTING_ONLY":
        print("Error: La clave API no está configurada correctamente.")
        return None

    url = f"{BASE_URL}{endpoint}"
    try:
        response = requests.get(url, headers=HEADERS, params=params, timeout=30) # Tiempo de espera de 30 segundos
        response.raise_for_status()  # Lanza HTTPError para respuestas malas (4xx o 5xx)
        return response.json()
    except requests.exceptions.HTTPError as http_err:
        print(f"Ocurrió un error HTTP: {http_err}")
        print(f"Código de Estado: {response.status_code}")
        try:
            # Intenta imprimir detalles del error de la API si están disponibles en JSON
            print(f"Respuesta de Error: {response.json()}")
        except json.JSONDecodeError:
            print(f"Respuesta de Error (no es JSON): {response.text}")
    except requests.exceptions.ConnectionError as conn_err:
        print(f"Ocurrió un error de conexión: {conn_err}")
    except requests.exceptions.Timeout as timeout_err:
        print(f"Ocurrió un error de tiempo de espera: {timeout_err}")
    except requests.exceptions.RequestException as req_err:
        print(f"Ocurrió un error inesperado con la solicitud: {req_err}")
    except json.JSONDecodeError: # Si response.json() falla para casos que no son HTTPError
        print("No se pudo decodificar la respuesta JSON de la API.")
        print(f"Contenido de la respuesta: {response.text if 'response' in locals() else 'No hay objeto de respuesta'}")
    return None

Importante: Para que los siguientes ejemplos funcionen, asegúrate de que RUGCHECK_API_KEY esté configurada en tu entorno. También necesitarás direcciones de contrato y direcciones de billetera válidas para las cadenas respectivas.

2. Ejemplo 1: Análisis Profundo del Escaneo de Token (/tokens/scan/{chain}/{contractAddress})

Este es uno de los endpoints más potentes. Escaneemos un token y analicemos la respuesta.Python

def get_token_scan_details(chain, contract_address, include_dex=True, include_events=False):
    """
    Escanea un token e imprime información detallada.
    """
    print(f"\n--- Escaneando Token: {contract_address} en {chain} ---")
    endpoint = f"/tokens/scan/{chain}/{contract_address}"
    params = {
        "includeDexScreenerData": str(include_dex).lower(), # La API espera la cadena "true" o "false"
        "includeSignificantEvents": str(include_events).lower()
    }

    data = make_api_request(endpoint, params=params)

    if data:
        print(f"ID del Escaneo: {data.get('id')}")
        print(f"Nivel de Riesgo: {data.get('riskLevel')}")

        trust_score_data = data.get('trustScore', {})
        print(f"Puntuación de Confianza: {trust_score_data.get('value')} ({trust_score_data.get('rating')})")

        print("\nEstafas Encontradas:")
        scams = data.get('scams', [])
        if scams:
            for scam in scams:
                print(f"  - Tipo: {scam.get('type')}, Severidad: {scam.get('severity')}, Mensaje: {scam.get('message')}")
        else:
            print("  No se encontraron indicadores de estafa específicos en este escaneo.")

        print("\nAdvertencias:")
        warnings = data.get('warnings', [])
        if warnings:
            for warning in warnings:
                print(f"  - Tipo: {warning.get('type')}, Severidad: {warning.get('severity')}, Mensaje: {warning.get('message')}")
        else:
            print("  No se encontraron advertencias en este escaneo.")

        contract_details = data.get('contractDetails', {})
        print("\nDetalles del Contrato:")
        print(f"  Nombre: {contract_details.get('name')}")
        print(f"  Símbolo: {contract_details.get('symbol')}")
        print(f"  Decimales: {contract_details.get('decimals')}")
        print(f"  Propietario: {contract_details.get('ownerAddress')}")
        print(f"  Creador: {contract_details.get('creatorAddress')}")
        print(f"  Verificado: {contract_details.get('isVerified')}")
        if contract_details.get('isProxy'):
            print(f"  Implementación Proxy: {contract_details.get('proxyImplementationAddress')}")

        taxes = data.get('taxes', {})
        print("\nImpuestos:")
        print(f"  Impuesto de Compra: {taxes.get('buyTax')}%")
        print(f"  Impuesto de Venta: {taxes.get('sellTax')}%")
        print(f"  Impuesto de Transferencia: {taxes.get('transferTax')}%")
        if taxes.get('isBuyTaxModifiable') or taxes.get('isSellTaxModifiable') or taxes.get('isTransferTaxModifiable'):
            print("  Advertencia: Uno o más impuestos pueden ser modificables.")

        liquidity = data.get('liquidityDetails', {})
        print("\nDetalles de Liquidez:")
        if liquidity.get('dexes'):
            for dex in liquidity['dexes']:
                print(f"  DEX: {dex.get('name')} ({dex.get('pairAddress')})")
                print(f"    Liquidez: {dex.get('liquidityAmountInUsd')} USD")
                print(f"    Suministro Total de LP: {dex.get('totalSupply')}")
                if dex.get('locks'):
                    for lock in dex['locks']:
                        print(f"      Bloqueo: Cantidad {lock.get('amountLocked')} hasta {lock.get('unlockDate')}, Proveedor: {lock.get('vendorName')}")
                else:
                    print("      No se encontraron bloqueos de LP explícitos para este DEX.")
        else:
            print("  No se encontró información de liquidez de DEX.")

        holder_analysis = data.get('holderAnalysis', {})
        print("\nAnálisis de Holders:")
        print(f"  Cantidad de Holders: {holder_analysis.get('holderCount')}")
        if holder_analysis.get('topHolders'):
            print("  Principales Holders:")
            # Mostrar los 3 principales por brevedad
            for i, holder in enumerate(holder_analysis['topHolders'][:3]):
                print(f"    {i+1}. Dirección: {holder.get('address')}, Saldo: {holder.get('balance')}, % Suministro: {holder.get('percentage')}%")

        if include_dex and 'dexScreenerData' in data and data['dexScreenerData']:
            dex_data = data['dexScreenerData']
            print("\nDatos de DEX Screener:")
            print(f"  Precio (USD): {dex_data.get('priceUsd')}")
            print(f"  FDV (USD): {dex_data.get('fdv')}")
            print(f"  Volumen (24h USD): {dex_data.get('volume', {}).get('h24')}")
            # Añade más campos según sea necesario

        # De manera similar, puedes procesar 'significantEvents' si include_events fue True
        # print(json.dumps(data, indent=2)) # Para imprimir la respuesta cruda completa para exploración
    else:
        print("No se pudieron recuperar los detalles del escaneo del token.")

# --- Ejemplo de Uso para Escaneo de Token ---
# Reemplaza con una dirección de contrato y cadena válidas de la lista soportada (ej., 'bsc', 'ethereum')
# Para BSC (tokens BEP-20): ej., contrato WBNB "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
# Para Ethereum (tokens ERC-20): ej., contrato USDC "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
# test_chain = "bsc"
# test_contract = "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c" # WBNB en BSC (ejemplo)
# get_token_scan_details(test_chain, test_contract, include_dex=True)

Interpretación de los Resultados del Escaneo:

3. Ejemplo 2: Recuperando el Código Fuente (/tokens/source-code/{chain}/{contractAddress})

Saber si un contrato está verificado y poder inspeccionar su código fuente es vital.Python

def get_token_source_code(chain, contract_address):
    """
    Recupera y muestra información sobre el código fuente de un token.
    """
    print(f"\n--- Recuperando Código Fuente para: {contract_address} en {chain} ---")
    endpoint = f"/tokens/source-code/{chain}/{contract_address}"

    data = make_api_request(endpoint)

    if data:
        print(f"Nombre del Contrato: {data.get('contractName')}")
        print(f"Está Verificado: {data.get('isVerified')}")

        if data.get('isVerified'):
            # El ABI puede ser muy largo, así que solo imprime un fragmento o su presencia
            print(f"ABI: {'Presente' if data.get('abi') else 'No disponible'}")

            source_code = data.get('sourceCode')
            if isinstance(source_code, str):
                print(f"Fragmento del Código Fuente (primeros 500 caracteres):\n{source_code[:500]}...")
                # En una aplicación real, podrías guardarlo en un archivo:
                # with open(f"{contract_address}_source.sol", "w") as f:
                # f.write(source_code)
                # print(f"Código fuente completo guardado en {contract_address}_source.sol")
            elif isinstance(source_code, dict): # Para fuentes de múltiples archivos
                print("Código Fuente (múltiples archivos):")
                for filename, content in source_code.items():
                    print(f"  Archivo: {filename}, Fragmento (primeros 200 caracteres): {content.get('content', '')[:200]}...")
            else:
                print("Código Fuente: No disponible o formato inesperado.")
        else:
            print("El código fuente del contrato no está verificado o no está disponible.")
    else:
        print("No se pudo recuperar la información del código fuente.")

# --- Ejemplo de Uso para Código Fuente ---
# test_chain_eth = "ethereum"
# usdc_contract_eth = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" # USDC en Ethereum (verificado)
# get_token_source_code(test_chain_eth, usdc_contract_eth)

4. Ejemplo 3: Calificación de Riesgo de Billetera (/wallets/risk-rating/{chain}/{walletAddress})

Analizar las billeteras asociadas a un proyecto (por ejemplo, billeteras del implementador, del equipo) puede revelar riesgos.Python

def get_wallet_risk_rating(chain, wallet_address):
    """
    Recupera y muestra la calificación de riesgo para una billetera.
    """
    print(f"\n--- Obteniendo Calificación de Riesgo para Billetera: {wallet_address} en {chain} ---")
    endpoint = f"/wallets/risk-rating/{chain}/{wallet_address}"

    data = make_api_request(endpoint)

    if data:
        print(f"Nivel de Riesgo General de la Billetera: {data.get('riskLevel')}")
        print(f"Resumen: {data.get('summary')}")

        print("\nTokens Asociados con Riesgo:")
        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"    Cadena: {token_info.get('chain')}")
                print(f"    Nivel de Riesgo: {token_info.get('riskLevel')}")
                print(f"    Rol: {token_info.get('roleInTokenContext')} (ej., Implementador, Propietario)")
        else:
            print("  No se encontraron tokens asociados con riesgo notable vinculados a esta billetera por el escaneo.")

        # Otros campos como 'activitySummary', 'knownAssociations' también podrían ser parseados.
        # print(json.dumps(data, indent=2)) # Para respuesta completa
    else:
        print("No se pudo recuperar la calificación de riesgo de la billetera.")

# --- Ejemplo de Uso para Calificación de Riesgo de Billetera ---
# Reemplaza con una dirección de billetera y cadena reales
# Ejemplo: Una dirección de billetera de implementador que estás investigando
# test_wallet_chain = "bsc"
# test_wallet_address = "0x000000000000000000000000000000000000dead" # Ejemplo, usa una real
# get_wallet_risk_rating(test_wallet_chain, test_wallet_address)

5. Ejemplo 4: Buscando Tokens (/tokens/search)

Si solo tienes el nombre o símbolo de un token, puedes intentar encontrar su dirección de contrato.Python

def search_for_token(query, chain=None, page_size=5):
    """
    Busca tokens y muestra los resultados.
    """
    print(f"\n--- Buscando tokens con la consulta: '{query}' ---")
    endpoint = "/tokens/search"
    params = {
        "query": query,
        "pageSize": page_size
    }
    if chain:
        params["chain"] = chain
        print(f"Filtrando por cadena: {chain}")

    data = make_api_request(endpoint, params=params)

    if data and 'items' in data:
        tokens_found = data['items']
        print(f"Encontrado(s) {len(tokens_found)} token(s) (mostrando hasta {page_size}):")
        if tokens_found:
            for token in tokens_found:
                print(f"  Nombre: {token.get('name')} ({token.get('symbol')})")
                print(f"    Contrato: {token.get('contractAddress')}")
                print(f"    Cadena: {token.get('chain')}")
                print(f"    Nivel de Riesgo: {token.get('riskLevel')}")
                print(f"    Enlace DEX Screener: {token.get('dexScreenerLink')}")
                print("-" * 20)
        else:
            print("No se encontraron tokens que coincidan con tu consulta.")

        # Los detalles de paginación también están disponibles si quieres implementar paginación completa
        # print(f"Total de Elementos: {data.get('totalItems')}, Página: {data.get('pageNumber')}, Total de Páginas: {data.get('totalPages')}")
    else:
        print("No se pudo realizar la búsqueda de tokens o no se encontraron elementos.")

# --- Ejemplo de Uso para Búsqueda de Token ---
# search_for_token("CAKE", chain="bsc")
# search_for_token("Shiba Inu") # Búsqueda amplia en todas las cadenas

6. Ejemplo 5: Listando Cadenas Soportadas (/utils/chains)

Una simple llamada de utilidad para obtener una lista de las cadenas que la API soporta. Esto puede ser útil para validar la entrada del usuario o para llenar menús desplegables en una aplicación.Python

def list_supported_chains():
    """
    Lista todas las cadenas soportadas por la API de Rugcheck.xyz.
    """
    print("\n--- Blockchains Soportadas por la API de 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} Nombre: {chain_info.get('name'):<20} Nativa: {chain_info.get('nativeCurrencySymbol')}")
    else:
        print("No se pudieron recuperar las cadenas soportadas.")

# --- Ejemplo de Uso para Listar Cadenas ---
# list_supported_chains()

Ejecutando los Ejemplos:

Para ejecutar estos ejemplos:

  1. Guarda el código como un archivo Python (ej., rugcheck_user.py).
  2. Configura tu clave API: export RUGCHECK_API_KEY="TU_CLAVE_API_REAL" (en Linux/macOS) o configúrala en las variables de entorno de tu sistema (Windows).
  3. Descomenta las líneas de ejemplo de uso al final de cada bloque de función que quieras probar.
  4. Ejecuta desde tu terminal: python rugcheck_user.py

Parte 5: Mejores Prácticas y Consejos Avanzados

Conclusión

La API de Rugcheck.xyz ofrece una forma robusta y detallada de evaluar programáticamente los riesgos asociados con los proyectos de criptomonedas. Al dominar su uso a través de la codificación práctica, como se demuestra en esta guía, puedes mejorar significativamente tu proceso de debida diligencia, construir sistemas de trading automatizados más seguros y contribuir a un ecosistema DeFi más transparente. Recuerda usar siempre estas herramientas de manera responsable y junto con una investigación exhaustiva. El poder de la API reside en tu capacidad para consultar, analizar e interpretar eficazmente la gran cantidad de datos que proporciona.

💡
¿Quieres una excelente herramienta de prueba de API que genere documentación de API hermosa?

¿Quieres una plataforma integrada y todo en uno para que tu equipo de desarrolladores trabaje con máxima productividad?

¡Apidog satisface todas tus demandas y reemplaza a Postman a un precio mucho más asequible!
button

Practica el diseño de API en Apidog

Descubre una forma más fácil de construir y usar APIs

Registrarse gratisDescargar