Como o reCAPTCHA detecta automação e como funcionam os solucionadores de API

O reCAPTCHA usa um sistema de detecção em várias camadas que vai muito além da caixa de seleção visível ou do desafio da imagem. Ele executa um mecanismo sofisticado de sinal de navegador e análise comportamental que identifica ferramentas automatizadas antes mesmo de o usuário interagir com o CAPTCHA. Este guia detalha todos os métodos de detecção que o reCAPTCHA usa e explica como solucionadores baseados em API, como CaptchaAI, lidam com todos eles.

Camada de detecção 1: investigação do ambiente JavaScript

O reCAPTCHA executa testes JavaScript para detectar navegadores headless e estruturas de automação.

detecção de navegador.webdriver

O principal indicador de automação:

// Selenium/Puppeteer set this automatically
sinal de navegador automatizado === true  // → Automation detected

// Real browser
sinal de navegador automatizado === undefined  // or false → Normal browser

Quando sinal de navegador automatizado é true, o reCAPTCHA sinaliza imediatamente a sessão como automatizada, normalmente resultando em uma pontuação de 0,1 ou inferior.

APIs de navegador ausentes

Sondas reCAPTCHA para APIs que navegadores headless omitem ou implementam de maneira diferente:

// Probes reCAPTCHA performs (simplified)
const checks = {
    // Chrome-specific object
    hasChrome: !!window.chrome,
    hasChromeRuntime: !!(window.chrome && window.chrome.runtime),

    // Plugin and MIME type arrays
    pluginCount: navigator.plugins.length,
    mimeTypeCount: navigator.mimeTypes.length,

    // Notification permission
    notificationPermission: Notification.permission,

    // Speech synthesis voices
    speechVoices: window.speechSynthesis.getVoices().length,

    // Performance observer
    hasPerformanceObserver: typeof PerformanceObserver !== "undefined",
};

Adulteração de cadeia de protótipo

Ferramentas de automação sofisticadas substituem as APIs do navegador para ocultar sua presença. Testes reCAPTCHA para adulteração:

// reCAPTCHA may check if native functions were modified
const nativeToString = Function.prototype.toString;
const pluginsToString = navigator.plugins.toString();

// Overridden functions have different toString output:
// Native: "function get plugins() { [native code] }"
// Overridden: "function () { return [...fakePlugins] }"

Camada de detecção 2: sinal de navegador Canvas e WebGL

sinal de navegador em tela

O reCAPTCHA renderiza elementos ocultos em uma tela e lê dados de pixel. O resultado varia de acordo com o sistema operacional, GPU, mecanismo de renderização de fontes e configurações de anti-aliasing:

// Simplified canvas sinal de navegador
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
ctx.textBaseline = "alphabetic";
ctx.font = "14px Arial";
ctx.fillStyle = "#f60";
ctx.fillRect(125, 1, 62, 20);
ctx.fillStyle = "#069";
ctx.fillText("CaptchaTest,!", 2, 15);

const sinal de navegador = canvas.toDataURL();
// Unique per browser/OS/GPU combination

Sinais de detecção:

• Mesma sinal de navegador em diferentes OS/browsers → Spoofing detectado
• As operações do Canvas retornam dados uniformes/blank → Ambiente modo headless
• A sinal de navegador corresponde ao padrão modo headless conhecido do Chrome → Automação sinalizada

sinal de navegador WebGL

const gl = document.createElement("canvas").getContext("webgl");
const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");

const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);

// Real browser: "ANGLE (NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0)"
// Headless Chrome: "Google Inc. (Google SwiftShader)" ← Strong bot signal

SwiftShader é o renderizador de GPU de software do Google usado quando nenhuma GPU de hardware está disponível, um claro indicador de ambiente headless.

Camada de detecção 3: Análise comportamental

Esta é a camada de detecção mais forte do reCAPTCHA. Ele monitora o comportamento do usuário desde o carregamento da página até o envio do formulário.

Análise do movimento do mouse

reCAPTCHA records:
  ├─ Mouse coordinates at ~60fps intervals
  ├─ Velocity and acceleration at each point
  ├─ Trajectories between clickable elements
  ├─ Hover patterns over links and buttons
  ├─ Micro-movements while "stationary"
  └─ Natural overshoot when targeting elements

