reCAPTCHA v2 vs v3: qual versão oferece melhor proteção contra bots?

Se você está tentando decidir entre reCAPTCHA v2 ou v3 para o seu site, está avaliando um trade-off real: atrito visível versus pontuação de risco invisível. Este guia detalha as diferenças entre reCAPTCHA v2 e v3 em proteção contra bots, experiência do usuário e implementação — com exemplos completos de código — para que você possa fazer uma escolha informada.

O que é o reCAPTCHA v2?

Lançado pelo Google, o reCAPTCHA v2 é a versão que a maioria dos usuários reconhece instantaneamente: a clássica caixa de seleção "I'm not a robot". Quando os sinais de risco do Google não são claros, ele eleva para um desafio em grade de imagens — pedindo aos usuários que identifiquem hidrantes, semáforos, faixas de pedestres e assim por diante.

O reCAPTCHA v2 está disponível em duas subvariantes:

• Checkbox (Padrão): Renderiza um widget visível. O usuário clica em uma caixa de seleção; o Google avalia o movimento do mouse, o tempo e os sinais do navegador. Se a confiança for baixa, aparece um desafio com imagens.
• Invisible v2: Sem widget visível. O desafio é acionado silenciosamente no envio do formulário. Apenas os usuários que parecem suspeitos chegam a ver um desafio. Essa é uma distinção importante ao comparar reCAPTCHA v2 invisible vs v3 (mais sobre isso abaixo).

A diferença entre reCAPTCHA v2 e v3 começa aqui: o v2 depende de uma ação humana explícita, enquanto o v3 coleta sinais comportamentais passivamente durante toda a sessão do usuário.

O que é o reCAPTCHA v3?

O reCAPTCHA v3, também desenvolvido pelo Google, é totalmente invisível. Ele nunca interrompe o usuário com um desafio. Em vez disso, funciona continuamente em segundo plano, monitorando sinais comportamentais como movimento do mouse, padrões de rolagem, tempo de interação e histórico de navegação. Em um ponto de ação definido — login, cadastro, checkout — ele retorna uma pontuação de risco de 0.0 a 1.0:

• 1.0 = muito provavelmente humano
• 0.0 = muito provavelmente um bot

Observação prática: O plano gratuito do reCAPTCHA v3 normalmente oferece apenas quatro valores de pontuação de risco: 0.1, 0.3, 0.7 e 0.9. Na prática, os valores extremos (0.0 e 1.0) raramente são retornados. A faixa completa de 11 níveis exige uma conta de faturamento vinculada a um projeto do Google Cloud.

De forma crítica, o reCAPTCHA v3 não bloqueia requisições automaticamente. Seu backend precisa interpretar a pontuação e decidir o que fazer. Esse é o núcleo da diferença entre reCAPTCHA v3 e v2: o v2 barra bots na entrada; o v3 os sinaliza e deixa a decisão para você.

Diferenças entre reCAPTCHA v2 e v3: análise aprofundada da proteção contra bots

Entender as diferenças entre Google reCAPTCHA v2 e v3 do ponto de vista de segurança exige observar a superfície de ataque que cada versão cria.

O reCAPTCHA v2 bloqueia imediatamente bots básicos baseados em scripts — eles não conseguem clicar em uma caixa de seleção nem resolver uma grade de imagens sem ferramentas especializadas. No entanto, ele é vulnerável a:

• Ataques de visão computacional — modelos de ML que conseguem resolver grades de imagens com níveis variados de precisão, dependendo do tipo de desafio e da sofisticação do modelo
• Serviços de resolução humana — plataformas de terceiros nas quais humanos normalmente resolvem desafios por taxas baixas por tarefa
• Ataques de replay de token — reutilização de um token válido em múltiplas requisições se a verificação no lado do servidor estiver ausente ou for fraca

O reCAPTCHA v3 muda o modelo de detecção. Como ele analisa o comportamento ao longo de toda a sessão, pode detectar bots sofisticados que imitam interação humana em um único ponto de desafio. No entanto, suas fraquezas incluem:

