Headless vs Headed Chrome para resolução de CAPTCHA

O Headless Chrome é executado sem janela visível: rápido, leve e perfeito para servidores. Mas os sistemas CAPTCHA detectam ativamente o modo headless. Veja como escolher o modo certo e resolver CAPTCHAs em ambos.

Comparação Rápida

Como os CAPTCHAs detectam o Headless Chrome

Sinais de Detecção

// Tests that CAPTCHA systems run

// 1. WebDriver flag (biggest tell)
sinal de navegador automatizado  // true in headless, undefined in real browser

// 2. Chrome object completeness
window.chrome        // Missing or incomplete in headless

// 3. Plugins
navigator.plugins.length  // 0 in headless, 3+ in headed

// 4. WebGL renderer
// Headless: "SwiftShader Renderer"
// Headed:   "ANGLE (NVIDIA GeForce GTX 1080...)"

// 5. User-Agent contains "Headless"
navigator.userAgent.includes("Headless")  // Old Chrome versions

// 6. Screen dimensions
screen.width === 0   // Some headless configs

// 7. Notification permission
Notification.permission  // "denied" in headless without override

Resultados do teste de detecção

Signal               Headed    Headless   New Headless (v112+)
─────────────────────────────────────────────────────────────
webdriver            false     true       true
chrome object        full      partial    improved
plugins              5         0          0
WebGL renderer       ANGLE     Swift      Swift
screen.width         1920      800        800
UA "HeadlessChrome"  no        yes        no (removed)

Modo “Novo Headless” do Chrome (v112+)

O Chrome 112+ introduziu o --headless=new, que usa a mesma base de código do Chrome:

from selenium import webdriver

# Old headless (more detectable)
options = webdriver.ChromeOptions()
options.add_argument("--headless")  # Legacy mode

# New headless (less detectable)
options = webdriver.ChromeOptions()
options.add_argument("--headless=new")  # Shares headed rendering

driver = webdriver.Chrome(options=options)

O novo modo headless corrige alguns vetores de detecção, mas ainda expõe sinal de navegador automatizado e não possui plugins.

modo headless + CaptchaAI (Python)

CaptchaAI funciona igualmente bem no modo headless porque resolve CAPTCHAs no lado do servidor - o modo navegador não afeta a API de resolução:

import requests
import time
from selenium import webdriver
from selenium.webdriver.common.by import By

API_KEY = "YOUR_API_KEY"
API_URL = "https://ocr.captchaai.com"


def create_headless_driver():
    options = webdriver.ChromeOptions()
    options.add_argument("--headless=new")
    options.add_argument("--no-sandbox")
    options.add_argument("--disable-blink-features=AutomationControlled")
    options.add_argument("--window-size=1920,1080")
    options.add_argument(
        "--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
    )
    return webdriver.Chrome(options=options)


def solve_captcha(site_url, sitekey):
    resp = requests.post(f"{API_URL}/in.php", data={
        "key": API_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": site_url,
        "json": 1,
    })
    task_id = resp.json()["request"]

    for _ in range(60):
        time.sleep(5)
        resp = requests.get(f"{API_URL}/res.php", params={
            "key": API_KEY, "action": "get",
            "id": task_id, "json": 1,
        })
        data = resp.json()
        if data["request"] != "CAPCHA_NOT_READY":
            return data["request"]

    raise TimeoutError("Solve timeout")


# Full headless workflow
driver = create_headless_driver()

try:
    driver.get("https://example.com/form")
    time.sleep(2)

    sitekey = driver.execute_script(
        "return document.querySelector('[data-sitekey]')?.getAttribute('data-sitekey')"
    )

    if sitekey:
        token = solve_captcha(driver.current_url, sitekey)
        driver.execute_script(f"""
            document.querySelector('#g-recaptcha-response').value = '{token}';
        """)
        driver.find_element(By.CSS_SELECTOR, "form").submit()

finally:
    driver.quit()

Dirigido em servidores (exibição virtual)

Execute o Chrome em servidores headless usando Xvfb:

Linux com Xvfb

# Install
sudo apt-get install xvfb

# Run with virtual display
xvfb-run --auto-servernum --server-args="-screen 0 1920x1080x24" python script.py

Python com PyVirtualDisplay

from pyvirtualdisplay import Display
from selenium import webdriver

