Sistemas CAPTCHA invisíveis explicados: como funcionam

Por que um formulário passa para alguns usuários e falha para outros sem exibir nenhuma caixa de seleção, grade de imagem ou campo de texto? Na maioria dos casos, a resposta é um CAPTCHA invisível: um script roda em segundo plano assim que a página carrega, analisa o comportamento do navegador, os sinais do dispositivo e a reputação da rede, e decide silenciosamente se libera a requisição.

Não existe desafio para clicar — só um token que precisa chegar junto no formulário. Este guia mostra como os 5 principais sistemas funcionam e como gerar esse token.

Como um CAPTCHA invisível decide se libera sua requisição

Todos os CAPTCHAs invisíveis seguem o mesmo padrão básico:

Page loads → CAPTCHA JavaScript injected
    ↓
Script runs in background, collecting signals:
  ├─ Browser sinal de navegador (canvas, WebGL, fonts, plugins)
  ├─ Behavioral data (mouse, keyboard, scroll, timing)
  ├─ Network data (IP reputation, TLS sinal de navegador)
  ├─ Device data (screen, GPU, CPU cores, memory)
  └─ History data (cookies, previous CAPTCHA completions)
    ↓
Signals sent to CAPTCHA provider's risk engine
    ↓
Risk score computed
    ↓
Response varies by score:
  ├─ Low risk  → Token issued silently (user sees nothing)
  ├─ Medium    → Light challenge shown (checkbox, simple click)
  └─ High risk → Full challenge (image grid) or block

A diferença para um CAPTCHA tradicional é essa: aqui a verificação começa no carregamento da página e roda o tempo todo, não só quando o usuário clica em uma caixa de seleção. O resultado — token liberado, desafio leve ou bloqueio total — depende exclusivamente da pontuação de risco calculada em cima desses sinais.

Como os principais CAPTCHAs invisíveis se comparam

Vale registrar para a LGPD: só o Turnstile evita dados pessoais. Com o panorama geral na mão, vale entender cada sistema em detalhe.

Os 5 sistemas de CAPTCHA invisível mais comuns em produção

1. reCAPTCHA v3

• Provedor: Google
• Lançamento: 2018
• Participação de mercado: maior entre os CAPTCHAs invisíveis

O reCAPTCHA v3 não pergunta nada ao usuário: a cada ação da página, devolve uma pontuação entre 0,0 e 1,0, e a decisão sobre o que fazer com o número fica com o site.

Como o script coleta os sinais:

<!-- reCAPTCHA v3 integration -->
<script src="https://www.google.com/recaptcha/api.js?render=SITE_KEY"></script>
<script>
  grecaptcha.ready(function() {
    grecaptcha.execute('SITE_KEY', { action: 'login' }).then(function(token) {
      // Token sent to server for verification
      document.getElementById('captcha-token').value = token;
    });
  });
</script>

O execute() não é o início da coleta — só o gatilho que envia o que o reCAPTCHA já observava desde o carregamento do script.

Como interpretar a pontuação:

Na prática, um limite rígido (0,7+) com reCAPTCHA v2 como plano B cobre o que o v3 sozinho deixaria passar — inspeção visual difícil não torna o v3 mais seguro que o v2.

Boas práticas para definir os limites de pontuação:

• decida o que fazer com pontuações altas, médias e baixas antes da produção;
• trate pontuações médias como gatilho de verificação, não como falha automática;
• registre a distribuição das pontuações para enxergar o desvio do limite cedo.

Como identificar no HTML da página:

import requests
import re

def detect_recaptcha_v3(url):
    html = requests.get(url, timeout=10).text
    indicators = {
        "recaptcha_v3": False,
        "site_key": None,
        "actions": [],
    }

    # Check for v3 script
    if "recaptcha/api.js?render=" in html:
        indicators["recaptcha_v3"] = True
        match = re.search(r"render=([A-Za-z0-9_-]+)", html)
        if match:
            indicators["site_key"] = match.group(1)

    # Find action names
    actions = re.findall(r"action:\s*['\"](\w+)['\"]", html)
    indicators["actions"] = actions

    return indicators

print(detect_recaptcha_v3("https://staging.example.com/qa-login"))

2. Cloudflare Turnstile

• Provedor: Cloudflare
• Lançamento: 2022
• Participação de mercado: o que mais cresce entre os sistemas invisíveis

O Turnstile resolve o desafio em camadas, sem coletar dados pessoais.

Estágios de verificação:

Integração:

<!-- Turnstile widget -->
<div class="cf-turnstile" data-sitekey="0x4AAAAAAAC3DHQhMMQ_Rxrg"></div>
<script src="https://challenges.cloudflare.com/turnstile/v0/api.js" async defer></script>