• Ausência de bloqueio rígido — um adversário que entenda seu limite de pontuação pode conseguir ajustar requisições para permanecer acima dele ao longo do tempo
• Falsos positivos — usuários legítimos em VPNs, nós de saída Tor ou navegadores com foco em privacidade podem receber pontuações baixas e ser bloqueados incorretamente
• Ônus de ajuste do threshold — você precisa instrumentar seu site, coletar dados e calibrar limites — o que exige manutenção contínua

Nenhuma das versões oferece prevenção garantida contra bots. Em cenários de alto risco, combinar as duas versões — usando o v3 como sinal primário e recorrendo a um desafio v2 quando a pontuação for baixa — é considerado uma estratégia híbrida de boas práticas.

Comparação de UX — atrito vs. invisibilidade

A diferença de UX entre Google reCAPTCHA v2 e v3 é significativa. O reCAPTCHA v2 introduz atrito visível em um ponto crítico de conversão. Desafios em grade de imagens são especialmente incômodos em dispositivos móveis e para usuários com deficiência visual, e um desafio padrão apenas com imagens pode entrar em conflito com as diretrizes de acessibilidade WCAG quando não há alternativa em áudio. Isso significa que o v2 pode ter um impacto relevante nas taxas de conversão, especialmente em formulários voltados ao consumidor.

Ao comparar reCAPTCHA v2 invisible vs v3: ambos ficam ocultos para a maioria dos usuários, mas diferem na forma como lidam com casos de borda. O Invisible v2 recorre a um desafio quando sua confiança é baixa — portanto, usuários preocupados com privacidade ainda podem ver uma grade de imagens. O v3 nunca mostra um desafio — em vez disso, retorna uma pontuação de risco ao seu backend, que então decide como responder. Se o seu backend estiver configurado para rejeitar requisições abaixo de um determinado limite, os usuários podem perceber que sua ação foi negada silenciosamente, sem explicação. Isso pode ser uma experiência frustrante, embora o próprio v3 não bloqueie ninguém: a decisão de bloqueio sempre pertence à lógica do seu servidor.

Observações de acessibilidade:

• v2 checkbox: Moderadamente acessível com navegação por teclado; grades de imagens continuam sendo difíceis para usuários de leitores de tela sem a alternativa em áudio
• v2 invisible: Mais acessível, já que a maioria dos usuários nunca vê um desafio
• v3: Melhor base de acessibilidade, já que nenhum desafio é exibido; no entanto, bloqueios silenciosos por falso positivo devem ser tratados com um caminho de fallback transparente (por exemplo, verificação por email)

reCAPTCHA v2 vs v3 — comparação de recursos

Quando usar reCAPTCHA v2 ou v3

Responder à pergunta reCAPTCHA v2 vs v3: qual é melhor depende inteiramente do seu contexto. Nenhuma das versões é universalmente superior.

Escolha o reCAPTCHA v2 quando:

• O formulário for de alto risco (login, pagamento, criação de conta) e a confirmação explícita do usuário agregar valor
• Você quiser uma lógica simples no backend — verificar o token, sem interpretar pontuação
• Sua base de usuários for menos sensível a atrito (ferramentas B2B, painéis administrativos)
• Você precisar de um desafio de fallback com bloqueio rígido para usuários que falham em uma verificação de pontuação do v3

Escolha o reCAPTCHA v3 quando:

• Experiência do usuário e taxa de conversão forem prioridades (e-commerce, landing pages, onboarding de SaaS)
• Você quiser proteger várias ações da página sem interromper o usuário
• Você tiver capacidade no backend para interpretar pontuações e aplicar respostas em camadas (permitir / desafiar / bloquear)
• Você quiser inteligência passiva contra bots ao longo de toda a sessão do usuário

A abordagem híbrida recomendada:

1. Implante o v3 em todas as ações protegidas
2. Se um usuário ficar abaixo do seu threshold (por exemplo, abaixo de 0.5), apresente um desafio invisible v2
3. Se isso também falhar, bloqueie ou encaminhe para revisão manual

Isso combina a fluidez de UX do v3 com a capacidade de bloqueio rígido do v2.

Guia de implementação — reCAPTCHA v2

