Cloudflare Under Attack Mode (IUAM) automatisiert lösen

Bekommt Ihr Scraper bei jeder Anfrage plötzlich HTTP 503 und die Meldung „Checking your browser…", ist das kein Serverfehler, sondern Cloudflares Under Attack Mode (IUAM). Dieser DDoS-Schutz zwingt jeden Besucher durch eine rund fünfsekündige JavaScript-Challenge, bevor die eigentliche Seite ausgeliefert wird – daran scheitern klassische HTTP-Clients.

Die kurze Antwort: Sie brauchen einen Client, der das Challenge-JavaScript ausführt und daraus das cf_clearance-Cookie erzeugt. Dieser Artikel zeigt, wie Sie IUAM von anderen Cloudflare-Modi unterscheiden und mit CaptchaAI automatisiert lösen.

Was beim Under Attack Mode passiert

Aktiviert ein Betreiber den Under Attack Mode, durchläuft jede Anfrage denselben Ablauf – vom 503 bis zum Cookie:

Every request → Cloudflare edge
    ↓
JavaScript challenge page served (HTTP 503)
    ↓
Browser executes JavaScript challenge (~5 seconds)
    ↓
Challenge answer submitted automatically
    ↓
cf_clearance cookie set
    ↓
Original page loaded with cf_clearance cookie

Die Challenge-Seite (HTTP 503) besteht aus diesen Bausteinen:

Kurz zusammengefasst – die fünf Signale von IUAM:

• Statuscode HTTP 503, nicht 403
• rund 5 Sekunden Pflicht-Wartezeit
• JavaScript zwingend – reine HTTP-Clients scheitern
• cf_clearance-Cookie, ~30 Minuten gültig
• domainweit auf jeder URL der Domain

Erst prüfen: Ist es wirklich IUAM?

Nicht jede 503-Antwort ist ein IUAM. Bevor Sie einen Solver ansteuern, bestimmen Sie den Schutzmodus – sonst lösen Sie die falsche Challenge-Art. Die folgende Funktion wertet Statuscode und Seiteninhalt aus:

import requests

def identify_cloudflare_protection(url):
    """Distinguish IUAM from other Cloudflare protections."""
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                      "AppleWebKit/537.36 Chrome/120.0.0.0",
    }

    response = requests.get(url, headers=headers, timeout=15, allow_redirects=False)
    html = response.text
    status = response.status_code

    if status == 503 and "jschl" in html:
        return "IUAM (I'm Under Attack Mode)"

    if status == 503 and "challenge-platform" in html:
        return "Managed Challenge"

    if status == 403 and "cf-ray" in str(response.headers):
        return "Blocked by WAF/Bot Management"

    if "cf-turnstile" in html:
        return "Turnstile widget"

    if "challenges.cloudflare.com" in html:
        return "Cloudflare challenge (generic)"

    if status == 200:
        return "No challenge (passed)"

    return f"Unknown (status: {status})"

Tipp: Rufen Sie identify_cloudflare_protection() als ersten Schritt jeder Anfrage auf. So trennen Sie IUAM, Managed Challenge, Turnstile und WAF-Block und leiten jeden Fall an die passende Methode.

Warum reine HTTP-Clients scheitern

Die JavaScript-Challenge prüft, ob hinter der Anfrage ein echter Browser steckt. Cloudflare liefert verschleiertes JavaScript, das erst nach Rechen- und Timing-Prüfung ein cf_clearance-Cookie freischaltet. Konkret erledigt das Skript:

• mathematische Operationen auf Zeichenketten aus der Seite
• DOM-Messungen im Dokument
• erzwungenes Timing von mindestens 4–5 Sekunden
• automatisches Absenden von jschl_vc, pass und jschl_answer

Ein einfaches requests.get() bekommt deshalb nur die Challenge-Seite zurück, nie den eigentlichen Inhalt:

# This will ALWAYS get the challenge page:
import requests
response = requests.get("https://iuam-protected-site.com")
# response.status_code == 503
# response.text contains "Checking your browser..."

# Plain HTTP clients cannot:
# - Execute JavaScript
# - Compute the challenge answer
# - Meet the timing requirement
# - Generate the required cookies

IUAM mit CaptchaAI lösen

Methode 1: Cloudflare-Challenge-Solver (empfohlen)

Die Methode cloudflare_challenge verarbeitet IUAM direkt: Ziel-URL und Sitekey übermitteln, das Ergebnis per Polling abfragen, die Freigabedaten entgegennehmen.

import requests
import time

