Cabal-Hunter

Verificación de seguridad previa a la negociación para tokens de Solana: rastrea la financiación coordinada de billeteras, las compras en bloque de la misma transacción y el historial del implementador de lanzamientos seriales en un veredicto de Riesgo de Liquidez de Salida antes de que un agente compre.

GitHub

Prueba este MCPPatrocinado

Documentación

Solana Safe Sniper — Plantilla MCP

🌐 Disponible en 9 idiomas: English · Español · Português · Français · Deutsch · Nederlands · 中文 · 日本語 · 한국어

Cabal-Hunter — live Solana cabal and rug analysis: interactive 3D holder map, serial-launcher deployer history, and an Exit-Liquidity Risk verdict

Evita que tus agentes de trading con IA sean estafados por cábalas coordinadas de wallets. Plantilla lista para usar con Claude Code, Cursor y ElizaOS.

▶ Pruébalo ahora: mapa 3D en vivo de holders de cualquier token de Solana → — sin registro.

Cabal-Hunter es un escáner gratuito de seguridad de tokens en Solana y verificador de rug pulls. Detecta cábalas coordinadas de wallets, compras en bloque en el mismo bloque, deployers con lanzamientos en serie y ventas coordinadas en el mismo bloque en cualquier mint de Solana (pump.fun, PumpSwap, Raydium, Orca, Meteora) — y responde la única pregunta que importa antes de lanzarte: ¿eres tú la liquidez de salida? Úsalo mediante MCP (Claude, Cursor, ElizaOS), una API REST, o un mapa 3D interactivo de holders gratuito.

El Problema

Tu agente de trading autónomo está leyendo puntuaciones de rug.check, bloqueos de liquidez y auditorías de contratos.

Nada de eso detecta una cábala.

Un puñado de wallets toma la base de un lanzamiento, el gráfico se ve limpio — contrato correcto, LP quemado, todo en verde — y luego venden contra cualquiera que haya comprado después. Tú eres la liquidez de salida.

Esta plantilla integra Cabal-Hunter como verificación de seguridad previa a la operación, para que tu agente pueda ver quién está manteniendo y quién ya se ha posicionado para vender antes de firmar un swap.

Una nota sobre lo que afirmamos y lo que no. Este README solía abrir con "15 wallets nuevas financiadas desde la misma wallet maestra, acumulando el 25-40% del suministro." Buscamos ese patrón y no pudimos encontrarlo. Rastrear 323 lanzamientos de pump.fun en la curva de vinculación reveló cero clústeres de financiación coordinados, y mostró por qué: el lanzamiento mediano tiene alrededor de cinco compradores exitosos, porque en un token representativo 1,260 de las 1,266 transacciones de la curva fallaron. La captura de lanzamiento es una carrera de snipers entre bots competidores, no una cábala silenciosa. Las capas de detección a continuación son las que podemos respaldar con evidencia real — concentración de holders, bundles en el mismo bloque, ventas coordinadas e historial del deployer. El rastreador de financiación previa al lanzamiento fue retirado; el análisis completo está aquí.

La única pregunta que responde: ¿eres TÚ la liquidez de salida?

La configuración clásica de liquidez de salida en pump.fun: wallets posicionadas antes de la multitud toman la base de un lanzamiento y luego descargan sobre el retail (y los bots) que entran después. El resultado principal de Cabal-Hunter es un veredicto único de Riesgo de Liquidez de Salida — risk_level, uno de LOW_SIGNAL | ELEVATED | HIGH que sintetiza cada señal a continuación en lo único que importa antes de firmar un swap: ¿están los insiders posicionados para descargar sobre ti?

Qué Hace Cabal-Hunter

Token mint address
      ↓
0. EXIT-LIQUIDITY RISK — the headline verdict. Synthesises the layers
   below (bundle, concentration, shared funder, coordinated selling,
   serial-launcher dev) into risk_level: LOW_SIGNAL | ELEVATED | HIGH.
   Are insiders set up to dump on a buyer? The one field an agent needs.
      ↓
