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

Por que uma automação passa liso no Selenium local e cai direto em pontuação 0,1 assim que vai para produção? O reCAPTCHA nunca depende só da caixa de seleção ou do desafio de imagem: ele cruza cinco camadas de sinal — ambiente JavaScript, sinal do navegador, comportamento, rede e histórico entre sessões — muito antes de qualquer desafio aparecer na tela. Este guia detalha as cinco camadas e mostra por que um solucionador via API, como a CaptchaAI, nem chega a acionar a maioria delas.

Resposta direta:

• ambiente JavaScript e sinal do navegador (canvas/WebGL);
• comportamento do usuário e reputação de rede/IP;
• histórico entre sessões e sites.

Camada 1: o que o JavaScript do reCAPTCHA verifica antes do clique

Assim que o script carrega, o reCAPTCHA roda uma bateria de testes em JavaScript para flagar navegadores headless e frameworks de automação — antes de qualquer interação do usuário.

O que essa camada confere, em ordem:

• presença do sinal de automação exposto pelo navegador e das APIs do Chrome real;
• sinais de adulteração em funções nativas do navegador.

A checagem do sinal de automação do navegador

É o sinal mais direto de automação — o primeiro que o reCAPTCHA confere.

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

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

Quando esse sinal indica automação, o reCAPTCHA marca a sessão na hora — geralmente com pontuação 0,1 ou menor.

As APIs que um Chrome headless não replica direito

O reCAPTCHA sonda um conjunto de APIs que navegadores headless costumam pular ou implementar de forma incompleta:

// 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 da cadeia de protótipos

Ferramentas mais sofisticadas sobrescrevem APIs do navegador para esconder a própria presença — é isso que o reCAPTCHA testa:

// 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] }"

Essas três checagens já derrubam boa parte das automações antes de qualquer clique no CAPTCHA.

Camada 2: o sinal do navegador via canvas e WebGL

Sinal do navegador via canvas

O reCAPTCHA desenha elementos ocultos em um <canvas> e lê de volta os dados de pixel resultantes. O resultado muda conforme sistema operacional, GPU, mecanismo de renderização de fontes e configuração 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

O que aciona o alarme: o mesmo sinal em sistemas ou navegadores diferentes indica spoofing; operações no canvas devolvendo dados uniformes ou em branco apontam ambiente headless; e um sinal que bate com o padrão conhecido de Chrome headless fecha a sinalização de automação.

Ambientes de QA que sempre rodam na mesma VM acabam repetindo esse mesmo sinal em todo teste — outro jeito de cair na regra acima.

Sinal do navegador via 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 por software do Google, usado quando não há GPU de hardware — indicador quase certo de ambiente headless.

Camada 3: como o reCAPTCHA lê o seu comportamento

É a camada mais difícil de simular de forma convincente. O reCAPTCHA acompanha o comportamento do usuário do carregamento da página até o envio do formulário — mouse, teclado e ritmo de interação.

Nesta camada, o reCAPTCHA cruza três sinais:

• ritmo e trajetória do mouse;
• cadência de digitação no teclado;
• tempo entre o carregamento da página e cada interação.

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 4: reputação de IP e de rede

O banco de reputação de IP do Google

O Google mantém uma base extensa de inteligência sobre IPs:

Na prática, para QA a partir do Brasil: workers longe do tráfego real — fora de sa-east-1 na AWS — somam sinais de salto geográfico, mesmo sem disfarce algum.

Sinal do navegador via TLS (JA3/JA4)

Cada cliente HTTP deixa uma marca própria no handshake TLS, resumida no hash 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 confere se esse sinal bate com o User-Agent declarado — Chrome anunciado com sinal de Python cai direto na automação.

O que os cabeçalhos HTTP entregam

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 5: inteligência entre sessões e sites

O reCAPTCHA cruza padrões observados em várias sessões e domínios diferentes.

1. Correlação de sinal entre sessões: o mesmo sinal de navegador disparando requisições rápidas em vários sites ao mesmo tempo;
2. Padrão de tempo de resolução: respostas corretas em janelas de tempo regulares demais — o tempo humano varia;
3. Correlação entre desafios: várias sessões resolvendo o mesmo desafio em poucos segundos;
4. Histórico de cookies: sessões novas repetidas vindas do mesmo IP, sem nenhuma persistência de cookie.

Como um solucionador via API responde às cinco camadas

Um solucionador via API, como a CaptchaAI, não tenta enganar as cinco camadas dentro do seu navegador — ele resolve o desafio em um ambiente totalmente separado, que já nasce limpo em cada uma delas:

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

Por que isso importa: sua automação nunca chega a tocar no reCAPTCHA — é o ambiente do solucionador que carrega o sinal de navegador, o comportamento e a resolução do desafio. Seu código só precisa enviar o token que ele devolve.

Na prática, isso significa:

• zero simulação de mouse ou teclado do seu lado;
• nenhum ajuste de sinal de navegador no seu código.

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

Perguntas que aparecem toda semana em integrações de reCAPTCHA com solucionador via API:

A região do servidor (ex.: sa-east-1 na AWS) muda a pontuação do reCAPTCHA?

Indiretamente, sim — é a mesma reputação de IP e geolocalização da Camada 4. Quem resolve via API não precisa se preocupar com isso: o ambiente do solucionador já usa IP residencial próprio.

O reCAPTCHA consegue identificar que o token veio de um solucionador via API?

Não pelo token em si. Ele é validado contra o histórico do ambiente que o gerou — se esse ambiente parecia humano, o Google não vê diferença.

Rodar Selenium puro, sem nenhum ajuste, já basta para cair na Camada 1?

Sim. O ChromeDriver padrão já expõe o sinal de automação do navegador e envia cabeçalhos HTTP característicos, o que já é suficiente para a sinalização. Ajustes reduzem parte da detecção, mas resolver via API evita o problema por completo.

Depois de receber o token da API, ainda preciso simular clique no desafio visual?

Não. O token g-recaptcha-response já é a resposta final — basta enviá-lo no campo correspondente do formulário.

O reCAPTCHA v3 usa as mesmas cinco camadas que o v2?

Sim, a base de sinal de navegador e comportamento é compartilhada entre as versões. A diferença é que o v3 não mostra desafio: devolve só uma pontuação de 0 a 1 e deixa a decisão para o site que o implementou.

Resumo

As cinco camadas do reCAPTCHA atuam juntas, não isoladas:

1. ambiente JavaScript (detecção de headless);
2. sinal de navegador via canvas/WebGL;
3. comportamento do usuário (mouse, teclado, rolagem);
4. reputação de rede/IP;
5. inteligência entre sessões e sites.

Um solucionador via API como a CaptchaAI resolve o desafio em um ambiente próprio, já limpo nas cinco camadas, e devolve um token válido pronto para o seu formulário. Como o código da sua automação nunca interage com o reCAPTCHA diretamente, ele simplesmente não aparece para o sistema de detecção.

Artigos relacionados

1. Como resolver o callback do reCAPTCHA v2 pela API
2. reCAPTCHA v2 e Cloudflare Turnstile no mesmo site: como lidar com os dois
3. Guia da API de avaliação do reCAPTCHA Enterprise