Bright Data + CaptchaAI: Guia completo de integração de proxy

Um proxy de qualidade reduz a frequência de CAPTCHA — não elimina. Mesmo com os mais de 72 milhões de IPs residenciais da Bright Data (antiga Luminati), parte das suas requisições ainda vai esbarrar em um reCAPTCHA ou em um desafio do Cloudflare Turnstile. A pergunta que importa não é "como evito o CAPTCHA", e sim "o que fazer quando ele aparecer, sem travar o resto da automação". Este guia separa as duas responsabilidades — a Bright Data cuida do IP de saída, a CaptchaAI resolve o desafio — com código em Python e Node.js e a zona que reduz o volume de CAPTCHA antes mesmo de chegar nesse ponto.

Como proxy e CaptchaAI dividem o trabalho

As duas ferramentas não se sobrepõem: o proxy troca o IP de saída; a CaptchaAI resolve o que aparecer depois. O fluxo:

Your Script ──▶ Bright Data Proxy ──▶ Target Site
                                          │
                                    CAPTCHA appears
                                          │
                                    CaptchaAI API ──▶ Solved token
                                          │
                            Inject token ◀─┘

A CaptchaAI não usa o seu proxy Bright Data — ela resolve pela própria infraestrutura, do lado do servidor. O proxy existe só para a navegação: carregar a página, manter a sessão, evitar que o IP do datacenter seja sinalizado. Quando o desafio aparece, você chama a API e injeta o token na página que o proxy carregou.

Tipos de proxy da Bright Data e o impacto na taxa de CAPTCHA

A escolha do proxy muda quantos CAPTCHAs você vê antes mesmo de a CaptchaAI entrar em ação. Datacenter é mais barato e mais rápido, mas dispara desafios com mais frequência:

Em sites com bastante CAPTCHA, residencial ou ISP compensam o custo mais alto: menos desafios, menos chamadas à CaptchaAI.

Integração em Python

Dois padrões cobrem a maioria dos casos: requisições diretas com requests, e Selenium quando o site só renderiza o widget do CAPTCHA depois de carregar o JavaScript da página.

Requests + Bright Data + CaptchaAI

Busca a página pelo proxy Bright Data, envia sitekey e pageurl para a CaptchaAI e faz o polling em res.php até o token voltar — uma função para reCAPTCHA v2, outra para Turnstile:

import requests
import time

CAPTCHAAI_KEY = "YOUR_API_KEY"
CAPTCHAAI_URL = "https://ocr.captchaai.com"

# Bright Data proxy credentials
BRIGHT_DATA_PROXY = {
    "http": "http://brd-customer-CUSTOMER_ID-zone-ZONE:PASSWORD@brd.superproxy.io:22225",
    "https": "http://brd-customer-CUSTOMER_ID-zone-ZONE:PASSWORD@brd.superproxy.io:22225",
}


def fetch_with_proxy(url):
    """Fetch a page through Bright Data proxy."""
    resp = requests.get(
        url,
        proxies=BRIGHT_DATA_PROXY,
        headers={
            "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"
        },
        timeout=30,
    )
    return resp


def solve_recaptcha(site_url, sitekey):
    """Solve reCAPTCHA v2 via CaptchaAI."""
    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
        "key": CAPTCHAAI_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": site_url,
        "json": 1,
    })
    data = resp.json()
    if data["status"] != 1:
        raise Exception(f"Submit: {data['request']}")

    task_id = data["request"]

    for _ in range(60):
        time.sleep(5)
        resp = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
            "key": CAPTCHAAI_KEY,
            "action": "get",
            "id": task_id,
            "json": 1,
        })
        data = resp.json()
        if data["request"] == "CAPCHA_NOT_READY":
            continue
        if data["status"] == 1:
            return data["request"]
        raise Exception(f"Solve: {data['request']}")

    raise TimeoutError("Solve timeout")


def solve_turnstile(site_url, sitekey):
    """Solve Cloudflare Turnstile via CaptchaAI."""
    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
        "key": CAPTCHAAI_KEY,
        "method": "turnstile",
        "sitekey": sitekey,
        "pageurl": site_url,
        "json": 1,
    })
    data = resp.json()
    task_id = data["request"]

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

    raise TimeoutError("Solve timeout")

