Bright Data + CaptchaAI: Proxy-Integration

Bright Data (ehemals Luminati) bietet das größte Proxy-Netzwerk – mehr als 72 Millionen private IPs in 195 Ländern. In Kombination mit CaptchaAI erhalten Sie saubere IPs zum Surfen sowie automatische CAPTCHA-Lösung, wenn Herausforderungen auftreten.

Architektur

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

CaptchaAI leitet nicht über Ihren Proxy weiter – es löst serverseitig mithilfe seiner eigenen Infrastruktur. Ihr Proxy übernimmt das Browsen; CaptchaAI kümmert sich um die CAPTCHAs.

Bright Data Proxy-Typen

Typ	IPs	Geschwindigkeit	Kosten	CAPTCHA-Rate
Rechenzentrum	770K+	Schnell	Niedrig	Höher
Wohnbereich	72M+	Mittel	Mittel	Niedriger
ISP	700K+	Schnell	Hoch	Am niedrigsten
Mobil	7M+	Langsam	Hoch	Sehr niedrig

Python-Integration

Anfragen + Bright Data + 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")

Selen + Bright Data + 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()

Länderspezifisches Targeting

Bright Data unterstützt die Ausrichtung auf Länder, Bundesstaaten und Städte:

# 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

Sitzungsverwaltung

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

Für CAPTCHA-Workflows: Verwenden Sie Sticky Sessions. Das CAPTCHA-Token ist an die IP gebunden, die die Seite geladen hat – die Verwendung einer anderen IP für die Übermittlung schlägt fehl.

Node.js-Integration

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

Bright Data Zone-Konfiguration

Zoneneinstellung	Empfohlen für CAPTCHA	Warum
Proxy-Typ	Wohnen	Niedrigste CAPTCHA-Triggerrate
Länder-Targeting	Passen Sie den Zielstandort an	IP – Inhaltskonsistenz
Sitzungstyp	Klebrig	Das Token muss mit der Ursprungs-IP übereinstimmen
IP-Qualitätsfilter	Hohe Qualität	Vermeiden Sie markierte IPs
Maximal gleichzeitig	100+	Parallele CAPTCHA-Workflows

Fehlerbehebung

Problem	Ursache	Lösung
407 vom Proxy	Falsche Anmeldeinformationen	Überprüfen Sie Kunden-ID, Zone und Passwort
CAPTCHA erscheint bei jeder Anfrage	Rechenzentrums-Proxy erkannt	Wechseln Sie in die Wohnzone
Token abgelehnt	IP hat sich zwischen Lösen und Senden geändert	Verwenden Sie Sticky Sessions
Langsame Reaktion	Überlasteter Ausgangsknoten	Zielen Sie auf ein weniger beliebtes Land/city
Verbindung abgelehnt	Bandbreitenlimit erreicht	Überprüfen Sie das Bright Data-Dashboard

FAQ

Verwendet CaptchaAI meinen Bright Data-Proxy?

Nein. CaptchaAI löst CAPTCHAs mithilfe seiner eigenen Infrastruktur. Ihr Proxy wird nur zum Surfen verwendet. Sie übergeben die Seiten-URL und den Sitekey an die API von CaptchaAI.

Welche Bright Data-Zone eignet sich am besten für CAPTCHA-lastige Websites?

Wohn- oder ISP-Zonen. Rechenzentrums-IPs lösen mit größerer Wahrscheinlichkeit CAPTCHAs aus. ISP-Proxys vereinen Rechenzentrumsgeschwindigkeit mit privatem Vertrauen.

Sollte ich Sticky- oder Rotationssitzungen verwenden?

Sticky für CAPTCHA-Workflows. Das CAPTCHA-Token ist IP-gebunden – wenn Ihre IP zwischen dem Laden der Seite und dem Absenden des Formulars wechselt, wird das Token abgelehnt.

Kann ich meinen Proxy an CaptchaAI übergeben?

Ja – die API von CaptchaAI akzeptiert einen proxy-Parameter. Dadurch löst CaptchaAI das CAPTCHA von derselben IP aus. Nützlich für IP-gebundene Herausforderungen.

Bright Data + CaptchaAI: Vollständiger Leitfaden zur Proxy-Integration