Human pattern:

  - Curved paths with variable speed
  - Natural acceleration/deceleration (Fitts's Law)
  - Random micro-jitter during hovering
  - Occasional overshoot and correction

Bot pattern:

  - Zero mouse events (no mouse simulation)
  - Straight lines at constant speed
  - Perfect targeting (no overshoot)
  - Identical patterns across sessions

Análise de teclado

reCAPTCHA records:
  ├─ Inter-key interval for each key pair
  ├─ Key hold duration (keydown to keyup)
  ├─ Error rate (backspace frequency)
  ├─ Typing rhythm consistency
  └─ Input method (keyboard vs paste vs JavaScript)

Human pattern:

  - Variable intervals (80-300ms typical)
  - Faster for common character pairs
  - Occasional errors and corrections
  - keydown → keypress → keyup sequence

Bot pattern:

  - Constant intervals or instant input
  - No keypress events (value set via JS)
  - Zero errors
  - All characters appear simultaneously

Sequência de tempo e interação

reCAPTCHA records:
  ├─ Time from page load to first interaction
  ├─ Time from CAPTCHA rendering to click
  ├─ Scroll events and depths
  ├─ Focus/blur events on form fields
  └─ Tab between fields vs click between fields

Suspicious patterns:

  - First interaction < 1 second after page load
  - CAPTCHA clicked immediately after rendering
  - No scroll events before interacting with below-fold content
  - All form fields filled in <500ms

Camada de detecção 4: análise de rede e IP

Banco de dados de reputação de IP

O Google mantém ampla inteligência de IP:

• Intervalos de data centers conhecidos: AWS (52.x.x.x, 54.x.x.x), GCP, Azure, DigitalOcean, etc.
• Provedores de proxy/VPN conhecidos: NordVPN, ExpressVPN, serviços de proxy comercial
• Nós de saída Tor: Lista pública, atualizada regularmente
• Histórico de abuso: IPs envolvidos em spam, scraping ou cultivo de CAPTCHA
• Padrões geográficos: Mudanças rápidas de localização sinalizam padrões de salto de VPN

sinal de navegador TLS

Cada cliente HTTP produz uma sinal de navegador de handshake TLS exclusiva (JA3/JA4):

Chrome 120:    JA3 = 771,4865-4866-4867-49195-49199-49196..
Python/requests: JA3 = 771,4866-4867-4865-49196-49200..
curl/libcurl:  JA3 = 771,49196-49200-159-52393-52392..

O reCAPTCHA valida se a sinal de navegador TLS corresponde ao User-Agent declarado. Um User-Agent do Chrome com uma sinal de navegador Python TLS é sinalizado como automação.

Análise de cabeçalho HTTP

Real Chrome headers:
  Accept: text/html,application/xhtml+xml,application/xml;q=0.9,...
  Accept-Language: en-US,en;q=0.9
  Accept-Encoding: gzip, deflate, br
  Sec-CH-UA: "Not_A Brand";v="8", "Chromium";v="120"
  Sec-CH-UA-Platform: "Windows"
  Sec-Fetch-Dest: document
  Sec-Fetch-Mode: navigate

Automation headers (missing or different):

  - Missing Sec-CH-UA headers
  - Missing Accept-Language
  - Non-standard Accept header
  - Missing Sec-Fetch-* headers

Camada de detecção 5: Inteligência entre sessões

O reCAPTCHA rastreia padrões em várias sessões e sites:

• Correlação de sinal de navegador de sessão: mesma sinal de navegador do navegador fazendo solicitações rápidas em vários sites
• Resolver análise de padrões: Respostas corretas dentro de janelas de tempo consistentes (os tempos de resolução humana são variáveis)
• Correlação de resposta ao desafio: Várias sessões resolvendo desafios idênticos em segundos
• Cronograma de cookies: múltiplas sessões recentes do mesmo IP sem persistência de cookies

Como os solucionadores baseados em API lidam com a detecção

Solucionadores baseados em API, como CaptchaAI, ignoram o sistema de detecção do reCAPTCHA operando em um ambiente completamente separado:

Your automation:
  Extracts sitekey + pageurl from target page
      ↓
  Sends to CaptchaAI API (HTTPS request to ocr.captchaai.com)
      ↓
CaptchaAI's solver environment:
  ├─ Real browser with genuine sinal de navegador (not headless)
  ├─ Human-like behavioral patterns
  ├─ Clean residential IP
  ├─ Valid cookies and session history
  ├─ Matching TLS/header sinal de navegadors
  └─ Solves the challenge with human-like behavior
      ↓
  Returns valid g-recaptcha-response token
      ↓
Your automation:
  Submits token to target website
      ↓
Target website validates token with Google
  → Google sees a legitimate solve from a trusted environment
  → Token validated: success = true

Informações importantes: Sua automação nunca interage diretamente com o reCAPTCHA. O solucionador lida com todas as impressões digitais, análises comportamentais e conclusão de desafios em um ambiente otimizado para passar por todas as camadas de detecção. Seu código só precisa enviar o token resultante.

Exemplo de Python

import requests
import time

API_KEY = "YOUR_API_KEY"

# Your automation only needs sitekey and pageurl
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": "6LcR_RsTAAAAAN_r0GEkGBfq3L7KmU5JbPHJtwNp",
    "pageurl": "https://staging.example.com/qa-login",
    "json": 1,
})

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

