Tipos de CAPTCHA de matemáticas y lógica explicados

¿Te has topado con un formulario que exige resolver "7 + 3" antes de dejarte enviarlo? Ese campo es un CAPTCHA de matemáticas, y sigue siendo uno de los mecanismos anti-spam más comunes en sitios WordPress, formularios de contacto y aplicaciones heredadas. Los CAPTCHA de lógica son su primo cercano: en vez de una operación, plantean preguntas de sentido común como "¿De qué color es el cielo?" o "Escribe el número más grande: 5, 12, 3". Ambos estuvieron entre los primeros tipos de CAPTCHA que existieron y, pese a ser fáciles de automatizar, no han desaparecido. Regla práctica: si tu automatización encuentra un campo de texto con una ecuación sencilla, estás ante un CAPTCHA matemático o lógico.

Qué tipos de CAPTCHA de matemáticas y lógica existen

1. CAPTCHA aritméticos básicos

Plantean una suma, resta o multiplicación sencilla —"¿Cuánto es 3 + 5?", "12 – 4 =?" o "6 × 7 =?"—. La operación llega como texto plano, fácil de analizar, o incrustada en una imagen, en cuyo caso necesitas OCR para leerla.

2. CAPTCHA matemáticos renderizados como imagen

Aquí la ecuación se dibuja como imagen para impedir el análisis directo del texto: piensa en un "14 + 23 =?" en una fuente distorsionada, o en números de colores sobre un fondo con ruido. Para resolverlos hace falta OCR que lea la ecuación de la imagen y, a continuación, aritmética que calcule el resultado.

3. CAPTCHA matemáticos con números en palabras

Los números se escriben con letras en lugar de dígitos, como en "¿Cuánto es siete más tres?" o "Escribe el resultado de doce menos cinco". Requieren procesamiento de lenguaje natural (NLP) para convertir las palabras en cifras y luego resolver.

4. Preguntas de lógica

Son preguntas no aritméticas que apelan al sentido común y casi siempre salen de un banco fijo:

• "¿De qué color es la hierba?"
• "¿Cuántas patas tiene un perro?"
• "¿El fuego está frío o caliente?"

Resolverlas exige una base de conocimiento o un modelo de lenguaje, no un simple analizador aritmético.

5. CAPTCHA de secuencia o patrón

Muestran una serie de números —"¿Qué sigue: 2, 4, 6, 8?" o "Completa el patrón: 1, 1, 2, 3, 5,?"— y piden el siguiente valor. Detrás hace falta lógica de reconocimiento de patrones.

Por qué siguen vigentes pese a ser tan fáciles

Aunque cualquier script mínimamente competente los supera, estos CAPTCHA no se han ido, y hay razones concretas:

1. Simplicidad: no dependen de una API externa ni de un SDK de JavaScript.
2. Plugins de WordPress: opciones como "Math CAPTCHA" y "Really Simple CAPTCHA" están instaladas en miles de sitios.
3. Poca fricción: al usuario le cuesta menos una operación mental rápida que seleccionar imágenes.
4. Accesibilidad: las versiones en texto funcionan con lectores de pantalla, a diferencia de los CAPTCHA de imagen.
5. Sistemas heredados: aplicaciones antiguas anteriores a los servicios modernos de CAPTCHA.

Un caso típico: una agencia que mantiene sitios WordPress de clientes hereda formularios con "Math CAPTCHA" activado, y el reto acaba viviendo en su flujo de QA durante años.

Cómo se comparan con otros tipos de CAPTCHA

En síntesis: gana en fricción y accesibilidad, pero su resistencia a bots es mínima. Es un filtro anti-spam ligero, no un muro de seguridad.

Cómo funcionan por dentro los CAPTCHA matemáticos

Flujo de un CAPTCHA matemático en texto

Server generates random equation (e.g., "7 + 3")
    ↓
Stores answer (10) in server-side session
    ↓
Renders equation as HTML text or image
    ↓
User submits answer via form field
    ↓
Server compares submitted answer to stored answer
    ↓
Match → Form submitted     Mismatch → Error shown

Flujo de un CAPTCHA matemático en imagen

Server generates random equation
    ↓
Renders equation into a distorted image (noise, lines, color shifts)
    ↓
Image served to client via <img> tag
    ↓
User reads image, computes answer, types in form field
    ↓
Server validates submitted answer

Cómo detectarlos en un flujo automatizado

Antes de resolver un CAPTCHA hay que reconocerlo. Estos fragmentos buscan las señales típicas —operaciones en el HTML, imágenes con alt sospechoso y preguntas de lógica— para clasificar la página.

Detección con Python

import requests
from bs4 import BeautifulSoup
import re

def detect_math_captcha(url):
    """Detect common math CAPTCHA patterns on a page."""
    response = requests.get(url, timeout=10)
    soup = BeautifulSoup(response.text, "html.parser")
    html = response.text.lower()

    indicators = {
        "text_math": False,
        "image_math": False,
        "logic_question": False,
    }

    # Check for text-based math questions
    math_patterns = [
        r"what is \d+\s*[\+\-\×\*]\s*\d+",
        r"\d+\s*[\+\-\×\*]\s*\d+\s*=\s*\?",
        r"solve:\s*\d+",
        r"type the (result|answer|sum)",
    ]
    for pattern in math_patterns:
        if re.search(pattern, html):
            indicators["text_math"] = True
            break

    # Check for CAPTCHA images near math-related labels
    captcha_images = soup.find_all("img", attrs={
        "alt": re.compile(r"captcha|math|verify", re.I)
    })
    if captcha_images:
        indicators["image_math"] = True

    # Check for logic questions
    logic_patterns = [
        r"what color is",
        r"how many legs",
        r"what comes next",
        r"is .+ hot or cold",
    ]
    for pattern in logic_patterns:
        if re.search(pattern, html):
            indicators["logic_question"] = True
            break

    return indicators