API_KEY = "YOUR_API_KEY"
TARGET_URL = "https://iuam-protected-site.com/data"

# Step 1: Submit challenge to CaptchaAI
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "cloudflare_challenge",
    "sitekey": "managed",
    "pageurl": TARGET_URL,
    "json": 1,
})

task_id = submit.json()["request"]
print(f"Task submitted: {task_id}")

# Step 2: Poll for result
for attempt in range(60):
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY,
        "action": "get",
        "id": task_id,
        "json": 1,
    }).json()

    if result.get("status") == 1:
        token = result["request"]
        print(f"Challenge solved! Token: {token[:50]}...")
        break
    elif result.get("request") == "ERROR_CAPTCHA_UNSOLVABLE":
        print("Challenge could not be solved")
        break
else:
    print("Timed out waiting for solution")

# Step 3: Use cf_clearance cookie or token
# The response contains the clearance data needed to access the site

Methode 2: Browser-Automatisierung mit CaptchaAI

Für dauerhafte Sitzungen kombinieren Sie einen Headless-Browser mit CaptchaAI: Der Browser navigiert, die Cookies extrahieren Sie anschließend für weitere Anfragen.

from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import requests
import time

API_KEY = "YOUR_API_KEY"

# Launch browser
options = webdriver.ChromeOptions()
options.add_argument("--disable-blink-features=AutomationControlled")
driver = webdriver.Chrome(options=options)

# Navigate to IUAM page
driver.get("https://iuam-protected-site.com")

# Wait for challenge page to load
time.sleep(3)

# Check if IUAM challenge is present
if "Checking your browser" in driver.page_source or driver.title == "Just a moment...":
    print("IUAM challenge detected")

    # Option A: Wait for browser to solve natively (if not headless)
    try:
        WebDriverWait(driver, 15).until(
            lambda d: "Checking your browser" not in d.page_source
        )
        print("Challenge passed natively")
    except:
        print("Native solve failed — using CaptchaAI")
        # Submit to CaptchaAI for solving
        # Token submission via JavaScript injection

# After challenge is passed, extract cookies for API use
cookies = driver.get_cookies()
cf_clearance = next(
    (c["value"] for c in cookies if c["name"] == "cf_clearance"), None
)

if cf_clearance:
    print(f"cf_clearance obtained: {cf_clearance[:30]}...")

    # Use cookie with requests library
    session = requests.Session()
    for cookie in cookies:
        session.cookies.set(cookie["name"], cookie["value"])
    session.headers.update({
        "User-Agent": driver.execute_script("return navigator.userAgent"),
    })

    # Now make requests with the clearance cookie
    response = session.get("https://iuam-protected-site.com/api/data")
    print(f"Status: {response.status_code}")

driver.quit()

Node.js

Dasselbe Muster in Node.js:

const axios = require("axios");

const API_KEY = "YOUR_API_KEY";
const TARGET_URL = "https://iuam-protected-site.com/data";

async function solveIUAM() {
  // Submit challenge
  const submit = await axios.post("https://ocr.captchaai.com/in.php", null, {
    params: {
      key: API_KEY,
      method: "cloudflare_challenge",
      sitekey: "managed",
      pageurl: TARGET_URL,
      json: 1,
    },
  });

  const taskId = submit.data.request;
  console.log(`Task submitted: ${taskId}`);

  // 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: API_KEY, action: "get", id: taskId, json: 1 },
    });

    if (result.data.status === 1) {
      console.log("IUAM challenge solved!");
      return result.data.request;
    }
  }

  throw new Error("Timed out");
}

solveIUAM().then((token) => console.log("Token:", token.substring(0, 50)));

cf_clearance-Cookies verwalten

Das cf_clearance-Cookie ist das Ergebnis einer gelösten IUAM-Challenge. Seine Eigenschaften bestimmen, wie lange und unter welchen Bedingungen Sie es wiederverwenden können:

Praxisszenario – Preis-Monitoring aus einem Hetzner-Worker: Läuft Ihr Monitoring für einen Shopware-Shop auf einem Hetzner- oder netcup-Server und schaltet der Shop während einer Rabattaktion den Under Attack Mode ein, brechen alle Anfragen mit 503 ab. Lösen Sie die Challenge einmal pro Worker und halten Sie IP und User-Agent über die Sitzung stabil – sonst verwirft Cloudflare das Cookie sofort. Betreiben Sie pro IP genau eine Sitzung und erneuern Sie sie vor Ablauf der 30 Minuten.

