Oxylabs + CaptchaAI: Datacenter-Proxy-Integration

Rechenzentrums-Proxys sind schnell und günstig – aber genau ihre gut bekannten IP-Bereiche lösen bei geschützten Zielen die meisten CAPTCHA-Abfragen aus. Sie müssen sich nicht zwischen Geschwindigkeit und Zustellrate entscheiden: Sie lassen Oxylabs die IP-Rotation übernehmen und übergeben jede auftauchende Abfrage an CaptchaAI. Dieser Leitfaden zeigt die konkrete Integration in Python – von der einfachen Anfrage über Sticky Sessions bis zur parallelen Pipeline.

Welcher Oxylabs-Proxy-Typ passt zu Ihrem Ziel?

Oxylabs deckt mit über 2 Millionen Rechenzentrums-IPs und mehr als 100 Millionen Residential-IPs ein breites Spektrum ab. Die Wahl des Produkts entscheidet, wie oft Sie überhaupt auf eine Abfrage stoßen – und damit, wie viel Arbeit an CaptchaAI weitergereicht wird.

Als Faustregel gilt: Rechenzentrum für unkritische Ziele mit hohem Durchsatz, Residential für Portale, die IP-Reputation streng prüfen. ISP-Proxys sind der Kompromiss – Residential-Vertrauen bei nahezu Rechenzentrums-Tempo.

Python-Integration: Anfrage und CAPTCHA-Lösung

Der Kern besteht aus zwei Funktionen: eine holt die Seite über den Oxylabs-Proxy, die andere übergibt einen erkannten Sitekey an CaptchaAI und fragt das Ergebnis per Polling ab. CaptchaAI arbeitet über die vertrauten Endpunkte in.php (Übermittlung) und res.php (Abholung); der zurückgegebene g-recaptcha-response-Token wandert anschließend in Ihr Formular.

import requests
import time

OXYLABS_USER = "customer-USERNAME"
OXYLABS_PASS = "PASSWORD"
OXYLABS_ENDPOINT = "pr.oxylabs.io:7777"

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

# Residential rotating proxy
proxies = {
    "http": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@{OXYLABS_ENDPOINT}",
    "https": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@{OXYLABS_ENDPOINT}",
}


def fetch_page(url, country=None):
    """Fetch page through Oxylabs proxy."""
    user = OXYLABS_USER
    if country:
        user += f"-cc-{country}"

    proxy = {
        "http": f"http://{user}:{OXYLABS_PASS}@{OXYLABS_ENDPOINT}",
        "https": f"http://{user}:{OXYLABS_PASS}@{OXYLABS_ENDPOINT}",
    }

    return requests.get(
        url,
        proxies=proxy,
        headers={
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 Chrome/126.0.0.0 Safari/537.36"
        },
        timeout=30,
    )


