API-Tutorials

SOCKS5-Proxy mit CaptchaAI einrichten und konfigurieren

Automatisierung Python reCAPTCHA v2 Cloudflare Turnstile Proxys
Von CaptchaAI Team Deutsch
Veröffentlicht unter May 15, 2026
SOCKS5-Proxy mit CaptchaAI einrichten und konfigurieren
Ausgewähltes Bild nicht verfügbar

Ein SOCKS5-Proxy leitet beliebigen TCP- und UDP-Verkehr weiter, ohne die einzelne Anfrage anzufassen – kein zusätzlicher Header, keine umgeschriebene Payload. Genau deshalb greifen viele Automatisierungs-Setups dazu, sobald WebSocket-Verbindungen, serverseitiges DNS oder Protokolle jenseits von HTTP ins Spiel kommen. Dieser Leitfaden zeigt die komplette Einrichtung: SOCKS5 in Python (requests und aiohttp), in Selenium, in Node.js und in Puppeteer – jeweils mit Authentifizierung – und wie Sie denselben Proxy an CaptchaAI übergeben, damit die CAPTCHA-Lösung von genau der IP kommt, über die auch Ihre restlichen Anfragen laufen.

Die Kurzfassung vorweg: requests[socks] plus PySocks reicht für einfache HTTP-Clients, Selenium und Puppeteer nehmen den Proxy als Chrome-Argument entgegen, und für authentifizierte SOCKS5-Verbindungen im Browser führt der Weg über Selenium Wire. Der wichtigste Handgriff durchzieht alle Sprachen: socks5h:// statt socks5://, damit die DNS-Auflösung auf dem Proxy und nicht lokal passiert.

SOCKS5 oder HTTP-Proxy – wann welcher?

Bevor Sie etwas konfigurieren, lohnt der Blick auf den Unterschied. Ein HTTP-Proxy versteht nur HTTP und HTTPS und kann dabei Header wie X-Forwarded-For ergänzen – ein verräterisches Signal für serverseitige Schutzmechanismen. SOCKS5 arbeitet eine Schicht tiefer, transportiert jedes TCP/UDP-Protokoll unverändert und lässt die Anfrage in Ruhe. Das ist der praktische Grund, warum SOCKS5 bei CAPTCHA-geschützten Zielen und modernen, WebSocket-lastigen Frontends die robustere Wahl ist.

Merkmal HTTP/HTTPS-Proxy SOCKS5-Proxy
Protokollunterstützung Nur HTTP/HTTPS Beliebiges TCP/UDP
Header-Änderung Kann X-Forwarded-For ergänzen Keine Änderung
Erkennung Einfacher (Header verraten den Proxy) Schwieriger
Geschwindigkeit Schnell Geringfügig langsamer
Authentifizierung Basic/Digest Benutzername/Passwort
DNS-Auflösung Client-seitig Serverseitig (SOCKS5h)
WebSocket-Unterstützung Eingeschränkt Vollständig

Kurz gesagt: HTTP-Proxys sind minimal schneller, SOCKS5 ist vielseitiger und unauffälliger. Für reine REST-Aufrufe ohne WebSocket genügt oft ein HTTP-Proxy; sobald Sitzungen, Sockets oder gemischte Protokolle dazukommen, ist SOCKS5 die stabilere Grundlage.

SOCKS5 in Python einrichten

Für einfache HTTP-Clients ist Python am schnellsten am Ziel. Installieren Sie die SOCKS-Erweiterung von requests zusammen mit PySocks:

pip install requests[socks] pysocks

Anschließend definieren Sie den Proxy einmal als Dictionary und reichen ihn bei jeder Anfrage durch. Beachten Sie das h in socks5h:// – damit übernimmt der Proxy-Server die DNS-Auflösung, und Ihre lokale Umgebung verrät den Ziel-Hostnamen nicht:

import requests
import time

SOCKS5_HOST = "proxy.example.com"
SOCKS5_PORT = 1080
SOCKS5_USER = "proxyuser"
SOCKS5_PASS = "proxypass"

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

# SOCKS5 proxy configuration
proxies = {
    "http": f"socks5h://{SOCKS5_USER}:{SOCKS5_PASS}@{SOCKS5_HOST}:{SOCKS5_PORT}",
    "https": f"socks5h://{SOCKS5_USER}:{SOCKS5_PASS}@{SOCKS5_HOST}:{SOCKS5_PORT}",
}
# socks5h = DNS resolved by proxy server (recommended)
# socks5  = DNS resolved locally


