logo
bars

ALTCHA
y CapMonster Cloud

Resolución de captcha, instalación en el sitio y pruebas.
¿Heredaste un sitio con una captcha u otra capa de protección pero sin acceso al código fuente? Entonces es normal preguntarse: ¿qué solución está instalada, está configurada correctamente y cómo se puede probar?

En este artículo hemos intentado responder a todas las preguntas clave. Para empezar a resolver la tarea, primero hay que determinar qué sistema de protección se está utilizando. Para ello, puedes consultar la lista de captchas y sistemas de protección antibot más populares, donde se muestran ejemplos visuales y señales clave que te ayudarán a identificar rápidamente con qué estás tratando.

Si descubres que tu sitio web utiliza ALTCHA, el siguiente paso será analizar con más detalle sus propiedades y su funcionamiento. En este mismo artículo también puedes consultar la guía de integración de ALTCHA para comprender por completo cómo funciona en tu sitio. Esto te permitirá no solo entender la protección actual, sino también planificar correctamente su mantenimiento.

Qué es ALTCHA
Qué es ALTCHA
ALTCHA (Alternative CAPTCHA) es un sistema de protección de sitios web contra bots y spam. Ayuda a distinguir usuarios reales de programas automatizados para que el sitio funcione de forma segura y estable. ALTCHA es una alternativa moderna a los CAPTCHAs tradicionales: utiliza un reto criptográfico ligero (proof-of-work) y no recopila cookies ni rastrea a los usuarios.
Background
Ejemplos de ALTCHA
Proof-of-Work (PoW)
Proof-of-Work (PoW)
El sistema utiliza por defecto el método de verificación Proof-of-Work (PoW), lo que elimina rompecabezas visuales y comprobaciones intrusivas. Este enfoque combina seguridad con comodidad para el usuario, ofreciendo una solución captcha discreta adecuada para la mayoría de los visitantes.
Code Captcha
Code Captcha
La protección puede reforzarse hasta requerir un captcha de texto.
Invisible Captcha
Invisible Captcha
La verificación ocurre sin un widget visible y no requiere ninguna acción del usuario.

Cómo resolver ALTCHA a través de CapMonster Cloud

Al probar formularios que incluyen ALTCHA, normalmente debes verificar que la captcha funcione y esté integrada correctamente.

Puedes comprobar manualmente la captcha incrustada en tu sitio.

  • Abre la página del formulario y verifica que la captcha se renderice.
  • Intenta enviar el formulario sin resolverla: el servidor debe devolver un error.
  • Tras una solución correcta, el formulario debe enviarse sin inconvenientes.

Para la resolución automática puedes usar herramientas como CapMonster Cloud, que reciben los parámetros de la captcha, los procesan en sus servidores y devuelven un token listo para usar. Inserta ese token en el formulario para pasar la verificación sin interacción del usuario.

Trabajar con CapMonster Cloud mediante la API suele implicar los siguientes pasos:

Creación de la tareaCreación de la tarea
arrow
Enviar una solicitud APIEnviar una solicitud API
arrow
Recepción del resultadoRecepción del resultado
arrow
Colocar el token en la páginaColocar el token en la página
arrow
Resolución, inserción de token y envío de formulario
Ejemplo en Node.js para un ciclo completo de resolución de captcha en su página web. Posibles enfoques: usar solicitudes HTTP para obtener HTML y parámetros del captcha, enviar la respuesta y procesar el resultado; o usar herramientas de automatización (como Playwright) — abrir la página, esperar al captcha, enviar parámetros (para pruebas puede enviar valores correctos o incorrectos), obtener el resultado a través del cliente de CapMonster Cloud, insertar el token en el formulario y observar el resultado.
// npm install playwright
// npx playwright install chromium

const { chromium } = require("playwright");

const API_KEY = "YOUR_API_KEY";
const ALTCHA_PAGE = "https://example.com"; // Su sitio con ALTCHA