def solve_recaptcha(site_url, sitekey):
    """Solve 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("Timeout")

IP über eine Sitzung hinweg stabil halten

Viele geschützte Ziele erwarten, dass Formularabruf, CAPTCHA-Lösung und Absenden von derselben IP kommen. Wechselt die IP mitten im Ablauf, verwirft der Server den Token. Oxylabs bietet dafür Sticky Sessions: Über den -sessid--Parameter bleibt dieselbe IP für die Dauer der Sitzung erhalten.

def get_oxylabs_sticky_proxy(session_id, country=None):
    """Create Oxylabs sticky session (same IP)."""
    user = OXYLABS_USER + f"-sessid-{session_id}"
    if country:
        user += f"-cc-{country}"

    proxy_url = f"http://{user}:{OXYLABS_PASS}@{OXYLABS_ENDPOINT}"
    return {"http": proxy_url, "https": proxy_url}


# CAPTCHA workflow with sticky IP
import random, string
session = "".join(random.choices(string.ascii_lowercase, k=8))
proxy = get_oxylabs_sticky_proxy(session, country="us")

# All requests use the same IP
resp = requests.get("https://target.com/form", proxies=proxy)
# ... solve CAPTCHA ...
resp = requests.post("https://target.com/submit", proxies=proxy, data={
    "g-recaptcha-response": token,
})

Oxylabs Web Scraper API mit CaptchaAI kombinieren

Für Ziele, bei denen das serverseitige Rendering von Oxylabs eine CAPTCHA-Abfrage nicht selbst auflöst, rendern Sie die Seite über die Web Scraper API und übergeben einen gefundenen Sitekey an CaptchaAI. So trennen Sie sauber, was jedes Werkzeug am besten kann: Oxylabs das Abrufen und Rendern, CaptchaAI das Lösen.

def scrape_with_oxylabs_api(url):
    """Use Oxylabs Web Scraper API for rendering, CaptchaAI for CAPTCHAs."""
    resp = requests.post(
        "https://realtime.oxylabs.io/v1/queries",
        auth=(OXYLABS_USER, OXYLABS_PASS),
        json={
            "source": "universal",
            "url": url,
            "render": "html",
            "browser_instructions": [
                {"type": "wait", "wait_time_s": 3},
            ],
        },
    )

    result = resp.json()
    html = result["results"][0]["content"]

    # Check for CAPTCHA in rendered HTML
    import re
    sitekey_match = re.search(r'data-sitekey="([^"]+)"', html)

    if sitekey_match:
        sitekey = sitekey_match.group(1)
        token = solve_recaptcha(url, sitekey)
        return {"html": html, "captcha_solved": True, "token": token}

    return {"html": html, "captcha_solved": False}

Rechenzentrums- vs. Residential-Proxys pro Ziel entscheiden

Statt den Proxy-Typ global festzulegen, treffen Sie die Wahl pro Ziel. Empfindliche Seiten bekommen Residential-IPs (seltener eine Abfrage), unkritische Seiten laufen über das schnellere Rechenzentrum – und die wenigen dort ausgelösten Abfragen fängt CaptchaAI ab.

# Datacenter: Fast but higher CAPTCHA rate
DC_PROXY = {
    "http": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@dc.pr.oxylabs.io:10000",
    "https": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@dc.pr.oxylabs.io:10000",
}

# Residential: Slower but lower CAPTCHA rate
RES_PROXY = {
    "http": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@pr.oxylabs.io:7777",
    "https": f"http://{OXYLABS_USER}:{OXYLABS_PASS}@pr.oxylabs.io:7777",
}


def smart_proxy_selection(url, captcha_sensitive=True):
    """Pick proxy type based on target site sensitivity."""
    if captcha_sensitive:
        return RES_PROXY  # Less likely to trigger CAPTCHA
    return DC_PROXY  # Faster, CaptchaAI handles any CAPTCHAs

Parallele Verarbeitung mit mehreren Threads

Für Durchsatz verarbeiten Sie URLs nebenläufig. Jeder Worker bekommt eine eigene Sticky Session, damit sich die IPs nicht überschneiden.

from concurrent.futures import ThreadPoolExecutor, as_completed

def process_url(url):
    session = "".join(random.choices(string.ascii_lowercase, k=8))
    proxy = get_oxylabs_sticky_proxy(session, country="us")

    try:
        resp = requests.get(url, proxies=proxy, timeout=30)

        import re
        match = re.search(r'data-sitekey="([^"]+)"', resp.text)

        if match:
            token = solve_recaptcha(url, match.group(1))
            return {"url": url, "status": "solved"}
        return {"url": url, "status": "no_captcha"}

    except Exception as e:
        return {"url": url, "status": "error", "error": str(e)}


urls = ["https://site1.com", "https://site2.com", "https://site3.com"]

with ThreadPoolExecutor(max_workers=5) as executor:
    futures = {executor.submit(process_url, u): u for u in urls}
    for future in as_completed(futures):
        print(future.result())

Die max_workers sollten Sie an Ihr CaptchaAI-Kontingent koppeln. CaptchaAI rechnet pro gleichzeitigem Thread ab, nicht pro Lösung – jeder Plan erlaubt unbegrenzt viele Lösungen innerhalb seiner Thread-Grenze. Fünf Worker wie im Beispiel passen genau zum BASIC-Tarif (15 $/Monat, 5 Threads); für breitere Pipelines skalieren Sie über STANDARD (30 $/Monat, 15 Threads) oder ADVANCE (90 $/Monat, 50 Threads). Die aktuellen Preise stehen auf der Preisseite von captchaai.com, angegeben in US-Dollar.

Fehlerbehebung

DSGVO im Blick behalten

Für Teams im DACH-Raum ist ein Punkt wichtig: IP-Adressen gelten nach DSGVO als personenbezogene Daten. Wenn Sie Proxys für Datenextraktion einsetzen, prüfen Sie Ihre Rechtsgrundlage und dokumentieren Sie, welche Daten Sie erheben und wie lange Sie sie speichern. Für die Worker selbst eignen sich europäische Anbieter wie Hetzner oder netcup, wenn Latenz und Datenfluss innerhalb der EU bleiben sollen. Das ist Sorgfaltspflicht auf Ihrer Seite und keine Compliance-Aussage über CaptchaAI oder Oxylabs.

FAQ

Warum lösen Rechenzentrums-Proxys mehr CAPTCHAs aus als Residential-IPs?

Weil ihre IP-Bereiche öffentlich bekannt sind und zu Cloud-Anbietern gehören. Reputationssysteme stufen solchen Traffic strenger ein und zeigen häufiger eine Abfrage. Residential-IPs stammen aus echten Endkundennetzen und wirken unauffälliger – dafür sind sie langsamer und teurer.

Wie viele parallele Threads brauche ich für CaptchaAI?

So viele, wie Sie gleichzeitige Lösungen erwarten. CaptchaAI rechnet pro Thread ab, nicht pro Lösung; ein Thread verarbeitet eine Abfrage nach der anderen. Richten Sie die max_workers Ihrer Pipeline an der Thread-Zahl Ihres Tarifs aus – BASIC bietet 5, ADVANCE 50 Threads.

Kann ich Sticky Sessions und CAPTCHA-Lösung sinnvoll kombinieren?

Ja, und das ist meist sogar nötig. Halten Sie Abruf, Lösung und Absenden auf derselben IP, damit der Token nicht durch einen IP-Wechsel entwertet wird. Der -sessid--Parameter von Oxylabs hält die IP für die Sitzung stabil.

Löst CaptchaAI auch Cloudflare Turnstile über Oxylabs-Proxys?

Ja. CaptchaAI löst reCAPTCHA v2 und v3, Cloudflare Turnstile und Challenge, GeeTest v3 sowie Bild- und Raster-CAPTCHAs. Der Proxy ist dabei transparent – Sie senden Sitekey und Seiten-URL, die Wahl von Oxylabs- oder Direktverbindung ändert am Lösungsablauf nichts.

Fallen bei CaptchaAI zusätzliche Kosten pro gelöstem CAPTCHA an?

Nein. Innerhalb Ihres Plans sind die Lösungen unbegrenzt; es gibt keine Gebühr pro CAPTCHA und keinen Aufschlag je nach Typ. Sie zahlen nur für die gleichzeitigen Threads – die Oxylabs-Kosten (pro GB bzw. pro IP) rechnen Sie separat über Oxylabs ab.

Verwandte Leitfäden

• Bright Data mit CaptchaAI verbinden
• Smartproxy und CaptchaAI einrichten
• ISP- oder Rechenzentrums-Proxys für die CAPTCHA-Lösung?

Oxylabs-Proxy-Infrastruktur mit CaptchaAI kombinieren.