Smartproxy + CaptchaAI: Residential-Proxy-Setup zur CAPTCHA-Lösung

Saubere Residential-IPs senken die Häufigkeit, mit der eine Website überhaupt ein CAPTCHA einblendet – lösen die Abfrage aber nicht. Genau an dieser Stelle greifen zwei Bausteine ineinander: Smartproxy liefert rund 55 Millionen private IPs über ein einfaches rotierendes Gateway, CaptchaAI übernimmt die Lösung der verbleibenden Abfragen. Dieser Leitfaden verbindet beide in drei Umgebungen und deckt dabei folgende Punkte ab:

• Anfragen über den Proxy in Python, Selenium und Node.js
• Sticky Sessions, damit dieselbe IP den gesamten Ablauf trägt
• Länder-Targeting für regionale Inhalte
• eine parallele Scraping-Pipeline für größere Mengen

Ein Hinweis vorab für den DACH-Kontext: IP-Adressen gelten unter der DSGVO als personenbezogene Daten. Prüfen Sie für jeden Scraping- oder Proxy-Workflow die Rechtsgrundlage und Ihre Datenflüsse, und arbeiten Sie in eigenen oder ausdrücklich freigegebenen Umgebungen. Die Preise von CaptchaAI und Smartproxy werden in US-Dollar abgerechnet.

Smartproxy-Proxy-Typen im Überblick

Welcher Pool passt, hängt vom Workflow ab. Für CAPTCHA-lastige Ziele sind Residential- und Mobil-IPs die ruhigste Wahl, weil sie seltener eine Abfrage auslösen.

Praxisbeispiel: Wer eine DACH-Preisvergleichsseite in der eigenen Staging-Umgebung testet, kombiniert Residential-IPs mit deutschem Länder-Targeting (-country-de), damit die ausgelieferte Seite der Region entspricht. Die CAPTCHA-Abfrage, die dabei auftritt, geht an CaptchaAI – der Proxy bleibt für den Seitenaufruf zuständig.

Einrichtung in Python

Anfragen über den Proxy

Der Einstieg ist ein einfaches Request-Setup: Benutzername, Passwort und das Gateway von Smartproxy bilden die Proxy-URL. Die Funktion solve_captcha übermittelt die Abfrage an CaptchaAI und fragt anschließend das Ergebnis im 5-Sekunden-Takt ab (Polling).

import requests
import time

SMARTPROXY_USER = "spuser"
SMARTPROXY_PASS = "sppassword"
SMARTPROXY_HOST = "gate.smartproxy.com"
SMARTPROXY_PORT = 10001

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

proxies = {
    "http": f"http://{SMARTPROXY_USER}:{SMARTPROXY_PASS}@{SMARTPROXY_HOST}:{SMARTPROXY_PORT}",
    "https": f"http://{SMARTPROXY_USER}:{SMARTPROXY_PASS}@{SMARTPROXY_HOST}:{SMARTPROXY_PORT}",
}


def fetch_page(url):
    return requests.get(url, proxies=proxies, timeout=30)


def solve_captcha(site_url, sitekey, captcha_type="recaptcha_v2"):
    submit_data = {
        "key": CAPTCHAAI_KEY,
        "pageurl": site_url,
        "json": 1,
    }

    if captcha_type == "turnstile":
        submit_data["method"] = "turnstile"
        submit_data["sitekey"] = sitekey
    else:
        submit_data["method"] = "userrecaptcha"
        submit_data["googlekey"] = sitekey

    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data=submit_data)
    data = resp.json()
    if data["status"] != 1:
        raise Exception(f"Submit failed: {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")

Sticky Sessions: dieselbe IP für den gesamten Ablauf

Der häufigste Grund für ein abgelehntes Token ist ein IP-Wechsel zwischen Seitenaufruf und Absenden. Eine Sticky Session hält dieselbe IP für eine festgelegte Dauer. Der typische Ablauf sieht so aus:

1. Seite über die Sticky-IP laden
2. Sitekey auslesen und an CaptchaAI übergeben
3. gelöstes Token über dieselbe IP absenden