1. HOLDER FUNDING TRACE (ONE HOP) — the CURRENT top holders walked back
   one funding hop: were they seeded by the same wallet? ONE hop, not a
   lineage — we do not claim to follow money through a chain of
   wallets. Only System-owned accounts count as
   a funder, so pools, vaults and routers can never be mistaken for a
   person (that mistake is exactly what got our pre-launch tracer
   withdrawn). Every cluster carries evidence_txs[] — the actual
   funding transactions on Solscan. This layer is genuinely rare to
   fire; treat a hit as significant and its absence as no evidence
   either way.
      ↓
2. SAME-BLOCK BUNDLE DETECTION — holders whose token accounts were
   created in the EXACT same slot - a Jito bundle is one way to do that, not
   the only one. Catches
   stealth launches that route funding through intermediaries to
   evade layer 1. Returned as `time_sync: true`.
      ↓
3. COORDINATED SELLING DETECTION — ≥2 holders that SOLD a meaningful
   chunk (≥25% of their bag each) in the EXACT same block.
   `coordinated_exit: true`, with sold_pct = % of supply sold and the
   signatures in evidence_txs[]. Same-slot + meaningful-size + distinct
   wallets = near-zero false positives. It reads the CURRENT holder set
   at scan time, so a bundle that already sold and left the top holders
   is not visible here — that is what the launch-block check is for.
   For a token you already hold, POST /api/watch pushes you a webhook
   the moment a dump or liquidity drain STARTS.
      ↓
4. DEV TRACK RECORD — the creator wallet is resolved on-chain (bonding
   curve pre-graduation, pump-amm pool after — works on any age token),
   and their launch history is pulled WITH THE PEAK MARKET CAP each
   past token hit. `sampled` says how many of those launches we actually
   walked — a very prolific wallet is sampled, not exhausted, so read
   `tokens_launched` as a floor, never as a complete history.
   Launch detection is venue-agnostic: pump.fun, Raydium,
   Orca, Meteora and PumpSwap. A launch is only counted where the
   transaction actually CREATED the mint, so minting more supply of a
   token that already exists is never miscounted as a launch.
   A dead-count alone hides a pump-and-dump: a dev whose
   tokens all died at $4k is a nobody, but one who ran a token to $728k
   then dumped it to dust has done it to holders before. Reputation:
   FIRST_LAUNCH | PROVEN | MIXED | DEAD_ON_ARRIVAL | SERIAL_RUGGER |
   UNKNOWN, with per-launch peak → now (paid tier returns the full
   launches[] array). UNKNOWN means the history could not be
   established — never read it as a clean record.
      ↓
5. CEX-NOISE FILTER — holders funded from a shared exchange or
   high-volume infra wallet are NOT a cabal. They're excluded from the
   score and surfaced transparently in filtered_clusters[], so you never
   get a false positive from people who just withdrew from Binance.
      ↓
6. HONEYPOT CHECK (Solana-native) — one RPC read of the mint account:
   is the FREEZE authority live (issuer can freeze your tokens — the
   sell-block lever)? is the MINT authority live (supply can be
   inflated)? any Token-2022 traps (transfer fees up to 100%, transfer
   hooks that block sells, permanent-delegate clawback)? On Solana a
   "honeypot" is built from these — tokens have no per-token contract
   code to audit. Returns `honeypot_risk: LOW | HIGH` +
   `freeze_authority_revoked` / `mint_authority_revoked` /
   `token2022_risks[]`.
      ↓
Returns: Cabal Score (0-100) + cluster map + deployer verdict
         + honeypot verdict + on-chain receipts + hard verdict

La capa del deployer es la que las cábalas no pueden esquivar: las wallets rotan, los deployers dejan un rastro de papel. Una respuesta de "deployer": {"reputation": "SERIAL_RUGGER", "tokens_launched": 22, "best_peak_usd": 728432, "pump_and_dumps": 2} muestra el historial completo del dev antes de la primera vela — incluyendo si este dev "muerto" ha llevado tokens silenciosamente a seis cifras y los ha descargado sobre los holders antes. (Contexto honesto: la mayoría de los creadores prolíficos de pump.fun tienen altas tasas de tokens muertos, por lo que esta señal está limitada — marca un token para revisión pero nunca impulsa un veredicto ALTO por sí sola.)

