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.
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:
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 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:
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ê.
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:
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:
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.
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:
Recurso | reCAPTCHA v2 (Checkbox) | reCAPTCHA v2 (Invisible) | reCAPTCHA v3 |
Interação do usuário | Clique na caixa de seleção + possível grade de imagens | Nenhuma para a maioria dos usuários; desafio em caso de suspeita | Nenhuma — totalmente invisível |
Método de detecção de bots | Sinais do navegador + resposta ao desafio | Sinais do navegador + fallback para desafio | Pontuação comportamental ao longo da sessão |
Saída | Token de aprovação / falha | Token de aprovação / falha | Pontuação (0.0–1.0) por ação |
Risco de falso positivo | Baixo–Médio | Baixo–Médio | Médio–Alto (para usuários de VPN/privacidade) |
Acessibilidade para usuários com deficiência | Moderada (grades de imagens podem ser problemáticas) | Melhor | Melhor de todas (nenhum desafio exibido) |
Atrito para os usuários | Alto | Baixo | Nenhum |
Complexidade no backend | Baixa (verificar token) | Baixa (verificar token) | Maior (interpretar pontuação + definir ações) |
Impacto em privacidade | Moderado | Moderado | Normalmente maior (rastreamento contínuo da sessão) |
Melhor caso de uso | Formulários de alto risco, login, pagamentos | Formulários de risco moderado | Monitoramento contínuo, fluxos com múltiplas ações |
Responder à pergunta reCAPTCHA v2 vs v3: qual é melhor depende inteiramente do seu contexto. Nenhuma das versões é universalmente superior.
Escolha o reCAPTCHA v2 quando:
Escolha o reCAPTCHA v3 quando:
A abordagem híbrida recomendada:
Isso combina a fluidez de UX do v3 com a capacidade de bloqueio rígido do v2.
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).
<!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><!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><?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>";
}
?>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.
<!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>// 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'));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.
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..."
}
}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.
# https://github.com/CapMonsterCloud/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)// https://github.com/CapMonsterCloud/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.
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.
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#.
Ainda bloqueado pelo reCAPTCHA v2 em 2026? Explore métodos comprovados de resolução — APIs, Python, Node.js, extensões de navegador e serviços de contingência — com exemplos práticos para ajudar você a escolher rapidamente a abordagem certa.