Selenium + Bright Data + CaptchaAI

Quando o CAPTCHA só aparece depois da renderização completa, requests sozinho não enxerga o sitekey. Este exemplo abre o Chrome com o proxy já configurado na linha de comando, extrai o sitekey do DOM e injeta o token de volta no formulário antes de disparar o callback do reCAPTCHA:

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

BRIGHT_DATA_HOST = "brd.superproxy.io"
BRIGHT_DATA_PORT = 22225
BRIGHT_DATA_USER = "brd-customer-CUSTOMER_ID-zone-residential"
BRIGHT_DATA_PASS = "PASSWORD"


def create_driver_with_proxy():
    options = webdriver.ChromeOptions()
    options.add_argument(
        f"--proxy-server=http://{BRIGHT_DATA_HOST}:{BRIGHT_DATA_PORT}"
    )
    options.add_argument("--disable-blink-features=AutomationControlled")
    options.add_argument("--window-size=1920,1080")

    driver = webdriver.Chrome(options=options)
    return driver


def scrape_with_captcha_solving(url, sitekey=None):
    driver = create_driver_with_proxy()

    try:
        driver.get(url)
        time.sleep(3)

        # Auto-detect sitekey if not provided
        if not sitekey:
            sitekey = driver.execute_script(
                "return document.querySelector('[data-sitekey]')"
                "?.getAttribute('data-sitekey')"
            )

        if sitekey:
            token = solve_recaptcha(url, sitekey)

            driver.execute_script(f"""
                document.querySelector('#g-recaptcha-response').value = '{token}';
                document.querySelectorAll('[name="g-recaptcha-response"]')
                    .forEach(el => {{ el.value = '{token}'; }});
            """)

            # Trigger callback
            driver.execute_script("""
                if (typeof ___grecaptcha_cfg !== 'undefined') {
                    const clients = ___grecaptcha_cfg.clients;
                    for (const key in clients) {
                        for (const prop in clients[key]) {
                            const val = clients[key][prop];
                            if (val && typeof val === 'object') {
                                for (const p in val) {
                                    if (typeof val[p]?.callback === 'function') {
                                        val[p].callback(arguments[0]);
                                    }
                                }
                            }
                        }
                    }
                }
            """)

        return driver.page_source

    finally:
        driver.quit()

Segmentação por país e cidade

A Bright Data direciona o IP de saída por país, estado ou cidade. Ajuda a reduzir CAPTCHA quando o site aplica regras por geografia, e é essencial quando o conteúdo muda conforme a origem do visitante:

# Country targeting
proxy_us = "http://brd-customer-ID-zone-residential-country-us:PASS@brd.superproxy.io:22225"
proxy_uk = "http://brd-customer-ID-zone-residential-country-gb:PASS@brd.superproxy.io:22225"
proxy_de = "http://brd-customer-ID-zone-residential-country-de:PASS@brd.superproxy.io:22225"

# City targeting
proxy_nyc = "http://brd-customer-ID-zone-residential-country-us-city-newyork:PASS@brd.superproxy.io:22225"

# Use the geo-matched proxy for lower CAPTCHA rates
def scrape_localized(url, country="us"):
    proxy = f"http://brd-customer-ID-zone-residential-country-{country}:PASS@brd.superproxy.io:22225"
    resp = requests.get(url, proxies={"http": proxy, "https": proxy}, timeout=30)
    return resp

Em workers hospedados na região sa-east-1 (São Paulo) da AWS, segmentar por country-br mantém o IP coerente com a origem da infraestrutura — reduz checagens extras em sites brasileiros que desconfiam de tráfego "estrangeiro".

Sessão fixa ou rotativa: qual usar com CAPTCHA

A sessão decide se o token do CAPTCHA ainda é válido na hora de enviar o formulário:

# Sticky session (same IP for entire session)
proxy_sticky = (
    "http://brd-customer-ID-zone-residential"
    "-session-abc123:PASS@brd.superproxy.io:22225"
)

# Rotating (new IP each request)
proxy_rotating = (
    "http://brd-customer-ID-zone-residential:PASS@brd.superproxy.io:22225"
)