Sobald IP-Adressen oder personenbezogene Daten ins Spiel kommen, gilt in der DACH-Region die DSGVO: Prüfen Sie Rechtsgrundlage, Zweck und die Nutzungsbedingungen der Zielseite, bevor Sie fremde Seiten automatisiert abfragen.

Strategie für die Cookie-Verwaltung

import requests
import time

class IUAMSessionManager:
    """Manage cf_clearance cookies for IUAM-protected sites."""

    def __init__(self, api_key, target_url, user_agent=None):
        self.api_key = api_key
        self.target_url = target_url
        self.user_agent = user_agent or (
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 Chrome/120.0.0.0"
        )
        self.session = requests.Session()
        self.session.headers["User-Agent"] = self.user_agent
        self.clearance_time = 0
        self.clearance_lifetime = 1800  # 30 minutes default

    def needs_refresh(self):
        """Check if clearance cookie needs refreshing."""
        return time.time() - self.clearance_time > self.clearance_lifetime - 60

    def solve_challenge(self):
        """Solve IUAM challenge and update session cookies."""
        submit = requests.post("https://ocr.captchaai.com/in.php", data={
            "key": self.api_key,
            "method": "cloudflare_challenge",
            "sitekey": "managed",
            "pageurl": self.target_url,
            "json": 1,
        })

        task_id = submit.json()["request"]

        for _ in range(60):
            time.sleep(5)
            result = requests.get("https://ocr.captchaai.com/res.php", params={
                "key": self.api_key,
                "action": "get",
                "id": task_id,
                "json": 1,
            }).json()

            if result.get("status") == 1:
                # Apply clearance to session
                self.clearance_time = time.time()
                return result["request"]

        raise TimeoutError("IUAM solve timed out")

    def get(self, url, **kwargs):
        """Make a GET request, solving IUAM if needed."""
        if self.needs_refresh():
            self.solve_challenge()
        return self.session.get(url, **kwargs)

Fehlerbehebung

Häufige Fehlerbilder beim IUAM-Handling und ihre Ursachen:

Häufige Fragen

Warum scheitern requests und httpx am Under Attack Mode?

Weil beide kein JavaScript ausführen. IUAM verlangt, dass das Challenge-Skript rechnet und das Timing einhält; ein reiner HTTP-Client erhält nur die 503-Seite. Erst ein Werkzeug, das die Challenge löst – CaptchaAI oder ein echter Browser –, erzeugt ein gültiges cf_clearance-Cookie.

Welcher CaptchaAI-Plan passt zu IUAM-lastigem Scraping?

Entscheidend ist die gewünschte Parallelität, nicht die Zahl der Lösungen. CaptchaAI rechnet Thread-basiert, mit unbegrenzten Lösungen pro Thread. Schon BASIC (15 $/Monat, 5 Threads) deckt fünf gleichzeitige Challenges ab; für größere Flotten skalieren Sie über STANDARD (30 $/Monat, 15 Threads) oder ADVANCE (90 $/Monat, 50 Threads).

Ist das automatisierte Lösen von IUAM DSGVO-konform?

Das Lösen selbst ist ein technischer Vorgang; die rechtliche Bewertung hängt von den erhobenen Daten ab. IP-Adressen gelten in der EU als personenbezogen. Klären Sie Rechtsgrundlage, Zweckbindung und Nutzungsbedingungen der Zielseite, bevor Sie produktiv scrapen – Ihre Sorgfaltspflicht, keine Aussage über CaptchaAI.

Woran erkenne ich, ob eine Seite IUAM oder eine Managed Challenge nutzt?

IUAM fordert jeden Besucher bedingungslos heraus – 503 mit jschl im Body. Eine Managed Challenge bewertet den Traffic zuerst und stellt nur selektiv – oft ein Turnstile-Widget – vor die Seite. Die Erkennungsmatrix oben und identify_cloudflare_protection() trennen beide Fälle zuverlässig.

Fazit

Der Under Attack Mode ist Cloudflares kompromisslosester Modus: Jede Anfrage erhält HTTP 503 und muss eine JavaScript-Challenge mit rund fünf Sekunden Rechenzeit bestehen. Reine HTTP-Clients haben hier keine Chance. Lösen Sie die Challenge mit dem Cloudflare-Challenge-Solver von CaptchaAI und nutzen Sie das cf_clearance-Cookie für alle Folgeanfragen im 30-Minuten-Fenster – IP-Adresse und User-Agent dabei konstant halten.

Verwandte Artikel

• So funktioniert die Cloudflare Challenge
• cf_clearance-Cookie richtig handhaben
• Managed Challenge vs. interaktive Challenge