(async () => {
  const browser = await chromium.launch({ headless: false, devtools: true });
  const context = await browser.newContext();
  const page = await context.newPage();

  // Capturando todas las respuestas del endpoint de Altcha
  let challengeResp = null;
  page.on("response", async (response) => {
    try {
      const url = response.url();
      if (url.startsWith("https://captcha.example.com/altcha")) { // Endpoint de Altcha
        challengeResp = await response.json();
        console.log("Captured Altcha response:", challengeResp);
      }
    } catch (err) {
      console.warn("Error parsing Altcha response:", err);
    }
  });

  await page.goto(ALTCHA_PAGE, { waitUntil: "networkidle" });

  // Clic en el widget, si existe
  const widgetHandle = await page.$("altcha-widget");
  if (widgetHandle) {
    try {
      await widgetHandle.click();
    } catch {}
  }

  // Esperando a que aparezca el challenge
  const start = Date.now();
  while (!challengeResp && Date.now() - start < 60000) { // Tiempo de espera aumentado
    await new Promise((r) => setTimeout(r, 300));
  }

  if (!challengeResp) {
    console.error("Failed to capture Altcha challenge.");
    await browser.close();
    return;
  }

  const { challenge, salt, signature, maxnumbers } = challengeResp;

  // Creando tarea en CapMonster Cloud
  const createTaskBody = {
    clientKey: API_KEY,
    task: {
      type: "CustomTask",
      class: "altcha",
      websiteURL: ALTCHA_PAGE,
      websiteKey: "",
      userAgent:"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36",
      metadata: {
        challenge,
        iterations: maxnumbers || 100000,
        salt,
        signature,
      },
    },
  };

  const taskResp = await fetch("https://api.capmonster.cloud/createTask", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(createTaskBody),
  }).then((r) => r.json());

  console.log("CreateTask response:", taskResp);
  if (!taskResp?.taskId) {
    console.error("CreateTask failed:", taskResp);
    await browser.close();
    return;
  }

  const taskId = taskResp.taskId;

  // Obteniendo solución
  let fullSolution = null;
  const pollStart = Date.now();
  while (Date.now() - pollStart < 120000) {
    const res = await fetch("https://api.capmonster.cloud/getTaskResult", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ clientKey: API_KEY, taskId }),
    }).then((r) => r.json());

    if (res.status === "ready") {
      fullSolution = res.solution;
      console.log("Solution:", fullSolution);
      break;
    }
    await new Promise((r) => setTimeout(r, 3000));
  }

  if (!fullSolution) {
    console.error("No solution received in time.");
    await browser.close();
    return;
  }

  const token = fullSolution?.data?.token || fullSolution?.token || fullSolution?.data;

  if (!token) {
    console.error("Token not found in solution:", fullSolution);
    await browser.close();
    return;
  }

  //Insertando token
  await page.evaluate((t) => {
    let input = document.querySelector("#captchaParaValidar");
    if (!input) {
      input = document.createElement("input");
      input.type = "hidden";
      input.id = "captchaParaValidar";
      input.name = "captchaParaValidar";
      (document.querySelector("form") || document.body).appendChild(input);
    }
    input.value = t;

    let alt = document.querySelector('input[name="altcha"]');
    if (!alt) {
      alt = document.createElement("input");
      alt.type = "hidden";
      alt.name = "altcha";
      (document.querySelector("form") || document.body).appendChild(alt);
    }
    alt.value = t;

    const widget = document.querySelector("altcha-widget");
    if (widget) {
      widget.setAttribute("data-state", "verified");
      const checkbox = widget.querySelector("input[type='checkbox']");
      if (checkbox) {
        checkbox.checked = true;
        checkbox.dispatchEvent(new Event("change", { bubbles: true }));
      }
      const label = widget.querySelector(".altcha-label");
      if (label) label.textContent = "Verified";
    }
  }, token);

  console.log("Token injected:", token);
})();
Cómo conectar ALTCHA a su sitio web
Para comprender correctamente cómo funciona el captcha en su sitio, entender su lógica de validación, reconectarlo o reconfigurarlo, le recomendamos leer esta sección. Describe el proceso de integración de la protección, ayudándole a entender todos los detalles rápidamente.

1. Instalación del widget

Opción 1 — mediante CDN (la más sencilla). Agregue esto en el <head> de su HTML:

<script async defer src="https://cdn.jsdelivr.net/gh/altcha-org/altcha/dist/altcha.min.js" type="module"></script>

Opción 2 — mediante npm:

npm install altcha