Detecção:

def detect_turnstile(url):
    html = requests.get(url, timeout=10).text
    indicators = {
        "turnstile": False,
        "site_key": None,
    }

    if "challenges.cloudflare.com/turnstile" in html or "cf-turnstile" in html:
        indicators["turnstile"] = True
        match = re.search(r'data-sitekey="([^"]+)"', html)
        if match:
            indicators["site_key"] = match.group(1)

    return indicators

3. reCAPTCHA v2 Invisível

• Provedor: Google
• Lançamento: 2017

É o reCAPTCHA v2 de sempre, disparado no envio do formulário em vez de aparecer como caixa de seleção — o usuário só clica em enviar. Se a pontuação de risco vier alta, surge um desafio de imagem, em pop-up.

Integração:

<button class="g-recaptcha"
        data-sitekey="SITE_KEY"
        data-callback="onSubmit"
        data-size="invisible">
    Submit
</button>

Principal diferença em relação à v3:

• v2 Invisible: sempre tem uma saída visível reservada para quem é sinalizado como suspeito.
• v3: nunca mostra nada — a decisão fica com o site, a partir da pontuação recebida.

4. hCaptcha Passivo (Enterprise)

• Provedor: Intuition Machines
• Disponibilidade: somente no nível Enterprise

No modo passivo do hCaptcha Enterprise não há widget visível — a avaliação usa os sinais do hCaptcha padrão e só mostra desafio visual aos mais suspeitos. O hCaptcha não está entre os tipos suportados pela CaptchaAI.

5. Tokens de acesso privado da Apple

• Provedor: Apple
• Disponibilidade: iOS 16+, macOS Ventura+

Não é um provedor de CAPTCHA, e sim um mecanismo que libera o acesso sem desafio: o dispositivo comprova que é genuíno via atestado de hardware, substituindo o CAPTCHA.

Device attestation:

  1. Website requests a challenge from a token issuer
  2. Device proves it is genuine without revealing identity
  3. Token issuer generates a blind-signed token
  4. Website verifies token → CAPTCHA skipped

Hoje já é suportado por:

• Cloudflare;
• Fastly;
• outras CDNs que implementam o padrão.

Como gerar o token certo com a API da CaptchaAI

Mesmo sem desafio na tela, todo CAPTCHA invisível gera um token que precisa chegar ao formulário. Um solucionador via API gera esse token fora do navegador do usuário, pronto para o envio.

Antes de chamar a API, você vai precisar:

• da sitekey/googlekey do widget, extraída do HTML da página-alvo;
• da pageurl onde o CAPTCHA aparece;
• da sua chave de API da CaptchaAI (YOUR_API_KEY).

Gerando o token do reCAPTCHA v3

import requests
import time

API_KEY = "YOUR_API_KEY"

submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": "6LdKlZEpAAAAAAOQjzC2v_d36tWxCl6dWsozdSy9",
    "pageurl": "https://staging.example.com/qa-login",
    "version": "v3",
    "action": "login",
    "score_qa": "0.9",
    "json": 1,
})

task_id = submit.json()["request"]

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

    if result.get("status") == 1:
        token = result["request"]
        print(f"reCAPTCHA v3 token received (score ≥ 0.9)")
        break

Gerando o token do Cloudflare Turnstile

submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "turnstile",
    "sitekey": "0x4AAAAAAAC3DHQhMMQ_Rxrg",
    "pageurl": "https://example.com/signup",
    "json": 1,
})

task_id = submit.json()["request"]

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

    if result.get("status") == 1:
        turnstile_token = result["request"]
        print(f"Turnstile token received")
        break

O mesmo fluxo de submit + polling vale em qualquer stack — inclusive Node.js:

Em Node.js: o mesmo fluxo para reCAPTCHA v3

const axios = require("axios");

async function solveRecaptchaV3(siteKey, pageUrl, action) {
    const API_KEY = "YOUR_API_KEY";

    // Submit
    const { data: submit } = await axios.post(
        "https://ocr.captchaai.com/in.php",
        new URLSearchParams({
            key: API_KEY,
            method: "userrecaptcha",
            googlekey: siteKey,
            pageurl: pageUrl,
            version: "v3",
            action: action,
            score_qa: "0.9",
            json: 1,
        })
    );

    const taskId = submit.request;

    // Poll
    for (let i = 0; i < 60; i++) {
        await new Promise((r) => setTimeout(r, 5000));
        const { data: result } = await axios.get(
            "https://ocr.captchaai.com/res.php",
            {
                params: {
                    key: API_KEY,
                    action: "get",
                    id: taskId,
                    json: 1,
                },
            }
        );

        if (result.status === 1) {
            return result.request;
        }
    }

    throw new Error("Solve timeout");
}