Etapa 1: registre sua site key

Acesse o Google Console de Administração do reCAPTCHA, selecione reCAPTCHA v2 ("I'm not a robot" Checkbox) e adicione seu domínio. Você receberá uma site key (pública) e uma secret key (privada — apenas servidor, nunca exponha no lado do cliente).

Etapa 2: frontend — widget Checkbox

<!DOCTYPE html> 
<html> 
<head> 
  <title>Demo do reCAPTCHA v2</title> 
  <script src="https://www.google.com/recaptcha/api.js" async defer></script> 
</head> 
<body> 
  <form action="/submit" method="POST"> 
    <input type="text" name="email" placeholder="Seu email" required /> 
    <div class="g-recaptcha" data-sitekey="YOUR_SITE_KEY"></div> 
    <br/> 
    <input type="submit" value="Enviar"> 
  </form> 
</body> 
</html>

Etapa 3: frontend — variante Invisible v2

<!DOCTYPE html> 
<html> 
<head> 
  <title>Demo do reCAPTCHA v2 Invisible</title> 
  <script src="https://www.google.com/recaptcha/api.js" async defer></script> 
  <script> 
    function onSubmit(token) { 
      document.getElementById("demo-form").submit(); 
    } 
  </script> 
</head> 
<body> 
  <form id="demo-form" action="/submit" method="POST"> 
    <input type="text" name="email" placeholder="Seu email" required /> 
    <button class="g-recaptcha" 
            data-sitekey="YOUR_SITE_KEY" 
            data-callback="onSubmit" 
            data-badge="bottomright"> 
      Enviar 
    </button> 
  </form> 
</body> 
</html>

Etapa 4: verificação no backend (PHP)

<?php 
if ($_SERVER['REQUEST_METHOD'] !== 'POST') { 
    http_response_code(405); 
    exit('Método não permitido'); 
} 
$token  = $_POST['g-recaptcha-response'] ?? ''; 
$secret = 'YOUR_SECRET_KEY'; 
if (!$token) { 
    exit('Token de CAPTCHA ausente.'); 
} 
// Use POST para evitar expor a secret key em logs de servidor/proxy 
$postData = http_build_query([ 
    'secret'   => $secret, 
    'response' => $token, 
]); 
$context = stream_context_create([ 
    'http' => [ 
        'method'  => 'POST', 
        'header'  => 'Content-Type: application/x-www-form-urlencoded', 
        'content' => $postData, 
    ], 
]); 
$response = file_get_contents( 
    'https://www.google.com/recaptcha/api/siteverify', 
    false, 
    $context 
); 
if ($response === false) { 
    http_response_code(503); 
    exit('Não foi possível acessar o serviço de verificação do reCAPTCHA.'); 
} 
$result = json_decode($response, true); 
if (!empty($result['success'])) { 
    echo "<p>Formulário enviado com sucesso!</p>"; 
} else { 
    http_response_code(403); 
    echo "<p>Falha na verificação do CAPTCHA. Tente novamente.</p>"; 
} 
?>

Guia de implementação — reCAPTCHA v3

Etapa 1: registre uma site key v3

No Console de Administração do reCAPTCHA, selecione reCAPTCHA v3. Você receberá chaves separadas de quaisquer chaves v2 — não as misture entre versões.

Etapa 2: frontend — execução programática do token

<!DOCTYPE html> 
<html> 
<head> 
  <title>Demo do reCAPTCHA v3</title> 
  <script src="https://www.google.com/recaptcha/api.js?render=YOUR_SITE_KEY"></script> 
</head> 
<body> 
  <form id="login-form"> 
    <input type="email" name="email" placeholder="Email" required /> 
    <input type="password" name="password" placeholder="Senha" required /> 
    <button type="button" onclick="submitWithRecaptcha()">Entrar</button> 
  </form> 
  <script> 
    async function submitWithRecaptcha() { 
      // Os tokens expiram após 2 minutos -- execute imediatamente antes do envio 
      const token = await new Promise((resolve) => { 
        grecaptcha.ready(() => { 
          grecaptcha.execute('YOUR_SITE_KEY', { action: 'login' }).then(resolve); 
        }); 
      }); 
      const response = await fetch('/api/login', { 
        method: 'POST', 
        headers: { 'Content-Type': 'application/json' }, 
        body: JSON.stringify({ 
          email: document.querySelector('[name="email"]').value, 
          recaptchaToken: token 
        }) 
      }); 
      const data = await response.json(); 
      if (data.ok) { 
        alert('Login realizado com sucesso!'); 
      } else { 
        alert('Falha na verificação: ' + (data.error || 'erro desconhecido')); 
      } 
    } 
  </script> 
