Sticky Sessions vs. Rotating Sessions: Beste Proxy-Strategie für CAPTCHAs

Kurz gesagt: Sticky Sessions gehören zu jedem zusammenhängenden Ablauf – Login, Checkout, Formular mit CAPTCHA –, rotierende Sessions zu unabhängigen Massenabfragen wie Scraping und Suche. Der Grund: Das CAPTCHA-Token ist an die IP gebunden, von der die Anfrage kommt. Der falsche Modus treibt Ihre CAPTCHA-Rate hoch und verbrennt Threads.

Sticky oder Rotating? Der direkte Vergleich

So funktioniert jeder Modus

Der Unterschied liegt nur in der IP-Zuordnung: Sticky hält eine IP über ein Zeitfenster, Rotating vergibt pro Anfrage eine neue.

STICKY SESSION:
  Request 1 ──▶ IP: 192.168.1.50 ──▶ site.com/login
  Request 2 ──▶ IP: 192.168.1.50 ──▶ site.com/dashboard
  Request 3 ──▶ IP: 192.168.1.50 ──▶ site.com/account
  (Same IP for all requests in the session window)

ROTATING SESSION:
  Request 1 ──▶ IP: 192.168.1.50 ──▶ site.com/page1
  Request 2 ──▶ IP: 10.0.0.77   ──▶ site.com/page2
  Request 3 ──▶ IP: 172.16.5.22 ──▶ site.com/page3
  (Different IP per request)

Wann Sticky Sessions gewinnen

Sticky lohnt sich, sobald Anfragen zusammengehören:

• Login und Registrierung – Token von derselben IP absenden.
• Checkout und Zahlung – Session-Cookies an die IP gebunden.
• Mehrseitige Navigation – Zustand wird pro IP verfolgt.

Wechselt die IP zwischen Lösen und Absenden, lehnt der Server das Token ab.

Beispiel: Login-Flow mit CAPTCHA

import requests
import time

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

# Sticky session: same IP for the entire login flow
STICKY_PROXY = {
    "http": "http://user-session-abc123:pass@proxy.example.com:5000",
    "https": "http://user-session-abc123:pass@proxy.example.com:5000",
}

session = requests.Session()
session.proxies = STICKY_PROXY
session.headers.update({
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
    "AppleWebKit/537.36 Chrome/126.0.0.0 Safari/537.36",
})


def login_with_captcha(url, sitekey, username, password):
    """Full login flow — MUST use same IP throughout."""
    # Step 1: Load login page (IP: 192.168.1.50)
    session.get(url)

    # Step 2: Solve CAPTCHA (solved against IP: 192.168.1.50)
    token = solve_recaptcha(sitekey, url)

    # Step 3: Submit login (MUST be IP: 192.168.1.50)
    resp = session.post(url, data={
        "username": username,
        "password": password,
        "g-recaptcha-response": token,
    })

    return resp.status_code == 200


def solve_recaptcha(sitekey, pageurl):
    resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
        "key": CAPTCHAAI_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": pageurl,
        "json": 1,
    })
    task_id = resp.json()["request"]

    for _ in range(60):
        time.sleep(5)
        result = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
            "key": CAPTCHAAI_KEY, "action": "get",
            "id": task_id, "json": 1,
        })
        data = result.json()
        if data["request"] != "CAPCHA_NOT_READY":
            return data["request"]

    raise TimeoutError("CAPTCHA solve timeout")

Warum die IP-Bindung zählt

Sticky session:

  1. Browser loads page    → IP: 5.5.5.5
  2. CAPTCHA solved        → Token bound to session
  3. Form submitted        → IP: 5.5.5.5 ✅ Token accepted

Rotating session:

  1. Browser loads page    → IP: 5.5.5.5
  2. CAPTCHA solved        → Token bound to session
  3. Form submitted        → IP: 9.9.9.9 ❌ Token may be rejected

Wann rotierende Sessions gewinnen

