ALTCHA
y CapMonster Cloud

Resolución de captcha, instalación en el sitio y pruebas.

Precios de la solución ALTCHA

CAPTCHA
Precio (USD)
$ 0.80
1000 tokens
¿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/150.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
<span class="font-bold">Guarde las claves secretas</span> (HMAC o API Key para Sentinel) solo en el servidor — no las envíe al frontend.
<span class="font-bold">Registre errores</span> y eventos de verificación (<span class="font-bold">verified: false</span> y <span class="font-bold">verificationData</span>) para entender por qué fallaron las verificaciones.
Para transparencia y confianza del usuario, <span class="font-bold">agregue enlaces a la política de privacidad</span> y a los <span class="font-bold">términos de uso de ALTCHA</span> 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)

Preguntas frecuentes sobre ALTCHA

Los widgets ALTCHA pueden funcionar sin sitekeys tradicionales, por eso CapMonster Cloud acepta una cadena vacía ("") para el parámetro websiteKey.

Importante: este campo sigue siendo obligatorio en su payload JSON. Aunque el sitio use ALTCHA Sentinel y exponga un apiKey en la challengeurl, no lo extraiga — simplemente envíe "websiteKey": "".

El parámetro iterations en su tarea de CapMonster Cloud se corresponde directamente con el valor maxnumber (número máximo para cálculos) del objeto challenge devuelto por el endpoint ALTCHA en la página objetivo. Debe pasar exactamente este valor para evitar fallos silenciosos al resolver.

La respuesta de getTaskResult proporciona simultáneamente el number simple y el token completo codificado en base64 dentro del mismo payload. El desarrollador extrae el valor que el sitio web objetivo exige para la validación.

Algunos formularios solo requieren el número calculado, mientras que otros esperan el conjunto completo de parámetros cifrados de forma segura en formato base64.

CapMonster Cloud admite las tres variantes de ALTCHA:

  • Proof-of-Work — el widget ALTCHA predeterminado que ejecuta un challenge computacional en el navegador.
  • Code Captcha — requiere que el usuario o el script introduzca un código corto.
  • Invisible Captcha — se ejecuta en segundo plano sin widget visible ni interacción del usuario.

Aprenda a encontrar todos los parámetros necesarios para crear la tarea

Tras el envío del challenge por el cliente, su backend verifica los datos (salt, signature, número calculado y difficulty). Puede implementarlo de dos formas:

  • Sentinel API: valida automáticamente el payload y previene ataques de replay (deduplicación y expiración).
  • Servidor propio: use la función verifySolution para comprobar manualmente el booleano verified y el payload.

Consulte el capítulo Cómo conectar ALTCHA a su sitio web (pasos 3–4) arriba para más detalles.

Nota: si la validación falla (p. ej., devuelve 403 Forbidden), suele deberse a un payload expirado o reutilizado (ataque de replay), no a un cálculo PoW incorrecto.