Scraping von CAPTCHA-geschützten Websites

Die meisten hochwertigen Websites verwenden CAPTCHAs als Teil ihrer Anti-Bot-Abwehr. Dieser Leitfaden behandelt Strategien zum zuverlässigen Scraping dieser Websites mit CaptchaAI, einschließlich der Identifizierung von CAPTCHA-Typen, ihrer automatischen Lösung und dem Aufbau robuster Scraper.

Allgemeine CAPTCHA-Implementierungen

Strategie 1: Erkennen und Lösen bei Bedarf

Der zuverlässigste Ansatz – normal scrapen und CAPTCHAs nur dann lösen, wenn sie erscheinen:

import requests
import time
from bs4 import BeautifulSoup

API_KEY = "YOUR_API_KEY"

class ProtectedScraper:
    def __init__(self):
        self.session = requests.Session()
        self.session.headers.update({
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
        })

    def scrape(self, url):
        resp = self.session.get(url)

        # Check for CAPTCHA
        if self._has_captcha(resp.text):
            resp = self._handle_captcha(resp.text, url)

        return resp.text

    def _has_captcha(self, html):
        indicators = ["g-recaptcha", "cf-turnstile", "h-captcha", "captcha"]
        return any(ind in html.lower() for ind in indicators)

    def _handle_captcha(self, html, url):
        soup = BeautifulSoup(html, "html.parser")

        # reCAPTCHA v2
        rc = soup.find("div", class_="g-recaptcha")
        if rc:
            token = self._solve_recaptcha(rc["data-sitekey"], url)
            return self.session.post(url, data={"g-recaptcha-response": token})

        # Cloudflare Turnstile
        ts = soup.find("div", class_="cf-turnstile")
        if ts:
            token = self._solve_turnstile(ts["data-sitekey"], url)
            return self.session.post(url, data={"cf-turnstile-response": token})

        raise Exception("Unknown CAPTCHA type")

    def _solve_recaptcha(self, site_key, page_url):
        resp = requests.get("https://ocr.captchaai.com/in.php", params={
            "key": API_KEY, "method": "userrecaptcha",
            "googlekey": site_key, "pageurl": page_url
        })
        return self._poll(resp.text.split("|")[1])

    def _solve_turnstile(self, site_key, page_url):
        resp = requests.get("https://ocr.captchaai.com/in.php", params={
            "key": API_KEY, "method": "turnstile",
            "sitekey": site_key, "pageurl": page_url
        })
        return self._poll(resp.text.split("|")[1])

    def _poll(self, task_id):
        for _ in range(60):
            time.sleep(5)
            result = requests.get("https://ocr.captchaai.com/res.php", params={
                "key": API_KEY, "action": "get", "id": task_id
            })
            if result.text == "CAPCHA_NOT_READY": continue
            if result.text.startswith("OK|"): return result.text.split("|")[1]
            raise Exception(result.text)
        raise TimeoutError()

# Usage
scraper = ProtectedScraper()
html = scraper.scrape("https://example.com/data")

Strategie 2: Vorab nach bekannten CAPTCHA-Seiten suchen

Wenn Sie wissen, welche Seiten immer CAPTCHAs haben, lösen Sie präventiv:

def scrape_known_captcha_page(url, site_key):
    # Solve before even loading the page
    token = solve_recaptcha(site_key, url)

    # Submit directly with token
    resp = requests.post(url, data={
        "g-recaptcha-response": token,
        "query": "search term"
    })
    return resp.text

Strategie 3: Durch Cloudflare geschützte Websites

Für Websites hinter Cloudflare ist häufig ein cf_clearance-Cookie erforderlich:

def get_cloudflare_clearance(url, proxy):
    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY,
        "method": "cloudflare_challenge",
        "pageurl": url,
        "proxy": proxy,
        "proxytype": "HTTP"
    })
    task_id = resp.text.split("|")[1]

    for _ in range(60):
        time.sleep(5)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY, "action": "get", "id": task_id
        })
        if result.text == "CAPCHA_NOT_READY": continue
        if "cf_clearance" in result.text:
            # Parse cf_clearance and user_agent from response
            return result.text
    raise TimeoutError()

Mehrseitiges Kratzmuster

def scrape_multiple_pages(base_url, site_key, pages):
    scraper = ProtectedScraper()
    results = []

    for page in pages:
        url = f"{base_url}?page={page}"
        try:
            html = scraper.scrape(url)
            soup = BeautifulSoup(html, "html.parser")
            items = soup.find_all("div", class_="item")
            results.extend([item.text.strip() for item in items])
            print(f"Page {page}: {len(items)} items")
        except Exception as e:
            print(f"Page {page} failed: {e}")

        time.sleep(random.uniform(2, 5))

    return results

Fehlerbehebung

FAQ

Welche Websites sind am schwersten zu durchsuchen?

Am anspruchsvollsten sind Websites, die Cloudflare Enterprise, PerimeterX oder Akamai Bot Manager verwenden. CaptchaAI verwaltet ihre CAPTCHA-Komponenten; kombinieren Sie es mit konfigurierten Browserprofilen und Proxys, um die besten Ergebnisse zu erzielen.

Kann ich Websites entfernen, die eine Anmeldung erfordern?

Ja. Melden Sie sich zuerst an (lösen Sie alle Anmelde-CAPTCHAs), verwalten Sie die Sitzungscookies und scannen Sie dann die authentifizierten Seiten. CaptchaAI verarbeitet CAPTCHAs in jeder Phase.

Wie gehe ich mit JavaScript-gerenderten Seiten um?

Verwenden Sie Selenium, Puppeteer oder Playwright, um JavaScript zu rendern, extrahieren Sie dann CAPTCHA-Parameter und lösen Sie es über CaptchaAI. Sehen Sie Selenium CAPTCHA-Verwaltung.

Verwandte Leitfäden

• So bewältigen Sie CAPTCHA-Herausforderungen in Web-Scraping-Workflows
• Probleme mit Headless-Browser-CAPTCHA
• CAPTCHA-Erkennung beim Scraping erklärt