Tipos de CAPTCHA de matemática e lógica explicados

Um campo pedindo "quanto é 7 + 3?" antes de liberar o envio do formulário: isso é um CAPTCHA matemático, um dos desafios mais antigos e simples ainda em uso. A variante lógica troca a conta pela pergunta de conhecimento geral — "qual é a cor do céu?" ou "digite o maior número entre 5, 12 e 3" — mas resolve o mesmo problema de um jeito ainda mais barato. Você encontra esse desafio sobretudo em sites WordPress, formulários de contato simples e sistemas legados sem verificação comportamental. Se a automação parar num campo pedindo para resolver uma equação, é exatamente isso que está pela frente.

Quais são os tipos de CAPTCHA matemático e lógico

Na prática, esse "desafio de conta" aparece em cinco formatos. Todos compartilham a mesma lógica — o servidor guarda uma resposta e compara com o que o usuário digita — mas mudam na forma como a pergunta chega até a tela, o que muda também a forma de automatizar cada um.

Por que esse tipo de CAPTCHA ainda aparece em formulários

A resposta curta é simplicidade: sem API externa, sem SDK JavaScript, e plugins como "Math CAPTCHA" e "Really Simple CAPTCHA" seguem entre os mais instalados no WordPress. Resolver uma conta simples também é mais rápido do que selecionar imagens em grade.

No Brasil, é comum ver o Really Simple CAPTCHA em formulários de contato de sites institucionais e lojas pequenas que preferem algo autossuficiente a um serviço externo.

Há também acessibilidade: a versão em texto funciona com leitor de tela, o que o CAPTCHA de imagem não oferece. E há inércia — aplicação legada, anterior aos serviços de CAPTCHA comportamental, que ninguém migrou.

Como o CAPTCHA matemático funciona por trás dos panos

O fluxo muda pouco entre a versão em texto e a versão em imagem — a diferença está em como a equação chega até o usuário.

Fluxo do CAPTCHA matemático em 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

Fluxo do CAPTCHA matemático em imagem

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

Como detectar CAPTCHA matemático em automação

Antes de resolver, sua automação precisa reconhecer o padrão na página. Os dois trechos abaixo procuram por perguntas matemáticas em texto, imagens de CAPTCHA e perguntas de lógica comuns.

Detecção em 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)

O retorno é um dicionário com três chaves booleanas, pronto para um if no fluxo.

Detecção em 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);

Mesma lógica do exemplo em Python, trocando requests/BeautifulSoup por axios/cheerio.

Como resolver CAPTCHA matemático em imagem com OCR

Quando a equação vem dentro de uma imagem, não existe atalho: primeiro você precisa de OCR para extrair o texto e só depois calcular a resposta.

Usando a CaptchaAI para CAPTCHA matemático em imagem

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

O mesmo endpoint serve para qualquer equação em imagem; o regex final só converte o texto extraído em resposta numérica.

CAPTCHA matemático comparado a outros tipos

Lado a lado com os desafios mais usados hoje, o CAPTCHA matemático perde feio em resistência a bots — por isso só faz sentido como primeira camada, nunca como proteção principal.

Perguntas frequentes

CAPTCHA matemático barra bots de verdade?

Não muito: a versão em texto simples é lida por qualquer bot que analise o HTML da página, e a versão em imagem cai com OCR. Esse tipo de CAPTCHA só segura spam bot genérico — para bloquear automação de verdade, use um sistema comportamental como reCAPTCHA ou Cloudflare Turnstile.

Qual a diferença entre CAPTCHA matemático e CAPTCHA lógico?

O matemático pede uma conta; o lógico troca a conta por uma pergunta de conhecimento geral, como a cor do céu. Os dois oferecem a mesma proteção: quase nenhuma, porque vêm de um banco de perguntas fixo e previsível.

Preciso de OCR para resolver um CAPTCHA matemático em texto?

Não. Se a equação estiver no HTML como texto puro, você captura direto do código-fonte com regex ou parsing de DOM. O OCR só é necessário quando a equação vem dentro de uma imagem.

CAPTCHA matemático em texto funciona com leitor de tela?

Sim — é um dos motivos de ele continuar em uso. Como a pergunta é texto puro no HTML, o leitor de tela a anuncia normalmente, ao contrário do CAPTCHA de imagem, que depende de visão.

Ainda vale usar plugins como o Really Simple CAPTCHA em 2026?

Contra spam genérico, sim — é leve e não depende de API externa. Contra automação dedicada ou scraping direcionado, não segura: Cloudflare Turnstile ou reCAPTCHA v3 protegem de verdade sem atrito extra para quem preenche o formulário.

Resumo

O CAPTCHA matemático e lógico é o desafio mais simples que ainda circula — comum em formulários WordPress e sistemas legados. A versão em texto lê-se direto do HTML; a em imagem exige OCR antes da conta. Para essa variante, a API de OCR de imagem CaptchaAI resolve extração e cálculo numa chamada. Fácil de automatizar, mas segue popular pela simplicidade e pelo ganho de acessibilidade sobre o CAPTCHA de imagem tradicional.

Artigos relacionados

• Geetest vs Cloudflare Turnstile: qual escolher
• Cloudflare Turnstile com erro 403 após corrigir o token
• Modos de widget do Cloudflare Turnstile explicados