import random
import string


def get_sticky_proxy(session_duration_minutes=10):
    """Create a sticky session proxy (same IP for duration)."""
    session_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=8))

    proxy_url = (
        f"http://{SMARTPROXY_USER}"
        f"-session-{session_id}"
        f"-sessionduration-{session_duration_minutes}"
        f":{SMARTPROXY_PASS}@{SMARTPROXY_HOST}:{SMARTPROXY_PORT}"
    )

    return {"http": proxy_url, "https": proxy_url}


# Use same IP for entire CAPTCHA workflow
sticky = get_sticky_proxy(session_duration_minutes=10)

# Page load
resp = requests.get("https://target.com/form", proxies=sticky)

# Solve CAPTCHA
token = solve_captcha("https://target.com/form", "SITEKEY_HERE")

# Submit with same IP
resp = requests.post(
    "https://target.com/submit",
    data={"g-recaptcha-response": token},
    proxies=sticky,
)

Länder-Targeting

Smartproxy steuert das Herkunftsland über einen Zusatz im Benutzernamen. Das ist nützlich, wenn eine Seite regionale Inhalte ausliefert und Ihr Test die passende Region abbilden soll.

# Smartproxy country targeting via username
def get_country_proxy(country_code):
    proxy_url = (
        f"http://{SMARTPROXY_USER}"
        f"-country-{country_code}"
        f":{SMARTPROXY_PASS}@{SMARTPROXY_HOST}:{SMARTPROXY_PORT}"
    )
    return {"http": proxy_url, "https": proxy_url}

# US proxy
us_proxy = get_country_proxy("us")

# UK proxy
uk_proxy = get_country_proxy("gb")

# Germany proxy
de_proxy = get_country_proxy("de")

Selenium-Integration

Für browserbasierte Abläufe erzeugt create_smartproxy_driver einen Chrome-Treiber mit Smartproxy-Konfiguration; scrape_with_captcha liest den Sitekey aus der Seite, lässt CaptchaAI lösen und trägt das Token in das Formularfeld ein. Für authentifizierte Proxys nutzen Sie Selenium Wire oder eine Erweiterung.

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


def create_smartproxy_driver(country=None, sticky_session=None):
    proxy_user = SMARTPROXY_USER
    if country:
        proxy_user += f"-country-{country}"
    if sticky_session:
        proxy_user += f"-session-{sticky_session}"

    proxy_url = f"{proxy_user}:{SMARTPROXY_PASS}@{SMARTPROXY_HOST}:{SMARTPROXY_PORT}"

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

    # For authenticated proxies, use seleniumwire or extension
    return webdriver.Chrome(options=options)


def scrape_with_captcha(url, country="us"):
    session_id = "".join(random.choices(string.ascii_lowercase, k=8))
    driver = create_smartproxy_driver(country=country, sticky_session=session_id)

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

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

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

        return driver.page_source

    finally:
        driver.quit()

Node.js-Integration

In Node.js übernimmt ein HttpsProxyAgent die Smartproxy-Verbindung. Die Seite wird über den Proxy geladen, die CAPTCHA-Lösung läuft direkt gegen CaptchaAI – ein eigener Proxy ist dafür nicht nötig.

const axios = require("axios");
const HttpsProxyAgent = require("https-proxy-agent");

const CAPTCHAAI_KEY = "YOUR_API_KEY";

function getSmartproxyAgent(options = {}) {
  let user = "spuser";
  if (options.country) user += `-country-${options.country}`;
  if (options.session) user += `-session-${options.session}`;

  return new HttpsProxyAgent(
    `http://${user}:sppassword@gate.smartproxy.com:10001`
  );
}

async function scrapeWithCaptcha(url, sitekey) {
  const agent = getSmartproxyAgent({
    country: "us",
    session: `sess-${Date.now()}`,
  });

  // Fetch page through proxy
  const pageResp = await axios.get(url, { httpsAgent: agent });

  // Solve CAPTCHA via CaptchaAI (no proxy needed)
  const submitResp = await axios.post(
    "https://ocr.captchaai.com/in.php",
    null,
    {
      params: {
        key: CAPTCHAAI_KEY,
        method: "userrecaptcha",
        googlekey: sitekey,
        pageurl: url,
        json: 1,
      },
    }
  );

  const taskId = submitResp.data.request;

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

    const result = await axios.get("https://ocr.captchaai.com/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");
}