FIRST_LAUNCH y UNKNOWN no son la misma respuesta. deployer.verdict de FIRST_LAUNCH significa que recorrimos el historial de este creador y no encontramos tokens anteriores. UNKNOWN significa que el historial no pudo establecerse en absoluto — eso es una ausencia de evidencia, no un historial limpio, y un agente no debe tratarlo como tal. Cuando un deployer no puede resolverse, el escaneo lo dice con palabras en lugar de devolver un silencio confiado.

Recibos, no magia. Cada clúster de wallets lleva evidence_txs[] — las firmas crudas detrás de ese clúster, verificables en Solscan, y los holders llevan funding_tx cuando resolvimos uno. La concentración de holders, el historial del deployer y las verificaciones de honeypot se leen del estado de la cadena, por lo que no llevan transacción propia: un token puede volver HIGH sin clústeres en absoluto. Verifica lo que hay en lugar de confiar en una puntuación.

Respuesta en <100ms para un mint rastreado en las últimas 8 horas — computed_at (segundos unix) dice exactamente cuándo se ejecutó ese rastreo. Cualquier otro mint ejecuta un rastreo en cadena en vivo y toma 15-20s, así que permite un timeout de 30s.

Nivel gratuito: 5 escaneos/mes sin cuenta, o 250/mes con una clave gratuita (un correo). Luego $0.01 por escaneo. Paga con tarjeta, en USDC en Solana, o vía x402 — mismo precio por cualquier puerta. $9/mes compra 2,500 escaneos al mes y $99/mes compra escaneos ilimitados de uso justo (50,000 al mes); con tarjeta un plan se renueva automáticamente y puede cancelarse en cualquier momento en cabal-hunter.com/billing.

Inicio Rápido

1. Claude Code / Claude Desktop

Añade a tu configuración MCP (~/.claude/mcp.json o proyecto .mcp.json):

{
  "mcpServers": {
    "cabal-hunter": {
      "url": "https://api.cabal-hunter.com/mcp"
    }
  }
}

Eso es todo. Claude ahora llamará a check_cabal_risk automáticamente cuando le pidas analizar un token de Solana.

Ejemplo de prompt:

"Antes de que compremos este token, verifica si hay wallets coordinadas: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"

Claude llama a la herramienta, paga $0.01 USDC desde tu wallet conectada y devuelve el análisis completo.

2. Cursor

Añade a .cursor/mcp.json en la raíz de tu proyecto:

{
  "mcpServers": {
    "cabal-hunter": {
      "url": "https://api.cabal-hunter.com/mcp"
    }
  }
}

3. ElizaOS (con pago automático x402)

Si usas ElizaOS con @hugen/plugin-x402-solana, el pago se maneja automáticamente. Añade a la configuración de tu agente:

{
  "plugins": ["@hugen/plugin-x402-solana"],
  "mcpServers": {
    "cabal-hunter": {
      "url": "https://api.cabal-hunter.com/mcp"
    }
  }
}

Tu agente llamará a check_cabal_risk(mintAddress) antes de cualquier swap y abortará si cabalScore >= 35 o isControlled === true.

4. API REST Directa

Para scripts headless, bots personalizados o cualquier lenguaje. Las primeras 5 llamadas/mes son gratuitas — sin clave, sin registro. Una clave gratuita (un correo) eleva eso a 250/mes. Solo llámala:

curl "https://api.cabal-hunter.com/api/scan-cabal?mintAddress=YOUR_MINT_ADDRESS"

Recibes el análisis completo de inmediato, con free_queries_remaining para que siempre sepas dónde estás. Contrato legible por máquina: /openapi.json.

Una vez agotado el nivel gratuito, las llamadas cuestan $0.01 USDC vía x402 — tu agente solo paga, sin configuración de facturación:

Paso 1 — Solicita análisis (obtén instrucciones de pago):

curl -X POST https://api.cabal-hunter.com/api/scan-cabal \
  -H "Content-Type: application/json" \
  -d '{"mintAddress": "YOUR_MINT_ADDRESS"}'

Respuesta (HTTP 402):

{
  "error": "payment_required",
  "payment": {
    "recipient": "ATYjZ1kWoHWhj74umGJ8wFqUeW1yeSGBbLi1UQpahPxt",
    "amount_usdc": 0.01,
    "memo_required": "ch-xxxx-xxxx-xxxx",
    "instructions": "Send 0.01 USDC with this memo, then resubmit with X-Payment-Signature header"
  }
}

Paso 2 — Paga y reenvía:

curl -X POST https://api.cabal-hunter.com/api/scan-cabal \
  -H "Content-Type: application/json" \
  -H "X-Payment-Signature: YOUR_TX_SIGNATURE" \
  -d '{"mintAddress": "YOUR_MINT_ADDRESS"}'

Respuesta (HTTP 200):

{
  "mint": "YOUR_MINT",
  "token_name": "EXAMPLE",
  "risk": "HIGH",
  "cabal_score": 72.4,
  "is_controlled": true,
  "time_sync": true,
  "verdict": "AVOID — 4 wallets bought in the EXACT same block (bundled launch), controlling 34.1% of supply. DEPLOYER ALERT: this creator has launched 14 tokens, 13 of 13 checked are dead (100%).",
  "coordinated_clusters": [
    {
      "type": "funding",
      "master_full": "FvbEKF...9RUg",
      "master_short": "FvbEKF…9RUg",
      "wallet_count": 4,
      "combined_pct": 34.1,
      "risk": "HIGH",
      "evidence_txs": ["4Y8auc5G...", "2XQx9LFv...", "AAbJ7rej..."]
    }
  ],
  "filtered_clusters": [
    {
      "funder_label": "high-volume wallet",
      "master_short": "43ViqZ…Z6iy",
      "wallet_count": 2,
      "combined_pct": 4.4
    }
  ],
  "deployer": {
    "creator": "5TbRN6...full address...",
    "creator_short": "5TbRN6…2TGC",
    "tokens_launched": 14,
    "dead": 13,
    "sampled": 13,
    "dead_pct": 100.0,
    "verdict": "SERIAL_LAUNCHER"
  },
  "holders": [
    { "rank": 1, "address": "...", "pct": 12.4, "cluster_id": 0, "funding_tx": "4Y8auc5G..." }
  ],
  "wallets_checked": 12,
  "analysis_time_ms": 487,
  "source": "real_time"
}

5. Ejecuta el servidor MCP localmente (Docker / Node)

Más rápido — sin necesidad de clonar: npx cabal-hunter-mcp — el mismo servidor stdio, publicado en npm (cabal-hunter-mcp · npm). O ejecútalo desde este repositorio:

¿Prefieres ejecutar el conector tú mismo en lugar de usar el endpoint alojado /mcp? Este repositorio incluye un servidor MCP stdio ligero que expone check_cabal_risk(mintAddress) y hace proxy a la API de Cabal-Hunter (el nivel gratuito funciona sin clave; los escaneos pagados usan x402 en el momento de la llamada):

# Node 18+
npm install
node server/index.mjs

# or Docker
docker build -t cabal-hunter-mcp .
docker run -i cabal-hunter-mcp

Luego apunta cualquier cliente MCP al comando local:

{
  "mcpServers": {
    "cabal-hunter": {
      "command": "node",
      "args": ["server/index.mjs"]
    }
  }
}

Integra en tu Lógica de Trading

import requests