result = detect_math_captcha("https://example.com/contact")
print(result)

Detección con Node.js

const axios = require("axios");
const cheerio = require("cheerio");

async function detectMathCaptcha(url) {
    const { data: html } = await axios.get(url, { timeout: 10000 });
    const $ = cheerio.load(html);
    const lower = html.toLowerCase();

    const indicators = {
        textMath: false,
        imageMath: false,
        logicQuestion: false,
    };

    // Text-based math patterns
    const mathPatterns = [
        /what is \d+\s*[+\-×*]\s*\d+/,
        /\d+\s*[+\-×*]\s*\d+\s*=\s*\?/,
        /solve:\s*\d+/,
        /type the (result|answer|sum)/,
    ];

    for (const pattern of mathPatterns) {
        if (pattern.test(lower)) {
            indicators.textMath = true;
            break;
        }
    }

    // Check for CAPTCHA images
    $("img").each((_, el) => {
        const alt = ($(el).attr("alt") || "").toLowerCase();
        if (/captcha|math|verify/.test(alt)) {
            indicators.imageMath = true;
        }
    });

    return indicators;
}

detectMathCaptcha("https://example.com/contact").then(console.log);

Resolver CAPTCHA matemáticos en imagen con OCR

Cuando la ecuación viaja como imagen, el atajo es claro: el OCR extrae el texto y un analizador mínimo calcula la respuesta.

Resolución con la API de OCR de CaptchaAI

import requests
import time
import re

API_KEY = "YOUR_API_KEY"
CAPTCHA_IMAGE_URL = "https://example.com/captcha.png"

# Download the CAPTCHA image
image_data = requests.get(CAPTCHA_IMAGE_URL).content

# Submit to CaptchaAI OCR
import base64
b64_image = base64.b64encode(image_data).decode()

submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "base64",
    "body": b64_image,
    "json": 1,
})

task_id = submit.json().get("request")

# Poll for result
for _ in range(30):
    time.sleep(3)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY,
        "action": "get",
        "id": task_id,
        "json": 1,
    })
    data = result.json()
    if data.get("status") == 1:
        ocr_text = data["request"]  # e.g., "7 + 3"
        print(f"OCR result: {ocr_text}")

        # Parse and compute the answer
        match = re.match(r"(\d+)\s*([+\-*/×])\s*(\d+)", ocr_text)
        if match:
            a, op, b = int(match.group(1)), match.group(2), int(match.group(3))
            ops = {"+": a + b, "-": a - b, "*": a * b, "×": a * b, "/": a // b}
            answer = ops.get(op)
            print(f"Answer: {answer}")
        break
    elif "CAPCHA_NOT_READY" in str(data):
        continue

El flujo envía la imagen con in.php, consulta el resultado con res.php y, recuperada la cadena "14 + 23", el propio código hace la aritmética. Como CaptchaAI factura por thread concurrente con resoluciones ilimitadas por thread, este patrón escala de un formulario a cientos de sitios cambiando de plan, no de código.

Preguntas frecuentes

¿Necesito OCR si la ecuación aparece como texto HTML?

No. Si la operación se renderiza como texto en el HTML, puedes leerla directamente del código de la página con una expresión regular o recorriendo el DOM, calcular el resultado y enviarlo. El OCR solo hace falta cuando la ecuación viene incrustada en una imagen.

¿Qué plan de CaptchaAI conviene para resolver CAPTCHA de imagen a volumen?

Depende de cuántas resoluciones necesites en paralelo. CaptchaAI cobra por thread concurrente, no por resolución, y todos los planes incluyen resoluciones ilimitadas por thread. El plan BASIC ($15/mes, 5 threads) cubre proyectos pequeños; si procesas formularios de muchos sitios a la vez, ADVANCE ($90/mes, 50 threads) da más margen. Consulta los precios vigentes en captchaai.com/pricing.

¿Los CAPTCHA matemáticos son accesibles para lectores de pantalla?

Depende del formato. Las versiones en texto plano se leen bien con lectores de pantalla, lo que las hace más accesibles que un CAPTCHA de imagen. Las versiones renderizadas como imagen pierden esa ventaja, salvo que incluyan una alternativa textual o de audio.

¿Se resuelven igual los CAPTCHA de lógica que los aritméticos?

No. Una operación aritmética se calcula con pocas líneas de código, pero "¿de qué color es la hierba?" necesita una base de conocimiento o un modelo de lenguaje. Como suelen salir de un banco fijo, muchos flujos las resuelven con una tabla de respuestas conocidas.

¿Basta un plugin de CAPTCHA matemático en WordPress para frenar el spam?

Frena el spam más básico, poco más. Cualquier bot capaz de leer HTML resuelve un CAPTCHA matemático de texto al instante, y el OCR se encarga de las variantes en imagen. Para spam persistente conviene un sistema conductual como Cloudflare Turnstile o reCAPTCHA v3.

En resumen

Los CAPTCHA de matemáticas y lógica son el tipo de desafío más simple y aparecen sobre todo en formularios de contacto de WordPress y en sistemas heredados. Las variantes en texto se analizan directamente desde el HTML con regex; las variantes en imagen requieren OCR para leer la ecuación y luego aritmética básica para calcular la respuesta. Para las primeras te basta con la API de OCR de imágenes de CaptchaAI, que extrae la operación lista para resolverla. Fáciles de superar mediante automatización, pero cómodos y accesibles: por eso siguen tan presentes.

Artículos relacionados

• GeeTest frente a Cloudflare Turnstile: comparación
• Error 403 de Cloudflare Turnstile tras corregir el token
• Modos de widget de Cloudflare Turnstile explicados