# Poll for token
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"]
        # Submit this token to the target site's form
        print("Token received — submit to target form")
        break

Exemplo de Node.js.

const axios = require("axios");

async function solveRecaptcha(sitekey, pageurl) {
    const API_KEY = "YOUR_API_KEY";

    const { data: submit } = await axios.post(
        "https://ocr.captchaai.com/in.php",
        new URLSearchParams({
            key: API_KEY,
            method: "userrecaptcha",
            googlekey: sitekey,
            pageurl: pageurl,
            json: 1,
        })
    );

    const taskId = submit.request;

    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("Timeout");
}

Perguntas frequentes

O reCAPTCHA pode detectar que um solucionador de API foi usado?

O reCAPTCHA valida o token em relação aos seus próprios registros. Se o ambiente do solucionador produziu uma solução legítima com comportamento semelhante ao humano, o token é válido. O Google vê uma solução humana normal, não um serviço de terceiros. O token em si não contém informações sobre como foi gerado.

O uso do Selenium sempre aciona a detecção do reCAPTCHA?

O Selenium padrão com ChromeDriver padrão é detectado imediatamente devido a sinal de navegador automatizado = true, APIs do Chrome ausentes e cabeçalhos HTTP do ChromeDriver. Selenium configurado controle de QAmente (chromedriver não detectado, plug-ins controle de QAs) pode reduzir a detecção, mas não a elimina. A solução baseada em API evita totalmente o problema ao não interagir com o reCAPTCHA em seu navegador.

Com que rapidez o reCAPTCHA atualiza seus métodos de detecção?

O Google atualiza continuamente a heurística de detecção do reCAPTCHA. As principais atualizações ocorrem a cada poucos meses. Novos métodos de detecção de navegador headless normalmente são implantados semanas após o lançamento de uma nova ferramenta de automação. Os serviços de resolução de API como o CaptchaAI adaptam-se imediatamente a essas mudanças porque mantêm seus próprios ambientes de resolução otimizados.

O reCAPTCHA compartilha dados de detecção entre sites?

Sim. A análise de risco do reCAPTCHA incorpora sinais entre sites por meio do cookie _GRECAPTCHA e da inteligência do servidor do Google. O mau comportamento em um site protegido por reCAPTCHA pode diminuir a pontuação em outros sites que usam o mesmo perfil de navegador.

Resumo

O reCAPTCHA detecta automação por meio de cinco camadas: sondagem do ambiente JavaScript (detecção modo headless), sinal de navegador canvas/WebGL, análise comportamental (mouse, teclado, rolagem), reputação da rede/IP e inteligência de sessão cruzada. Solucionadores baseados em API, comoCaptchaAIlide com todas as cinco camadas resolvendo desafios em um ambiente separado e otimizado e retornando um token válido. Seu código de automação nunca interage diretamente com o reCAPTCHA, tornando-o invisível para o sistema de detecção.

Artigos relacionados

• Como resolver o retorno de chamada do Recaptcha V2 usando API
• Torniquete Recaptcha V2 no mesmo local
• Aprofundamento da API de avaliação empresarial do Recaptcha