Importe el widget en su archivo JS:

import "altcha";

2. Agregar el widget al formulario.

Inserte el componente <altcha-widget> en el formulario donde se requiera protección:


<form method="POST" action="/submit">
  <altcha-widget challengeurl="/altcha/challenge"></altcha-widget>
  <button type="submit">Send</button>
</form>

challengeurl — su endpoint de servidor para emitir el challenge.

Si usa ALTCHA Sentinel (protección lista para usar contra bots y spam con aprendizaje automático y análisis de tráfico), use su URL en lugar de su propio servidor:


<altcha-widget 
  challengeurl="https://sentinel.example.com/v1/challenge?apiKey=YOUR_API_KEY">
</altcha-widget>

3. Validación del servidor.

Cómo se realiza la validación:

  • 1) El widget genera un payload — JSON codificado en Base64, normalmente enviado como campo de formulario altcha.
  • 2) En el servidor, valide el payload criptográficamente (sin solicitudes adicionales a la API).
  • 3) Tras la validación exitosa, se puede procesar el formulario.

Validación mediante ALTCHA Sentinel:

Usando la bibliotecaUsando la biblioteca
arrow

A través del HTTP API de Sentinel (si la biblioteca no está disponible):A través del HTTP API de Sentinel (si la biblioteca no está disponible):
arrow

4. Validación sin Sentinel (servidor propio)

Generación del challenge:


import { createChallenge } from 'altcha-lib';

const hmacKey = '$ecret.key'; // Su clave secreta HMAC

const challenge = await createChallenge({ hmacKey });

// Devolvemos el challenge en JSON para el widget

Validación del payload al enviar el formulario:


import { verifySolution } from 'altcha-lib';

const hmacKey = '$ecret.key'; // Su clave secreta HMAC

const verified = await verifySolution(payload, hmacKey);

if (verified) {
  // Validación exitosa — procesando los datos del formulario
}

En este caso, crea su propio endpoint /altcha/challenge para emitir tareas y validarlas en el servidor.

Background
Posibles errores y depuración
Bug Icon
challengeurl o API Key incorrectos
El widget no se carga o devuelve un error durante la validación.
Bug Icon
Tiempo de resolución agotado
El servidor no tuvo tiempo de validar el payload. Aumente el tiempo de espera o asegúrese de que la validación del servidor funcione correctamente.
Bug Icon
Payload vacío
Error al enviar el resultado del widget al servidor.
Bug Icon
Verification failed
El payload ha expirado, se ha reutilizado o ha sido manipulado. Para diagnóstico, active el registro y revise los campos verified y verificationData en la respuesta del servidor o Sentinel.
Pruebas de resistencia de la protección
Después de la integración, asegúrate de que el sistema realmente proteja el sitio contra acciones automatizadas.
Consejos de seguridad y optimización
<b>Guarde las claves secretas</b> (HMAC o API Key para Sentinel) solo en el servidor — no las envíe al frontend.
<b>Registre errores</b> y eventos de verificación (<b>verified: false</b> y <b>verificationData</b>) para entender por qué fallaron las verificaciones.
Para transparencia y confianza del usuario, <b>agregue enlaces a la política de privacidad</b> y a los <b>términos de uso de ALTCHA</b> si es necesario.
Conclusión

Si has heredado un sitio web que ya tiene un captcha u otro sistema de protección instalado y no tienes acceso al código, no pasa nada. Identificar qué tecnología se está utilizando es bastante sencillo. Para comprobar que todo funciona correctamente, puedes usar el servicio de reconocimiento CapMonster Cloud en un entorno de pruebas aislado, para asegurarte de que el mecanismo de procesamiento de tokens y la lógica de verificación funcionan correctamente.

En el caso de ALTCHA, basta con detectar el sistema, analizar su comportamiento y confirmar que la protección funciona correctamente. En el artículo hemos mostrado cómo identificar ALTCHA y dónde encontrar las instrucciones para su integración o reconfiguración, de modo que puedas mantener la protección con confianza y controlar su funcionamiento.

Conclusion
Enlaces útiles
DocIconDocumentación de ALTCHADocIconCódigo fuente de ALTCHADocIconDocumentación de CapMonster Cloud (trabajo con ALTCHA)