solveRecaptchaV3("SITE_KEY", "https://staging.example.com/qa-login", "login")
    .then((token) => console.log("Token:", token.substring(0, 50) + "..."));

Script para detectar todos os CAPTCHAs invisíveis de uma página

import requests
import re

def detect_invisible_captcha(url):
    """Detect all invisible CAPTCHA types on a page."""
    html = requests.get(url, timeout=10).text

    results = []

    # reCAPTCHA v3
    if "recaptcha/api.js?render=" in html:
        key = re.search(r"render=([A-Za-z0-9_-]+)", html)
        results.append({
            "type": "reCAPTCHA v3",
            "site_key": key.group(1) if key else "unknown",
            "solver_method": "userrecaptcha (version=v3)",
        })

    # reCAPTCHA v2 invisible
    if 'data-size="invisible"' in html and "g-recaptcha" in html:
        key = re.search(r'data-sitekey="([^"]+)"', html)
        results.append({
            "type": "reCAPTCHA v2 Invisible",
            "site_key": key.group(1) if key else "unknown",
            "solver_method": "userrecaptcha (invisible=1)",
        })

    # Cloudflare Turnstile
    if "challenges.cloudflare.com/turnstile" in html:
        key = re.search(r'data-sitekey="([^"]+)"', html)
        results.append({
            "type": "Cloudflare Turnstile",
            "site_key": key.group(1) if key else "unknown",
            "solver_method": "turnstile",
        })

    # hCaptcha (passive mode detected by script without visible widget)
    if "hcaptcha.com/1/api.js" in html and 'data-size="invisible"' in html:
        results.append({
            "type": "hCaptcha Passive",
            "solver_method": "hcaptcha",
        })

    if not results:
        results.append({"type": "none detected"})

    return results

for item in detect_invisible_captcha("https://example.com"):
    print(item)

Perguntas frequentes

Dúvidas recorrentes de quem está integrando CAPTCHA invisível com a API da CaptchaAI:

Qual é a diferença entre reCAPTCHA v3 e Cloudflare Turnstile?

• reCAPTCHA v3: pontuação 0,0–1,0, decisão fica com o seu código.
• Turnstile: resultado binário (aprova/reprova), sem coletar dados comportamentais.

Na prática, o Turnstile costuma ser mais simples de integrar quando você só precisa de um sim/não.

Um CAPTCHA invisível consome as mesmas threads do plano CaptchaAI que um desafio visível?

Sim — a cobrança é por thread simultânea, não por tipo de CAPTCHA:

• um token de reCAPTCHA v3 ocupa uma thread;
• um token de Turnstile ocupa uma thread;
• um desafio de imagem visível ocupa a mesma thread.

Preciso enviar um token mesmo quando o CAPTCHA é invisível?

Sim. Todo CAPTCHA invisível gera um token que precisa ir no envio do formulário — em campo oculto ou como parâmetro da requisição. Sem ele, o servidor rejeita a submissão sem mostrar nenhum desafio.

Por que um formulário com CAPTCHA invisível falha sem exibir nenhum erro?

Porque a verificação roda inteiramente no back-end:

• token ausente ou inválido → o site recusa a requisição ou devolve erro genérico;
• não há desafio visível para apontar o problema, então vale inspecionar a resposta HTTP.

Dá para testar CAPTCHA invisível em staging antes de subir para produção?

Dá, e é o caminho recomendado:

• gere os tokens contra o seu próprio ambiente de staging;
• valide o fluxo completo antes de apontar para produção.

Isso evita quebrar o formulário por causa de um token mal formado.

Resumo

O CAPTCHA invisível verifica quem está do outro lado da tela analisando comportamento do navegador, sinais do dispositivo e reputação de rede em segundo plano — sem nenhuma interação visível.

Pontos-chave:

• reCAPTCHA v3 e Cloudflare Turnstile são as implementações mais usadas hoje;
• o Turnstile cresce mais rápido, com preço gratuito e sem coletar dados pessoais;
• mesmo invisível, o desafio sempre exige um token válido para a automação.

Use a CaptchaAI para gerar esse token: reCAPTCHA v3 pelo método userrecaptcha com version=v3, e Turnstile pelo método turnstile, com alta taxa de sucesso nos dois casos.

Artigos relacionados

• GeeTest vs Cloudflare Turnstile: qual escolher
• Turnstile retornando 403 mesmo depois de corrigir o token
• Os modos de widget do Cloudflare Turnstile, explicados