CAPTCHA de texto vs CAPTCHA de imagem: comparação para desenvolvedores

Se a pergunta é "qual dos dois devo usar", a resposta curta em 2026 é: provavelmente nenhum. O CAPTCHA de texto — aquelas letras tortas dentro de um PNG — já é lido por OCR comum e hoje barra mais gente de verdade do que bot; o de imagem protege melhor, mas cobra caro em atrito e em acessibilidade.

A pergunta útil é outra: você mantém um sistema que já usa um dos dois, ou automatiza testes contra ele. Segue na ordem do trabalho — decisão, detecção, código.

Decisão rápida: qual tipo faz sentido no seu projeto

Fique com o CAPTCHA de texto quando:

• Você precisa de algo auto-hospedado, sem SDK de terceiros no formulário.
• O volume de bots é baixo e o objetivo é conter spam.
• Políticas internas de dados (ou uma leitura conservadora da LGPD) desaconselham enviar sinais de navegação a um provedor externo.

Prefira o CAPTCHA de imagem quando:

• A superfície protegida é sensível: login, recuperação de senha, checkout.
• Você aceita mais atrito por uma barreira que exige reconhecer objetos.
• Você quer uma solução gerenciada em vez de um gerador próprio.

Não use nenhum dos dois quando:

• Um desafio invisível dá conta: reCAPTCHA v3 e Cloudflare Turnstile avaliam a requisição sem pedir nada ao usuário.

Um caso concreto: em um e-commerce brasileiro na Black Friday, trocar a grade de imagens do cadastro por Turnstile devolve segundos a cada conversão. Um CAPTCHA de texto ali seria o pior dos dois mundos — atrito quase igual, barreira menor.

Comparação lado a lado

As faixas por mil são valores de mercado, úteis como ordem de grandeza. A CaptchaAI não cobra por resolução: os planos são por thread, do BASIC (US$ 15/mês, 5 threads) ao VIP-3 (US$ 7.500/mês, 5.000 threads). O custo depende da concorrência, não do volume de desafios.

Como o CAPTCHA de texto é montado

O servidor gera uma string aleatória, distorce, renderiza como imagem e guarda a resposta. Sem JavaScript obrigatório e sem chamada externa.

Técnicas usadas na distorção

Fluxo do desafio

Server generates random string (e.g., "X7mK9p")
    ↓
Applies distortion: warping, noise, overlap
    ↓
Renders as PNG/JPEG image
    ↓
User reads characters, types into input field
    ↓
Server compares input against stored string (case-insensitive usually)

O problema estrutural: cada técnica acima custa legibilidade humana na mesma proporção em que atrapalha o OCR.

Como o CAPTCHA de imagem é montado

Aqui o servidor sorteia fotos de um conjunto rotulado, monta uma grade e pede uma categoria; a validação compara a seleção com o rótulo.

Formatos que você vai encontrar

Fluxo do desafio

Server selects images from a labeled dataset
    ↓
Presents 3×3 or 4×4 grid with a text prompt
    ↓
User clicks matching images
    ↓
Server validates selections against ground truth
    ↓
If fading images: new images load in place of selected ones (multi-round)

O detalhe que mais atrapalha a automação é o último: nas grades com imagens que se dissolvem, cada acerto carrega outra foto e o desafio vira multi-rodada.

Como identificar o formato de uma página

Antes de escolher o solucionador, descubra o que está na página. Os scripts abaixo apontam para staging — use sempre o seu ambiente autorizado.

Detecção em Python

import requests
from bs4 import BeautifulSoup
import re

def detect_captcha_type(url):
    """Detect whether page uses text or image CAPTCHA."""
    response = requests.get(url, timeout=10)
    soup = BeautifulSoup(response.text, "html.parser")
    html = response.text

    result = {"text_captcha": False, "image_captcha": False, "provider": None}

    # Check for reCAPTCHA (image-based)
    if "google.com/recaptcha" in html or "g-recaptcha" in html:
        result["image_captcha"] = True
        result["provider"] = "reCAPTCHA"
        return result

    # Check for hCaptcha (image-based)
    if "hcaptcha.com" in html or "h-captcha" in html:
        result["image_captcha"] = True
        result["provider"] = "hCaptcha"
        return result

    # Check for text CAPTCHA patterns
    captcha_images = soup.find_all("img", attrs={
        "src": re.compile(r"captcha", re.I)
    })
    captcha_inputs = soup.find_all("input", attrs={
        "name": re.compile(r"captcha", re.I)
    })

    if captcha_images and captcha_inputs:
        # Image with text input = text CAPTCHA
        result["text_captcha"] = True
        result["provider"] = "custom text CAPTCHA"
        return result

    # Check for FunCaptcha (image-based rotation)
    if "funcaptcha" in html.lower() or "arkoselabs" in html.lower():
        result["image_captcha"] = True
        result["provider"] = "FunCaptcha"
        return result

    return result