Rotieren gewinnt, wenn Anfragen unabhängig sind:

• Massen-Scraping – verteilt die Last über viele IPs.
• Suchmaschinen-Abfragen – bleibt unter den Grenzen pro IP.
• Preisüberwachung – viele unabhängige Abrufe.

Beispiel: paralleles Seiten-Scraping

import concurrent.futures

ROTATING_PROXY = {
    "http": "http://user:pass@rotating.proxy.example.com:5000",
    "https": "http://user:pass@rotating.proxy.example.com:5000",
}


def scrape_page(url):
    """Each request gets a fresh IP automatically."""
    resp = requests.get(
        url,
        proxies=ROTATING_PROXY,
        headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"},
        timeout=30,
    )
    if resp.status_code == 200:
        return url, resp.text
    return url, None


urls = [f"https://example.com/products?page={i}" for i in range(1, 501)]

with concurrent.futures.ThreadPoolExecutor(max_workers=10) as pool:
    results = list(pool.map(scrape_page, urls))
    success = sum(1 for _, html in results if html)
    print(f"Scraped: {success}/{len(urls)}")

Beispiel: Suchmaschinen-Abfragen ohne Rate-Limiting

def scrape_search(query, pages=10):
    results = []
    for page in range(pages):
        # Each request → new IP
        resp = requests.get(
            "https://search-engine.example.com/search",
            params={"q": query, "start": page * 10},
            proxies=ROTATING_PROXY,
            timeout=20,
        )
        results.append(resp.text)
        time.sleep(2)
    return results

Beide kombinieren: die hybride Proxy-Strategie

In der Praxis brauchen Sie oft beides. Der Manager unten wählt Sticky für Anmeldungen und Rotating für Einzelabfragen automatisch.

class HybridProxyManager:
    """Sticky for multi-step flows, rotating for single requests."""

    def __init__(self, provider_host, username, password, port=5000):
        self.host = provider_host
        self.username = username
        self.password = password
        self.port = port

    def get_rotating_proxy(self):
        return {
            "http": f"http://{self.username}:{self.password}@{self.host}:{self.port}",
            "https": f"http://{self.username}:{self.password}@{self.host}:{self.port}",
        }

    def get_sticky_proxy(self, session_id, duration_min=10):
        sticky_user = f"{self.username}-session-{session_id}-ttl-{duration_min}"
        return {
            "http": f"http://{sticky_user}:{self.password}@{self.host}:{self.port}",
            "https": f"http://{sticky_user}:{self.password}@{self.host}:{self.port}",
        }


proxy_mgr = HybridProxyManager("proxy.example.com", "user", "pass")


def scrape_with_auto_strategy(url, needs_login=False):
    if needs_login:
        # Multi-step → sticky
        import uuid
        session_id = uuid.uuid4().hex[:8]
        proxy = proxy_mgr.get_sticky_proxy(session_id)
    else:
        # Single page → rotating
        proxy = proxy_mgr.get_rotating_proxy()

    return requests.get(url, proxies=proxy, timeout=30)

Node.js-Umsetzung

Dieselbe Logik in Node.js mit axios – Sticky-ID im Benutzernamen:

const axios = require("axios");

const CAPTCHAAI_KEY = "YOUR_API_KEY";
const PROXY_HOST = "proxy.example.com";
const PROXY_PORT = 5000;

function getProxy(mode, sessionId = null) {
  const user =
    mode === "sticky" ? `user-session-${sessionId}` : "user";

  return {
    proxy: {
      host: PROXY_HOST,
      port: PROXY_PORT,
      auth: { username: user, password: "pass" },
    },
  };
}

// Rotating: bulk scrape
async function scrapePages(urls) {
  const results = [];
  for (const url of urls) {
    const config = getProxy("rotating");
    const resp = await axios.get(url, { ...config, timeout: 30000 });
    results.push({ url, data: resp.data });
  }
  return results;
}