def fetch_through_socks(url):
    """Fetch URL through SOCKS5 proxy."""
    return requests.get(
        url,
        proxies=proxies,
        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_captcha(site_url, sitekey):
    """Solve CAPTCHA via CaptchaAI (direct, no proxy needed)."""
    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")


# Full workflow
resp = fetch_through_socks("https://target.com/form")

import re
match = re.search(r'data-sitekey="([^"]+)"', resp.text)
if match:
    token = solve_captcha("https://target.com/form", match.group(1))
    # Submit with token through same proxy
    resp = requests.post(
        "https://target.com/submit",
        data={"g-recaptcha-response": token},
        proxies=proxies,
    )

Der Ablauf ist bewusst zweigeteilt: Die Seite wird über den SOCKS5-Proxy geladen, der Sitekey per Regex ausgelesen und an CaptchaAI übergeben. Die reCAPTCHA-v2-Lösung liefert das Token g-recaptcha-response zurück, das Sie über denselben Proxy mit dem Formular absenden – so bleiben Abruf und Übermittlung IP-konsistent.

Asynchron mit aiohttp

Wer viele Ziele parallel abfragt, kombiniert SOCKS5 mit aiohttp und aiohttp_socks. Der ProxyConnector kapselt die Verbindung pro Session:

import aiohttp
import aiohttp_socks
import asyncio


async def fetch_async(url):
    connector = aiohttp_socks.ProxyConnector.from_url(
        f"socks5://{SOCKS5_USER}:{SOCKS5_PASS}@{SOCKS5_HOST}:{SOCKS5_PORT}"
    )

    async with aiohttp.ClientSession(connector=connector) as session:
        async with session.get(url) as resp:
            return await resp.text()


asyncio.run(fetch_async("https://target.com/form"))

SOCKS5 in Selenium nutzen

Bei einem echten Browser gibt es zwei Fälle. Ohne Authentifizierung genügt das Chrome-Argument --proxy-server=socks5://…. Für einen SOCKS5-Proxy mit Benutzername und Passwort scheitert der Kommandozeilenweg jedoch – hier übernimmt Selenium Wire die Anmeldung transparent:

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


def create_socks5_driver(host, port, username=None, password=None):
    options = webdriver.ChromeOptions()

    # SOCKS5 proxy (no auth via command line)
    options.add_argument(f"--proxy-server=socks5://{host}:{port}")

    # DNS through proxy
    options.add_argument("--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE 127.0.0.1")

    options.add_argument("--disable-blink-features=AutomationControlled")
    options.add_argument("--window-size=1920,1080")

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


# For authenticated SOCKS5, use seleniumwire
from seleniumwire import webdriver as sw_webdriver

def create_auth_socks5_driver():
    options = {
        "proxy": {
            "http": f"socks5h://{SOCKS5_USER}:{SOCKS5_PASS}@{SOCKS5_HOST}:{SOCKS5_PORT}",
            "https": f"socks5h://{SOCKS5_USER}:{SOCKS5_PASS}@{SOCKS5_HOST}:{SOCKS5_PORT}",
        }
    }

    chrome_options = sw_webdriver.ChromeOptions()
    chrome_options.add_argument("--disable-blink-features=AutomationControlled")

    return sw_webdriver.Chrome(
        seleniumwire_options=options,
        options=chrome_options,
    )


# Usage
driver = create_auth_socks5_driver()
driver.get("https://target.com/form")
time.sleep(3)

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

if sitekey:
    token = solve_captcha("https://target.com/form", sitekey)
    driver.execute_script(f"""
        document.querySelector('#g-recaptcha-response').value = '{token}';
    """)
    driver.find_element(By.CSS_SELECTOR, "form").submit()

driver.quit()

Der Sitekey wird direkt aus dem DOM gelesen, das gelöste Token in das Feld g-recaptcha-response eingetragen und das Formular abgesendet – ganz ohne Klick auf das Widget.

SOCKS5 in Node.js

Im Node.js-Ökosystem übernimmt der SocksProxyAgent die Arbeit. Sie hängen ihn als httpAgent und httpsAgent an jede axios-Anfrage. Die CaptchaAI-Aufrufe laufen bewusst nicht über den Proxy – gelöst wird zentral, nur der Ziel-Traffic geht durch SOCKS5:

const { SocksProxyAgent } = require("socks-proxy-agent");
const axios = require("axios");

const CAPTCHAAI_KEY = "YOUR_API_KEY";

const socksAgent = new SocksProxyAgent(
  "socks5h://proxyuser:proxypass@proxy.example.com:1080"
);

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

async function solveCaptcha(siteUrl, sitekey) {
  // CaptchaAI calls don't go through SOCKS proxy
  const submit = await axios.post(
    "https://ocr.captchaai.com/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("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");
}

SOCKS5 in Puppeteer

Puppeteer bekommt den Proxy beim Start als Argument, die Zugangsdaten reicht page.authenticate() nach. Nach dem Laden wird derselbe Sitekey-Lese-Lösen-Einfügen-Ablauf wie in Selenium ausgeführt:

const puppeteer = require("puppeteer");

async function launchWithSocks5() {
  const browser = await puppeteer.launch({
    args: [
      "--proxy-server=socks5://proxy.example.com:1080",
      "--no-sandbox",
      "--window-size=1920,1080",
    ],
  });

  const page = await browser.newPage();

  // Authenticate if needed
  await page.authenticate({
    username: "proxyuser",
    password: "proxypass",
  });

  await page.goto("https://target.com/form", { waitUntil: "networkidle0" });

  const sitekey = await page.evaluate(() =>
    document.querySelector("[data-sitekey]")?.getAttribute("data-sitekey")
  );

  if (sitekey) {
    const token = await solveCaptcha(page.url(), sitekey);
    await page.evaluate((t) => {
      document.querySelector("#g-recaptcha-response").value = t;
    }, token);
  }

  await browser.close();
}

Den SOCKS5-Proxy an CaptchaAI übergeben

Standardmäßig löst CaptchaAI von seiner eigenen Infrastruktur aus. Bei sensiblen Zielen, die IP-Konsistenz zwischen dem Laden der Seite und dem eingereichten Token prüfen, können Sie Ihren Proxy jedoch mit übergeben – dann löst CaptchaAI von genau Ihrer Proxy-IP. Der Parameter folgt dem Format type:host:port:user:pass, dazu proxytype=SOCKS5:

def solve_with_proxy(site_url, sitekey, proxy_url):
    """Pass proxy to CaptchaAI for IP-matched solving."""
    # Format: type:host:port:user:pass
    proxy_param = f"socks5:{SOCKS5_HOST}:{SOCKS5_PORT}:{SOCKS5_USER}:{SOCKS5_PASS}"

    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
        "key": CAPTCHAAI_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": site_url,
        "proxy": proxy_param,
        "proxytype": "SOCKS5",
        "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":
            return data["request"]

    raise TimeoutError("Timeout")

Für Cloudflare Turnstile setzen Sie stattdessen method=turnstile und lesen das Token cf-turnstile-response aus – der Proxy-Parameter bleibt identisch. Die Abrechnung ändert sich dabei nicht: CaptchaAI rechnet pro Thread ab, nicht pro Lösung – ein Thread ist eine gleichzeitig laufende CAPTCHA-Lösung, und die Zahl der Lösungen pro Thread ist im Monatstarif nicht gedeckelt.

DSGVO-Hinweis für DACH-Teams: IP-Adressen gelten nach DSGVO als personenbezogene Daten. Wenn Sie Proxys – ob bei einem Anbieter oder auf eigener Infrastruktur wie Hetzner oder IONOS – für Datenextraktion einsetzen, prüfen Sie Zweck, Rechtsgrundlage und Ihren Datenfluss, bevor Sie produktiv gehen. Das ist Sorgfaltspflicht auf Ihrer Seite, keine Compliance-Aussage über CaptchaAI.

Häufige Fehler beheben

Problem Ursache Lösung
Verbindung abgelehnt Falscher Port oder Host Prüfen Sie, ob der SOCKS5-Server läuft und erreichbar ist
DNS-Leck socks5:// statt socks5h:// verwendet socks5h:// für serverseitiges DNS nutzen
Authentifizierung fehlgeschlagen Falsche Zugangsdaten Mit curl --socks5 gegenprüfen
Langsame Verbindungen Geografisch entfernter Proxy Einen näher gelegenen Proxy wählen
WebSocket schlägt fehl SOCKS5-Server ohne UDP-Unterstützung Einen SOCKS5-Server mit UDP-Unterstützung einsetzen

Der mit Abstand häufigste Fehler ist das fehlende h: Mit socks5:// löst Ihr lokaler Rechner den Hostnamen auf, bevor der Verkehr in den Tunnel geht – der DNS-Request verrät das Ziel trotz Proxy. socks5h:// verlagert die Auflösung auf den Proxy-Server und schließt dieses Leck.

FAQ

Worin unterscheiden sich socks5:// und socks5h://?

Beim h-Suffix löst der Proxy-Server die DNS-Namen auf, ohne h Ihr lokaler Client. Nutzen Sie fast immer socks5h:// – so gelangt keine DNS-Anfrage an Ihrem Proxy vorbei und der Hostname bleibt innerhalb des Tunnels.

Unterstützt CaptchaAI SOCKS5 als Proxy-Typ?

Ja. Übergeben Sie proxytype=SOCKS5 und proxy=socks5:host:port:user:pass in Ihrer Übermittlungsanfrage, dann löst CaptchaAI die Abfrage von Ihrer Proxy-IP statt von der eigenen Infrastruktur.

Sind Proxy-IPs für DACH-Projekte DSGVO-relevant?

IP-Adressen zählen zu den personenbezogenen Daten. Beim Web-Scraping über Proxys sollten Sie Zweck und Rechtsgrundlage dokumentieren und den Datenfluss prüfen – unabhängig davon, welchen Lösungsdienst Sie einsetzen.

Wie authentifiziere ich einen SOCKS5-Proxy in Selenium?

Über die Kommandozeile funktioniert nur ein Proxy ohne Zugangsdaten. Für Benutzername und Passwort verwenden Sie Selenium Wire und übergeben socks5h://user:pass@host:port in den seleniumwire_options – die Anmeldung läuft dann transparent im Hintergrund.

Verwandte Leitfäden

Verbinden Sie SOCKS5-Proxys mit CaptchaAI für zuverlässige, IP-konsistente CAPTCHA-Lösung – Holen Sie sich Ihren API-Schlüssel.

Kommentare sind für diesen Artikel deaktiviert.