</body> 
</html>

Etapa 3: verificação no backend (Node.js / Express)

// Node.js 18+ com Express 
import express from 'express'; 
const app = express(); 
app.use(express.json()); 
app.post('/api/login', async (req, res) => { 
  const { recaptchaToken } = req.body; 
  const params = new URLSearchParams(); 
  params.set('secret', process.env.RECAPTCHA_SECRET); 
  params.set('response', recaptchaToken); 
  try { 
    const verifyRes = await fetch('https://www.google.com/recaptcha/api/siteverify', { 
      method: 'POST', 
      headers: { 'content-type': 'application/x-www-form-urlencoded' }, 
      body: params 
    }); 
    const data = await verifyRes.json(); 
    if (!data.success) { 
      return res.status(403).json({ error: 'recaptcha_failed', codes: data['error-codes'] }); 
    } 
    // Sempre valide se a action corresponde ao que você esperava 
    if (data.action !== 'login') { 
      return res.status(403).json({ error: 'recaptcha_action_mismatch' }); 
    } 
    // 0.5 é o threshold inicial recomendado pelo Google -- ajuste com base no seu tráfego 
    if (data.score < 0.5) { 
      return res.status(403).json({ error: 'recaptcha_low_score', score: data.score }); 
    } 
    return res.json({ ok: true }); 
  } catch (err) { 
    return res.status(503).json({ error: 'recaptcha_service_unavailable' }); 
  } 
}); 
app.listen(3000, () => console.log('Servidor em execução na porta 3000'));

Automatizando a resolução de reCAPTCHA com CapMonster Cloud

Ao criar automação de testes, pipelines de QA ou fluxos autorizados de web scraping, você precisa de uma forma de lidar com desafios de reCAPTCHA programaticamente — sem quebrar sua suíte de testes toda vez que um CAPTCHA aparece. CapMonster Cloud é um serviço automatizado de resolução de CAPTCHA que oferece suporte a reCAPTCHA v2 e v3, fornecendo uma API baseada em tokens que se integra com facilidade a qualquer stack tecnológica.

Importante: O CapMonster Cloud destina-se ao uso em sites e plataformas aos quais você tem acesso autorizado — para testes, automação de QA e fluxos autorizados de scraping.

Resolvendo reCAPTCHA v2 via API do CapMonster Cloud

Requisição para criar tarefa:

POST https://api.capmonster.cloud/createTask
{ 
  "clientKey": "YOUR_API_KEY", 
  "task": { 
    "type": "RecaptchaV2Task", 
    "websiteURL": "https://example.com/login", 
    "websiteKey": "YOUR_SITE_KEY" 
  } 
}

Resposta

{ 
  "errorId":0, 
  "taskId":407533072 
}

Consultar resultado:

POST https://api.capmonster.cloud/getTaskResult
{ 
  "clientKey": "YOUR_API_KEY", 
  "taskId": 407533072 
}

Resposta (quando estiver pronta):

{ 
  "errorId": 0, 
  "status": "ready", 
  "solution": { 
    "gRecaptchaResponse": "03AFcWeA66ZARdA5te7ac..." 
  } 
}

Resolvendo reCAPTCHA v3 via API do CapMonster Cloud

POST https://api.capmonster.cloud/createTask
{ 
  "clientKey": "YOUR_API_KEY", 
  "task": { 
    "type": "RecaptchaV3TaskProxyless", 
    "websiteURL": "https://example.com/login", 
    "websiteKey": "YOUR_SITE_KEY",
    "isEnterprise": false, 
    "minScore": 0.7, 
    "pageAction": "login" 
  } 
}