display = Display(visible=0, size=(1920, 1080))
display.start()

options = webdriver.ChromeOptions()
# No --headless flag = headed mode in virtual display
options.add_argument("--no-sandbox")
options.add_argument("--window-size=1920,1080")

driver = webdriver.Chrome(options=options)
# Now runs headed Chrome with real rendering, but no physical display

Docker com Xvfb

FROM python:3.12-slim

RUN apt-get update && apt-get install -y \
    xvfb \
    chromium \
    chromium-driver \
    && rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . /app
WORKDIR /app

CMD ["xvfb-run", "--auto-servernum", "python", "main.py"]

Patches modo headless + controle de QAs (Node.js)

const puppeteer = require("puppeteer-extra");
const QaPlugin = require("configuração padrão do Puppeteer");

puppeteer.use(QaPlugin());

async function headlessStealth() {
  const browser = await puppeteer.launch({
    headless: "new",
    args: [
      "--no-sandbox",
      "--window-size=1920,1080",
      "--disable-blink-features=AutomationControlled",
    ],
  });

  const page = await browser.newPage();
  await page.setViewport({ width: 1920, height: 1080 });

  // Additional QA de navegador patches
  await page.evaluateOnNewDocument(() => {
    Object.defineProperty(navigator, "webdriver", {
      get: () => undefined,
    });

    Object.defineProperty(navigator, "plugins", {
      get: () => [1, 2, 3, 4, 5],
    });
  });

  await page.goto("https://example.com/form");

  // Detect and solve CAPTCHA with CaptchaAI
  const sitekey = await page.evaluate(() =>
    document.querySelector("[data-sitekey]")?.getAttribute("data-sitekey")
  );

  if (sitekey) {
    // Call CaptchaAI API (see other guides for full implementation)
    const token = await solveCaptchaAI(page.url(), sitekey);

    await page.evaluate((t) => {
      document.querySelector("#g-recaptcha-response").value = t;
    }, token);
  }

  await browser.close();
}

Quando usar cada modo

Use modo headless quando:

• Rodando em servidores/CI sem display
• Escalando para mais de 50 sessões simultâneas
• A memória é limitada
• CaptchaAI lida com todas as soluções de CAPTCHA (modo navegador irrelevante)

Use o cabeçalho quando:

• Depurando fluxos CAPTCHA visualmente
• As pontuações de reCAPTCHA v3 são importantes (pontuações mais altas em cabeçadas)
• O site de destino bloqueia especificamente o headless
• Executando em máquinas com monitores

Use Headed + Virtual Display quando:

• Precisa de resistência à detecção de nível de cabeçalho em servidores
• reCAPTCHA v3 dá pontuações baixas em headless
• O orçamento permite memória extra (~2x por sessão)

Referências de desempenho

Informação principal: As taxas de resolução do CaptchaAI são idênticas, independentemente do modo do navegador. O modo afeta apenas a frequência com que os CAPTCHAs aparecem e as pontuações reCAPTCHA v3.

Solução de problemas

Perguntas frequentes

CaptchaAI se importa se eu uso modo headless ou modo headless?

CaptchaAI resolve CAPTCHAs no lado do servidor usando a chave do site e o URL. O modo navegador não afeta a resolução.

O novo modo modo headless (--headless=new) está protegido contra detecção?

É mais adequado do que o antigo modo headless, mas ainda detectável. Os sites que verificam sinal de navegador automatizado ou a contagem de plug-ins ainda o sinalizarão.

Posso obter pontuações reCAPTCHA v3 acima de 0,7 em headless?

Raramente. O modo Headless produz sinais semelhantes aos de um bot. Use head + Xvfb para pontuações mais altas ou use a resolução v3 do CaptchaAI, que retorna tokens de pontuação mais alta.

Devo investir em patches controle de QAs ou apenas usar o CaptchaAI?

Ambos. QA de navegador reduz a frequência do CAPTCHA (menos soluções = menor custo). CaptchaAI lida com os CAPTCHAs que ainda aparecem.

Guias Relacionados

• sinal de navegador do navegador e CAPTCHA
• Puppeteer controle de QA + CaptchaAI
• Protocolo Chrome DevTools + CaptchaAI

Escolha o modo de navegador correto para o seu fluxo de trabalho CAPTCHA —obtenha sua chave CaptchaAIe resolva CAPTCHAs em qualquer configuração.