Para fluxos com CAPTCHA, use sessão fixa. O token fica vinculado ao IP que carregou a página — trocar de IP entre a resolução e o envio do formulário derruba o token, e não há como a CaptchaAI prever que isso vai acontecer.

Integração em Node.js

Mesma lógica em Node.js: um httpsAgent aponta para o proxy Bright Data, e o polling em res.php roda em laço assíncrono até a CaptchaAI devolver o token:

const axios = require("axios");
const https = require("https");

const CAPTCHAAI_KEY = "YOUR_API_KEY";
const CAPTCHAAI_URL = "https://ocr.captchaai.com";

const proxyAgent = new (require("https-proxy-agent"))(
  "http://brd-customer-ID-zone-residential:PASS@brd.superproxy.io:22225"
);

async function fetchWithProxy(url) {
  return axios.get(url, {
    httpsAgent: proxyAgent,
    headers: {
      "User-Agent":
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/126.0.0.0",
    },
  });
}

async function solveCaptcha(siteUrl, sitekey) {
  const submit = await axios.post(`${CAPTCHAAI_URL}/in.php`, null, {
    params: {
      key: CAPTCHAAI_KEY,
      method: "userrecaptcha",
      googlekey: sitekey,
      pageurl: siteUrl,
      json: 1,
    },
  });

  const taskId = submit.data.request;

  for (let i = 0; i < 60; i++) {
    await new Promise((r) => setTimeout(r, 5000));

    const result = await axios.get(`${CAPTCHAAI_URL}/res.php`, {
      params: {
        key: CAPTCHAAI_KEY,
        action: "get",
        id: taskId,
        json: 1,
      },
    });

    if (result.data.request === "CAPCHA_NOT_READY") continue;
    if (result.data.status === 1) return result.data.request;
  }

  throw new Error("Timeout");
}

Configuração recomendada da zona Bright Data para CAPTCHA

Configurações de zona que, na prática, mais reduzem o volume de CAPTCHA:

Erros comuns e como resolver

Problemas mais comuns ao combinar Bright Data com a CaptchaAI, e a causa raiz de cada um:

Se o pipeline registra o IP de saída em log para depurar qual zona disparou o CAPTCHA, trate esse dado como informação pessoal sob a LGPD quando puder identificar alguém, com retenção curta.

Perguntas frequentes

Preciso passar meu proxy Bright Data para a CaptchaAI resolver o CAPTCHA?

Não é obrigatório, mas ajuda em desafios vinculados a IP. A API aceita um parâmetro proxy opcional — quando você passa, a CaptchaAI resolve a partir do mesmo IP que carregou a página, em vez de usar a própria infraestrutura.

Zona residencial ou ISP: qual reduz mais o CAPTCHA?

As duas, muito à frente do datacenter. Residencial tem mais confiança por ser IP de usuário real; ISP entrega velocidade de datacenter com boa parte dessa confiança. Comece por residencial e migre para ISP se a velocidade virar problema.

Quantos workers em paralelo cabem no plano BASIC da CaptchaAI?

O BASIC (US$ 15/mês, 5 threads) permite até 5 desafios simultâneos, resoluções ilimitadas por thread. Para volumes maiores, o STANDARD (US$ 30/mês, 15 threads) e o ADVANCE (US$ 90/mês, 50 threads) escalam sem trocar de arquitetura.

O proxy Bright Data deixa a resolução da CaptchaAI mais lenta?

Não diretamente — a CaptchaAI resolve do lado dela. O que muda é o tempo até o CAPTCHA aparecer: um nó congestionado atrasa o carregamento da página, não a resolução em si.

Vale a pena logar o IP de saída para depurar CAPTCHA?

Sim. Trate esse log como dado pessoal sob a LGPD quando puder identificar alguém, com retenção curta e acesso restrito à equipe de QA.

Guias relacionados

• Como as proxies residenciais rotativas reduzem o CAPTCHA
• Como a qualidade do proxy afeta a taxa de resolução de CAPTCHA
• ISP ou datacenter: qual proxy escolher para CAPTCHA

Combine a rede de proxies da Bright Data com a resolução automática da CaptchaAI — crie sua chave de API e escale a automação sem travar em desafios.