def is_safe_to_buy(mint_address: str, payment_sig: str) -> bool:
    """Returns True if token passes cabal check."""
    resp = requests.post(
        "https://api.cabal-hunter.com/api/scan-cabal",
        json={"mintAddress": mint_address},
        headers={"X-Payment-Signature": payment_sig}
    )
    if resp.status_code != 200:
        return False  # fail-safe: don't buy on error
    data = resp.json()
    # Block on: coordinated control, high score, bundled launch,
    # or a deployer with a history of dead tokens
    deployer_verdict = (data.get("deployer") or {}).get("verdict", "UNKNOWN")
    return (
        not data.get("is_controlled")
        and data.get("cabal_score", 100) < 35
        and not data.get("time_sync")
        and deployer_verdict not in ("SERIAL_RUGGER", "SERIAL_LAUNCHER", "POOR_TRACK_RECORD")
    )

# In your bot's buy logic:
if is_safe_to_buy(token_mint, my_payment_sig):
    execute_swap(token_mint, sol_amount)
else:
    print(f"Cabal detected — skipping {token_mint}")

Mapa 3D Interactivo de Holders (Gratis)

Mira exactamente lo que encontró el análisis. Cada holder real es un cristal facetado dimensionado por su participación del suministro; las wallets en el mismo clúster están unidas por haces de luz, y el pool de liquidez y el suministro bloqueado están separados en una bóveda wireframe porque no pueden venderse. Arrastra para rotar, pasa el cursor para ver la wallet, haz clic para ir a Solscan:

https://api.cabal-hunter.com/map?mint=ANY_SOLANA_MINT

Gratis de ver, en 9 idiomas. Comparte esta URL cuando detectes un rug. Cada cristal es clicable y enlaza a Solscan para investigación profunda.

Cabal-Hunter en todas partes

El mismo motor de detección, dondequiera que viva tu stack:

npx cabal-hunter-mcp — servidor MCP independiente para Claude · Cursor · VS Code · cualquier cliente MCP: cabal-hunter-mcp · npm
Plugin ElizaOS: npm i elizaos-plugin-cabal-hunter — plugin-cabal-hunter · npm
API REST + OpenAPI: api.cabal-hunter.com · /openapi.json

Precios

Los primeros 5 escaneos cada mes son gratuitos — sin registro, sin clave API. Una clave gratuita (un correo) eleva eso a 250/mes.

Después de eso, elige lo que se ajuste a lo duro que trabaja tu bot:

Plan	Precio	Qué obtienes
Trader	$9 USDC / mes	2,500 escaneos al mes
Pro ⭐	$99 USDC / mes	Ilimitado — uso justo: 50,000/mes, más de lo que cualquier bot necesita
Pago por uso	$0.01 USDC / escaneo	Solo lo que uses — prepago o por llamada, sin compromiso

Claves prepagadas: envía USDC una vez → POST /api/buy-key con la firma de la transacción → usa el header X-API-Key en cada escaneo. O paga por llamada vía x402 (header X-Payment-Signature). Sin tarjeta de crédito, sin cuenta, sin bloqueo.

¿Se paga solo? Calcúlalo con tus propios números en lugar de los nuestros: el plan Trader cuesta $9 al mes, así que se paga solo la primera vez que te evita entrar en una posición mayor de $9 que va a cero. Si eso ocurre una vez al mes o una vez a la semana depende de qué operas y con qué frecuencia — no vamos a inventar un promedio para ti.

El pago es nativo en Solana — sin tarjeta de crédito, sin cuenta, sin bloqueo de suscripción.

Insignia de panel en vivo

Coloca una insignia de seguridad en vivo en el panel de tu propio bot — dos líneas de HTML, y cada token muestra su veredicto mientras opera:

<div class="cabal-hunter-badge" data-mint="YOUR_TOKEN_MINT"></div>
<script src="https://api.cabal-hunter.com/widget.js" defer></script>

Renderiza la puntuación 0–100, el veredicto en lenguaje natural y las banderas activas (lanzamiento en bundle, venta coordinada, concentración de ballenas, deployer de lanzamientos en serie, honeypot). Añade data-refresh="120" para re-escanear en vivo mientras operas, y data-api-key="..." una vez que superes tus escaneos gratuitos. Funciona en cualquier lugar — React, HTML plano, cualquier sitio.