As etapas seguintes são semelhantes às do v2.

Exemplo de SDK (Python — reCAPTCHA v3)

# https://github.com/Zennolab/capmonstercloud-client-python
import asyncio 
from capmonstercloudclient import CapMonsterClient, ClientOptions 
from capmonstercloudclient.requests import RecaptchaV3ProxylessRequest 
client_options = ClientOptions(api_key="YOUR_API_KEY")  # Especifique sua chave de API do CapMonster Cloud 
cap_monster_client = CapMonsterClient(options=client_options) 
# Opcionalmente, você pode verificar o saldo 
balance = asyncio.run(cap_monster_client.get_balance()) 
print("Saldo:", balance) 
recaptcha_v3_request = RecaptchaV3ProxylessRequest( 
    websiteUrl="https://lessons.zennolab.com/captchas/recaptcha/v3.php?level=beta",  # URL da sua página com captcha 
    websiteKey="6Le0xVgUAAAAAIt20XEB4rVhYOODgTl00d8juDob", 
    minScore=0.6, 
    pageAction="myverify" 
) 
async def solve_captcha(): 
    return await cap_monster_client.solve_captcha(recaptcha_v3_request) 
responses = asyncio.run(solve_captcha()) 
print(responses)

Exemplo de SDK (Node.js — reCAPTCHA v2)

// https://github.com/ZennoLab/capmonstercloud-client-js
import { CapMonsterCloudClientFactory, ClientOptions, RecaptchaV2Request } from '@zennolab_com/capmonstercloud-client'; 
const API_KEY = "YOUR_API_KEY";  // Especifique sua chave de API do CapMonster Cloud 
async function solveRecaptchaV2() { 
    const client = CapMonsterCloudClientFactory.Create( 
        new ClientOptions({ clientKey: API_KEY }) 
    ); 
    // Exemplo básico sem proxy 
    // O CapMonster Cloud usa automaticamente seus próprios proxies 
    let recaptcha2Request = new RecaptchaV2Request({ 
        websiteURL: "https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high", 
        websiteKey: "6Lcg7CMUAAAAANphynKgn9YAgA4tQ2KI_iqRyTwd" 
    }); 
    // Exemplo de uso do seu próprio proxy 
    // Descomente este bloco se quiser usar seu próprio proxy 
    /* 
    const proxy = { 
        proxyType: "http", 
        proxyAddress: "123.45.67.89", 
        proxyPort: 8080, 
        proxyLogin: "username", 
        proxyPassword: "password" 
    }; 
    recaptcha2Request = new RecaptchaV2Request({ 
        websiteURL: "https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high", 
        websiteKey: "6Lcg7CMUAAAAANphynKgn9YAgA4tQ2KI_iqRyTwd", 
        proxy, 
        userAgent: "userAgentPlaceholder" 
    }); 
    */ 
    // Opcionalmente, você pode verificar o saldo 
    const balance = await client.getBalance(); 
    console.log("Saldo:", balance); 
    const result = await client.Solve(recaptcha2Request); 
    console.log("Solução:", result); 
} 
solveRecaptchaV2().catch(console.error);

O CapMonster Cloud também oferece suporte a reCAPTCHA Enterprise, Cloudflare Turnstile e vários outros tipos de CAPTCHA — o que o torna uma ferramenta versátil para qualquer infraestrutura de testes que interaja com formulários protegidos por CAPTCHA.

Checklist de implementação

reCAPTCHA v2

1. Registre uma site key v2 no Console de Administração do Google reCAPTCHA
2. Adicione o script api.js à sua página com async defer
3. Renderize o widget com <div data-sitekey="..."> (checkbox) ou configure a variante invisible com data-callback
4. Extraia g-recaptcha-response do corpo do POST no seu servidor
5. Verifique o token em https://www.google.com/recaptcha/api/siteverify usando sua secret key via POST (não GET) para proteger a secret key contra registro em logs
6. Verifique se success: true é retornado antes de processar o envio do formulário
7. Nunca exponha sua secret key em código no lado do cliente
8. Forneça uma alternativa de desafio em áudio para acessibilidade