Parallele Scraping-Pipeline

Bei größeren Mengen skaliert ein ThreadPoolExecutor die Arbeit über mehrere Worker. Jede URL erhält eine eigene Sticky Session; taucht ein Sitekey auf, geht die Abfrage an CaptchaAI, andernfalls wird die Seite direkt weiterverarbeitet.

from concurrent.futures import ThreadPoolExecutor, as_completed


def process_url(url):
    session_id = "".join(random.choices(string.ascii_lowercase, k=8))
    proxy = get_sticky_proxy(10)

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

        # Check if CAPTCHA is present (simplified detection)
        if "data-sitekey" in resp.text:
            import re
            match = re.search(r'data-sitekey="([^"]+)"', resp.text)
            if match:
                sitekey = match.group(1)
                token = solve_captcha(url, sitekey)
                return {"url": url, "status": "solved", "token": token[:30]}

        return {"url": url, "status": "no_captcha"}

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


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

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

    for future in as_completed(futures):
        result = future.result()
        print(f"[{result['status']}] {result['url']}")

Wie viele Worker sinnvoll sind, richtet sich nach Ihren CaptchaAI-Threads. CaptchaAI rechnet pro gleichzeitigem Thread ab, nicht pro Lösung – der Tarif bestimmt also, wie viele Abfragen parallel laufen:

• BASIC: 15 $/Monat, 5 Threads
• STANDARD: 30 $/Monat, 15 Threads
• ADVANCE: 90 $/Monat, 50 Threads
• PREMIUM: 170 $/Monat, 100 Threads

Für sehr große Pipelines reichen die Stufen bis ENTERPRISE (300 $/Monat, 200 Threads) und darüber hinaus.

Typische Probleme und Lösungen

Häufige Fragen

Senken Residential-Proxys die CAPTCHA-Häufigkeit wirklich?

Ja, in der Regel deutlich. Rechenzentrums-IPs sind gut bekannt und lösen häufiger eine Abfrage aus; Residential- und Mobil-IPs wirken wie normale Nutzer und werden seltener herausgefordert. Die verbleibenden CAPTCHAs übernimmt CaptchaAI.

Muss CaptchaAI über denselben Proxy laufen wie mein Browser?

Nicht zwingend, aber es hilft. CaptchaAI akzeptiert einen proxy-Parameter in der Übermittlungsanfrage. Damit löst der Dienst von derselben IP aus wie Ihr Seitenaufruf – das reduziert Ablehnungen, wenn eine Seite IP und Token abgleicht.

Warum wird mein Token nach dem Lösen abgelehnt?

Fast immer, weil sich die IP zwischen Laden und Absenden geändert hat. Nutzen Sie eine Sticky Session mit ausreichender Dauer: 10 Minuten decken den Ablauf Laden → Lösen → Senden ab, bei mehrstufigen Formularen sind 30 Minuten sinnvoll.

Lässt sich das Setup DSGVO-konform betreiben?

Das hängt von Ihrem Anwendungsfall ab und liegt in Ihrer Verantwortung. IP-Adressen sind personenbezogene Daten; prüfen Sie Rechtsgrundlage, Zweckbindung und Datenflüsse und beschränken Sie Tests auf eigene oder freigegebene Umgebungen. CaptchaAI und Smartproxy sind Werkzeuge, keine Rechtsberatung.

Verwandte Leitfäden

• Bright Data + CaptchaAI einrichten
• Proxy-Authentifizierung mit CaptchaAI
• Warum Proxy-Qualität die Lösungsrate beeinflusst

Koppeln Sie das Residential-Netzwerk von Smartproxy mit CaptchaAI: Holen Sie sich Ihren API-Schlüssel und lösen Sie Ihr erstes CAPTCHA in wenigen Minuten.