Referencia de API

Endpoint	Descripción	Auth
`POST /api/scan-cabal`	Análisis completo de cábalas	$0.01 USDC
`GET /api/scan-cabal?mintAddress=`	GET versión	$0.01 USDC
`GET /map?mint=`	Mapa 3D interactivo de holders	Gratis
`GET /api/cex-funding?mint=`	Desglose de financiación por exchange (qué CEXes financiaron holders, % cada uno)	Gratis
`GET /api/trade-analysis?mint=`	PnL de cohorte (Equipo/Snipers/Insiders) + puntuación de wash-trading + impacto de precio de liquidez de salida, una llamada	Gratis
`POST /api/watch`	Registra un webhook de descarga de emergencia para un mint (push al inicio de dump/rug)	Gratis
`GET /api/info`	Precios, endpoints	Gratis
`GET /health`	Verificación de uptime	Gratis
`POST /mcp`	Endpoint de herramienta MCP	$0.01 USDC por llamada

Webhook de descarga de emergencia (auto-salida)

En lugar de hacer polling, deja que tu bot se suscriba a un token que mantiene — enviamos push en el momento en que comienza una descarga coordinada o un drenaje de liquidez:

curl -X POST https://api.cabal-hunter.com/api/watch \
  -H "Content-Type: application/json" \
  -d '{"mint":"YOUR_MINT","webhook_url":"https://your-bot.com/dump-alert"}'

Tu endpoint recibe:

{ "event":"dump_detected", "mint":"...", "reason":"price −34% since last check",
  "coordinated": true, "price_usd": 0.0001, "liquidity_usd": 4200,
  "action":"consider_immediate_exit", "ts": 1781370000 }

Infraestructura

RPC: Helius (Frankfurt)
Hosting: AWS EC2 Frankfurt — baja latencia para EU/global
Análisis: leído de la cadena, nunca extraído de otro escáner. Un rastreo completado se cachea por 8 horas y computed_at siempre dice cuándo se ejecutó; fresh=1 fuerza uno nuevo
Uptime: objetivo 99.9% — monitoreado, auto-reinicio vía systemd

FAQ

¿Qué es una cábala de Solana? Un grupo de wallets — a menudo financiadas desde la misma fuente y comprando en el mismo bloque — que acumulan silenciosamente una gran parte del suministro de un token antes del retail, y luego descargan simultáneamente contra todos los que compran después del lanzamiento.

¿Cómo verifico si un token de Solana es un rug? Escanea el mint con Cabal-Hunter (MCP, API REST o el mapa 3D gratuito de holders). Rastrea la financiación de holders un salto atrás hasta fuentes compartidas, detecta compras en bundle en el mismo bloque, marca deployers de lanzamientos en serie y ventas coordinadas en el mismo bloque, y devuelve un veredicto de Riesgo de Liquidez de Salida — risk_level: LOW_SIGNAL, ELEVATED o HIGH. ¿Es gratis? Sí: 5 escaneos/mes sin registro ni clave API, y 250/mes con una clave gratuita (un correo electrónico). Más allá de eso, cuesta $0.01 USDC por escaneo, pagado de forma nativa en Solana.

¿Hay alguna forma de usarlo sin escribir código? Sí: @TheCabalHunter_Bot en Telegram. Pega un mint, obtén el mismo escaneo como tarjeta, y pídele que vigile un token que tengas para que te avise cuando comience un dump. Los tokens puntuados se publican en @CabalHunterAlerts.

¿Pueden usarlo agentes de trading con IA? Sí: ese es el punto principal. El servidor MCP (api.cabal-hunter.com/mcp) permite que agentes de Claude, Cursor y ElizaOS llamen a check_cabal_risk(mintAddress) automáticamente antes de cualquier swap, y una API REST cubre cualquier otro lenguaje.

Licencia

MIT: haz un fork, construye sobre él, intégralo. Si construyes algo con esto, compártelo.

Creado por Cabal Hunter · Impulsado por Helius · Contacto: api.cabal-hunter.com/api/info