Integrações

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

Python Cloudflare Turnstile reCAPTCHA v2 Cloudflare Challenge Proxies
Por Equipe CaptchaAI Brasil
Publicado em May 06, 2026
Bright Data + CaptchaAI: Guia completo de integração de proxy
Imagem em destaque indisponível

Bright Data (anteriormente Luminati) fornece a maior rede proxy - mais de 72 milhões de IPs residenciais em 195 países. Combinado com CaptchaAI, você obtém IPs limpos para navegação, além de solução automatizada de CAPTCHA quando surgem desafios.

Arquitetura

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

CaptchaAI não roteia através do seu proxy – ele resolve no lado do servidor usando sua própria infraestrutura. Seu proxy cuida da navegação; CaptchaAI lida com os CAPTCHAs.

Tipos de proxy de dados brilhantes

Tipo IPs Velocidade Custo Taxa CAPTCHA
Centro de dados 770K+ Rápido Baixo Superior
Residencial Mais de 72 milhões Médio Médio Inferior
ISP Mais de 700 mil Rápido Alto Mais baixo
Celular Mais de 7 milhões Lento Alto Muito baixo

Integração Python

Solicitações + Dados Bright + CaptchaAI

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")

Selênio + Dados Brilhantes + CaptchaAI

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 específica por país

Bright Data oferece suporte à segmentação por país, estado e cidade:

# 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

Gerenciamento de sessão

# 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 de trabalho CAPTCHA: Use sessões fixas. O token CAPTCHA está vinculado ao IP que carregou a página – usar um IP diferente para envio falhará.

Integração Node.js.

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 de zona de dados brilhante

Configuração de zona Recomendado para CAPTCHA Por que
Tipo de proxy Residencial Menor taxa de disparo de CAPTCHA
Segmentação por país Corresponder ao local do site de destino IP → consistência de conteúdo
Tipo de sessão Pegajoso O token deve corresponder ao IP de origem
Filtro de qualidade IP Alta qualidade Evite IPs sinalizados
Máximo simultâneo Mais de 100 Fluxos de trabalho CAPTCHA paralelos

Solução de problemas

Problema Causa Correção
407 do proxy Credenciais erradas Verifique o ID do cliente, zona e senha
CAPTCHA aparece a cada solicitação Proxy do datacenter detectado Mudar para zona residencial
Token rejeitado IP alterado entre resolver e enviar Use sessões fixas
Resposta lenta Nó de saída congestionado Segmentar país menos popular/city
Conexão recusada Limite de largura de banda atingido Verifique o painel Bright Data

Perguntas frequentes

CaptchaAI usa meu proxy Bright Data?

Não. CaptchaAI resolve CAPTCHAs utilizando infraestrutura própria. Seu proxy é usado apenas para navegação. Você passa o URL da página e a chave do site para a API do CaptchaAI.

Qual zona Bright Data funciona mais adequado para sites com muito CAPTCHA?

Zonas residenciais ou ISP. Os IPs do datacenter têm maior probabilidade de acionar CAPTCHAs. Os proxies do ISP combinam a velocidade do datacenter com a confiança residencial.

Devo usar sessões fixas ou rotativas?

Fixo para fluxos de trabalho CAPTCHA. O token CAPTCHA é vinculado ao IP – se o seu IP alternar entre o carregamento da página e o envio do formulário, o token será rejeitado.

Posso passar meu proxy para CaptchaAI?

Sim — a API do CaptchaAI aceita um parâmetro proxy. Isso faz com que CaptchaAI resolva o CAPTCHA do mesmo IP. Útil para desafios vinculados a IP.

Guias Relacionados

Combine a rede proxy da Bright Data com solução automatizada de CAPTCHA -obtenha sua chave CaptchaAIe dimensione sua automação.

Os comentários estão desativados para este artigo.