// Sticky: login flow
async function loginFlow(loginUrl, sitekey, credentials) {
  const sessionId = Date.now().toString(36);
  const config = getProxy("sticky", sessionId);

  // Step 1: Load page
  await axios.get(loginUrl, config);

  // Step 2: Solve CAPTCHA
  const submitResp = await axios.post(
    "https://ocr.captchaai.com/in.php",
    null,
    {
      params: {
        key: CAPTCHAAI_KEY,
        method: "userrecaptcha",
        googlekey: sitekey,
        pageurl: loginUrl,
        json: 1,
      },
    }
  );
  const taskId = submitResp.data.request;

  let token;
  for (let i = 0; i < 60; i++) {
    await new Promise((r) => setTimeout(r, 5000));
    const res = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: CAPTCHAAI_KEY, action: "get", id: taskId, json: 1 },
    });
    if (res.data.request !== "CAPCHA_NOT_READY") {
      token = res.data.request;
      break;
    }
  }

  // Step 3: Submit with same IP
  return axios.post(
    loginUrl,
    {
      ...credentials,
      "g-recaptcha-response": token,
    },
    config
  );
}

Entscheidungsmatrix nach Workflow

Passende Sticky-Dauer wählen

Faustregel: Setzen Sie die Sticky-Dauer auf das Doppelte Ihrer erwarteten Ablaufzeit.

Häufige Probleme und Lösungen

DSGVO im Blick: Proxys und personenbezogene Daten

Für DACH-Teams kommt eine rechtliche Frage hinzu: IP-Adressen gelten nach DSGVO als personenbezogene Daten. Wer Residential- oder Rechenzentrums-Proxys zur Datenerhebung nutzt, sollte vorab prüfen:

• Rechtsgrundlage der Verarbeitung,
• Datenflüsse und Speicherorte,
• Speicherdauer der erhobenen Daten.

Der Session-Modus ändert daran nichts – er entscheidet nur über die Stabilität der Lösung. CaptchaAI rechnet ohnehin pro Thread ab (Pläne ab BASIC mit 15 $/Monat und 5 Threads).

FAQ

Warum wird mein CAPTCHA-Token nach dem Lösen abgelehnt?

Meist hat sich die IP zwischen Lösen und Absenden geändert. Das Token ist an die anfragende IP gebunden – nutzen Sie bei Login- und Formular-Abläufen Sticky Sessions.

Welche Sticky-Dauer passt zu einem Login-Flow?

Fünf Minuten sind ein guter Startwert. Faustregel: die doppelte erwartete Ablaufzeit. Kürzere Fenster laufen mitten im Vorgang ab, längere erhöhen das Sperr-Risiko.

Beeinflusst der Session-Modus meine CaptchaAI-Kosten?

Indirekt. CaptchaAI rechnet pro Thread ab, nicht pro Lösung. Der falsche Modus löst aber mehr CAPTCHA-Abfragen aus und belegt Threads länger.

Wie aktiviere ich Sticky Sessions bei meinem Proxy-Anbieter?

Fast alle Anbieter kodieren eine Session-ID im Benutzernamen, etwa user-session-abc123; das genaue Format steht in der Doku. Eigene Leitfäden gibt es für Bright Data, Smartproxy und Oxylabs.

Gilt dieselbe Strategie für reCAPTCHA v3 und Turnstile?

Ja. Auch reCAPTCHA v3 und Turnstile binden das Token an den Anfragekontext. Mehrstufig: Sticky, sonst Rotating.

Verwandte Leitfäden

• Proxy-Authentifizierung im Überblick
• Proxy-Qualität und Lösungsrate
• Browser-Sitzung über verteilte Worker persistent halten

Passen Sie Ihre Proxy-Strategie an Ihren Workflow an – holen Sie sich Ihren CaptchaAI-Schlüssel und lösen Sie CAPTCHAs in jedem Modus.