captcha = detect_captcha_type("https://staging.example.com/qa-login")
print(captcha)

Detecção em Node.js

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

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

    const result = { textCaptcha: false, imageCaptcha: false, provider: null };

    // reCAPTCHA detection
    if (html.includes("google.com/recaptcha") || html.includes("g-recaptcha")) {
        result.imageCaptcha = true;
        result.provider = "reCAPTCHA";
        return result;
    }

    // hCaptcha detection
    if (html.includes("hcaptcha.com") || html.includes("h-captcha")) {
        result.imageCaptcha = true;
        result.provider = "hCaptcha";
        return result;
    }

    // Text CAPTCHA: image + input with "captcha" in name/class
    const captchaImgs = $("img[src*='captcha' i]").length;
    const captchaInputs = $("input[name*='captcha' i]").length;

    if (captchaImgs > 0 && captchaInputs > 0) {
        result.textCaptcha = true;
        result.provider = "custom text CAPTCHA";
        return result;
    }

    return result;
}

detectCaptchaType("https://staging.example.com/qa-login").then(console.log);

A ordem importa: provedores gerenciados aparecem pelo domínio do script; só depois vale procurar o padrão do CAPTCHA de texto — img com "captcha" no src junto de um input com "captcha" no name.

Resolvendo CAPTCHA de texto com a CaptchaAI

Todo CAPTCHA de texto é, no fundo, uma imagem, e por isso cabe na API de OCR: enviar a imagem em base64 para in.php e consultar o resultado em res.php.

import requests
import base64
import time

API_KEY = "YOUR_API_KEY"

# Get the CAPTCHA image
captcha_url = "https://example.com/captcha.png"
image_data = requests.get(captcha_url).content
b64 = base64.b64encode(image_data).decode()

# Submit to CaptchaAI
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "base64",
    "body": b64,
    "json": 1,
})
task_id = submit.json()["request"]

# Poll for result
for _ in range(30):
    time.sleep(3)
    resp = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY,
        "action": "get",
        "id": task_id,
        "json": 1,
    }).json()

    if resp.get("status") == 1:
        print(f"CAPTCHA text: {resp['request']}")
        break

Dois pontos evitam retrabalho: trate CAPCHA_NOT_READY como estado normal, não erro — só o status: 1 encerra o polling; e dimensione por thread, porque 20 verificações em paralelo exigem 20 threads no plano.

A CaptchaAI cobre mais de 27.500 variantes de CAPTCHA de imagem — texto distorcido, equações matemáticas, reconhecimento de caracteres — com alta taxa de sucesso nos tipos suportados.

O que é coberto e o que não é

Suportado: imagem e OCR, grade de imagens, BLS, reCAPTCHA v2 e v3 (inclusive Enterprise e invisível), GeeTest v3, Cloudflare Turnstile e Challenge. Em beta: CaptchaFox (beta), Friendly Captcha (beta) e Lemin (beta). Não suportado: hCaptcha e FunCaptcha (Arkose Labs); o GeeTest v4 está anunciado como "em breve".

Perguntas frequentes

Dá para deixar um CAPTCHA de texto acessível de verdade?

Só parcialmente. Uma alternativa em áudio cobre parte dos usuários com baixa visão, mas falha para quem usa leitor de tela em ambiente ruidoso. Desafios invisíveis têm menos barreiras.

Vale a pena manter meu gerador próprio de CAPTCHA de texto?

Se ele só contém spam e o volume é baixo, sim — a manutenção é quase zero. Se protege login ou pagamento, não: OCR genérico lida com a maioria dos geradores caseiros, e a distorção necessária para atrapalhá-lo derruba o acerto dos seus usuários.

Como calculo o custo de resolver esses desafios no meu pipeline de testes?

Comece pela concorrência: conte quantas resoluções o pipeline dispara ao mesmo tempo no pico e escolha o plano com pelo menos esse número de threads. O BASIC (US$ 15/mês, 5 threads) atende suítes pequenas; o STANDARD (US$ 30/mês, 15 threads) cobre CI paralelo.

Automatizar a resolução de CAPTCHA em testes é permitido?

Depende do escopo. O uso previsto é em ambientes próprios ou autorizados: staging, QA de integração, monitoramento contratado. Ao coletar dado pessoal, considere as obrigações da LGPD (ou do RGPD, em Portugal).

Resumo

CAPTCHA de texto é barato de implantar e fácil de resolver por OCR; o de imagem protege mais e custa mais, em atrito e em preço. Para quem automatiza fluxos autorizados, o texto exige apenas OCR — tarefa direta para o OCR de imagem da CaptchaAI —, enquanto a grade exige solucionadores específicos, disponíveis para reCAPTCHA, mas não para hCaptcha nem FunCaptcha.

Artigos relacionados

• CaptchaAI e CapMonster Cloud lado a lado
• GeeTest v3 ou Cloudflare Turnstile: qual escolher
• Erro 403 no Cloudflare Turnstile depois do token