reCAPTCHA v3

1. Registre uma site key v3 separada (não reutilize chaves v2)
2. Carregue api.js?render=YOUR_SITE_KEY
3. Chame grecaptcha.execute(siteKey, { action: 'your_action' }) para cada ação protegida
4. Envie o token ao seu backend imediatamente — os tokens expiram após 2 minutos e são de uso único
5. Verifique via siteverify, confirme success: true e valide se action corresponde ao valor esperado
6. Defina um threshold inicial de pontuação (0.5 é o ponto de partida recomendado pelo Google) e ajuste com base na análise do tráfego real
7. Defina uma resposta em camadas para cada faixa de pontuação: permitir / desafio adicional / bloquear
8. Registre as pontuações ao longo do tempo para detectar desvios e ajustar os thresholds
9. Forneça um caminho de fallback transparente (por exemplo, verificação por email) para usuários que recebam pontuação baixa sem culpa própria

FAQ

P: O reCAPTCHA v3 é melhor que o v2? Não de forma universal. O reCAPTCHA v3 oferece melhor experiência do usuário, mas exige significativamente mais trabalho no backend e introduz risco de falsos positivos para usuários legítimos em VPNs ou navegadores com foco em privacidade. O v2 é mais simples de implantar e fornece um bloqueio rígido no nível do formulário. Para formulários de alta segurança, muitas equipes usam ambos em uma configuração híbrida — v3 como primeira camada, v2 como fallback.

P: Qual é a diferença entre reCAPTCHA v2 e v3 em termos de experiência do usuário? O v2 (checkbox) exige uma ação visível do usuário e pode escalar para desafios com imagens. O v3 é totalmente invisível — os usuários nunca interagem diretamente com ele. No entanto, o v3 pode retornar uma pontuação baixa e bloquear silenciosamente usuários legítimos, o que é uma forma diferente — mas ainda real — de atrito, especialmente quando os usuários não recebem explicação sobre o motivo de sua ação ter sido rejeitada.

P: Posso usar reCAPTCHA v2 e v3 juntos? Sim, e isso é recomendado para cenários de alto risco. Use o v3 como camada principal para pontuar todos os usuários passivamente e, em seguida, apresente um desafio v2 (visível ou invisible) para os usuários cuja pontuação no v3 fique abaixo do seu threshold. Essa é a abordagem híbrida descrita na seção de implementação acima.

P: Que threshold devo definir para o reCAPTCHA v3? O Google recomenda 0.5 como ponto de partida. O threshold correto depende dos seus padrões de tráfego — analise as distribuições de pontuação entre seus usuários reais antes de definir um número final. Um threshold muito alto pode bloquear usuários legítimos; muito baixo, e bots podem passar. Ações de alto risco, como pagamentos ou redefinições de senha, podem justificar um threshold mais alto.

P: Qual é a diferença entre reCAPTCHA v2 invisible e v3? Ambos ficam ocultos para a maioria dos usuários, mas funcionam de maneira diferente. O Invisible v2 ainda tem fallback para desafio — usuários suspeitos podem ver uma grade de imagens. O v3 nunca mostra nenhum tipo de desafio; ele retorna apenas uma pontuação. A principal diferença prática é que o v2 invisible mantém um mecanismo de bloqueio rígido por meio do desafio, enquanto o v3 delega toda decisão de bloqueio à lógica do seu backend.

Conclusão

A decisão entre reCAPTCHA v2 vs v3 se resume a duas variáveis: quanto atrito você pode aceitar e quanto de sofisticação no backend você pode investir. O v2 fornece uma barreira simples e comprovada com configuração mínima; o v3 fornece inteligência invisível e mais refinada, que exige interpretação ativa e ajuste contínuo de thresholds. Para a maioria dos sites em produção, a abordagem mais resiliente é um híbrido dos dois.

Pronto para testar sua integração de CAPTCHA? Experimente o CapMonster Cloud hoje mesmo → — automatize a resolução de reCAPTCHA v2 e v3 nos seus fluxos de QA e testes com uma API simples e SDKs oficiais para Python, JavaScript e C#.