Einzelhandelsdaten scrapen: CAPTCHA-Handling für Preis-Monitoring

Wer Preise, Verfügbarkeiten oder Bewertungen großer Online-Shops automatisiert erfasst – etwa für Wettbewerbspreis-Monitoring –, stößt früher oder später auf ein Bild-CAPTCHA: einen verzerrten Text als Bot-Sperre. Die kurze Antwort: Die OCR-Lösung von CaptchaAI liest diese Bilder aus und gibt den Text zurück, sodass Ihr Scraper ohne manuellen Eingriff weiterläuft.

Dieser Leitfaden zeigt den kompletten Ablauf am Beispiel von Amazon – von der Erkennung der CAPTCHA-Seite über das Auslesen des Bildes bis zum Absenden der Lösung. Der Code nutzt Python mit requests und BeautifulSoup und lässt sich auf jede Shop-Seite mit klassischem Bild-CAPTCHA übertragen.

Wann Einzelhandelsseiten ein CAPTCHA anzeigen

Große Shops blenden die Abfrage anhand klarer Signale ein:

Ist die Schwelle erreicht, leitet die Seite auf eine Ansicht mit verzerrtem Textbild und Eingabefeld weiter: Bild lösen, Text absenden, Abruf fortsetzen. Wie schnell die Sperre greift, hängt vom Setup ab – mit sauberen Residential-Proxys und realistischen Headern lassen sich oft Hunderte Seiten abrufen, ohne Proxys erscheint das CAPTCHA teils schon nach 10–20 Anfragen.

Warum Shops ein eigenes Bild-CAPTCHA einsetzen

Anders als auf Login- oder Formularseiten kommt auf Produktseiten großer Händler selten reCAPTCHA oder Turnstile zum Einsatz, sondern ein selbst gehostetes Bild-CAPTCHA mit verzerrtem Text. Der Grund ist praktischer Natur: Diese Abfrage lässt sich serverseitig an bestehende Anti-Bot-Schwellen koppeln, ohne dass pro Seitenaufruf ein Drittanbieter-Skript geladen wird. Für Ihren Scraper hat das drei Konsequenzen:

• Die Abfrage ist ein reines Bild – kein JavaScript-Token, keine Browser-Ausführung nötig.
• Der OCR-Endpunkt (method=base64) genügt; Sie brauchen weder Headless-Browser noch Sitekey.
• Erkennung und Lösung laufen im selben HTTP-Request-Fluss wie der eigentliche Abruf.

Voraussetzungen

Bild-CAPTCHA auf Einzelhandelsseiten lösen – Schritt für Schritt

Der Ablauf besteht aus drei Schritten: die CAPTCHA-Seite erkennen, das Bild extrahieren und über CaptchaAI lösen, den zurückgegebenen Text ins Formular eintragen und absenden. Die folgenden Beispiele bauen aufeinander auf.

Schritt 1: CAPTCHA-Seite erkennen

Prüfen Sie zunächst, ob statt der Produktseite eine CAPTCHA-Ansicht kam:

import requests
from bs4 import BeautifulSoup

session = requests.Session()
session.headers.update({
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    "Accept-Language": "en-US,en;q=0.9",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
})

def is_captcha_page(html):
    return "Type the characters you see in this image" in html or \
           "captcha" in html.lower()

url = "https://www.amazon.com/dp/B0EXAMPLE"
resp = session.get(url)

if is_captcha_page(resp.text):
    print("CAPTCHA detected!")
else:
    print("Page loaded successfully")

Schritt 2: Bild extrahieren und lösen

Bild herunterladen, als Base64 kodieren, an den OCR-Endpunkt übermitteln und das Ergebnis per Polling abfragen:

import base64

API_KEY = "YOUR_API_KEY"

def solve_amazon_captcha(session, captcha_page_html, captcha_page_url):
    soup = BeautifulSoup(captcha_page_html, "html.parser")

    # Find the CAPTCHA image
    img_tag = soup.find("img", src=lambda s: s and "captcha" in s.lower())
    if not img_tag:
        raise Exception("CAPTCHA image not found")

    img_url = img_tag["src"]

    # Download the image
    img_resp = session.get(img_url)
    img_base64 = base64.b64encode(img_resp.content).decode()

    # Submit to CaptchaAI
    submit_resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY,
        "method": "base64",
        "body": img_base64
    })
    task_id = submit_resp.text.split("|")[1]

    # Poll for result
    import time
    for _ in range(30):
        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(f"Solve error: {result.text}")

    raise TimeoutError("Solve timed out")

Schritt 3: Lösung absenden

Formular auslesen, den gelösten Text in das richtige Feld eintragen und an die action-URL absenden:

def submit_captcha_solution(session, captcha_page_html, solution, captcha_page_url):
    soup = BeautifulSoup(captcha_page_html, "html.parser")
    form = soup.find("form")

    # Build form data
    form_data = {}
    for inp in form.find_all("input"):
        name = inp.get("name")
        if name:
            form_data[name] = inp.get("value", "")

    # Set the CAPTCHA answer
    form_data["field-keywords"] = solution

    # Submit
    action = form.get("action", captcha_page_url)
    if action.startswith("/"):
        from urllib.parse import urljoin
        action = urljoin(captcha_page_url, action)

    resp = session.post(action, data=form_data)
    return resp

Vollständiges Arbeitsbeispiel

Alle drei Schritte zusammengefasst: Seite abrufen, CAPTCHA bei Bedarf lösen und absenden, dann Titel und Preis parsen.

import requests
import base64
import time
from bs4 import BeautifulSoup

API_KEY = "YOUR_API_KEY"

def scrape_amazon_product(url):
    session = requests.Session()
    session.headers.update({
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        "Accept-Language": "en-US,en;q=0.9"
    })

    resp = session.get(url)

    # Handle CAPTCHA if present
    if "captcha" in resp.text.lower():
        soup = BeautifulSoup(resp.text, "html.parser")
        img = soup.find("img", src=lambda s: s and "captcha" in s.lower())

        if img:
            # Download and solve
            img_data = session.get(img["src"]).content
            img_b64 = base64.b64encode(img_data).decode()

            submit = requests.get("https://ocr.captchaai.com/in.php", params={
                "key": API_KEY, "method": "base64", "body": img_b64
            })
            task_id = submit.text.split("|")[1]

            for _ in range(30):
                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|"):
                    solution = result.text.split("|")[1]
                    break

            # Submit solution
            form = soup.find("form")
            form_data = {inp.get("name"): inp.get("value", "")
                        for inp in form.find_all("input") if inp.get("name")}
            form_data["field-keywords"] = solution

            action = form.get("action", url)
            resp = session.post(action, data=form_data)

    # Parse product data
    soup = BeautifulSoup(resp.text, "html.parser")
    title = soup.find("span", {"id": "productTitle"})
    price = soup.find("span", class_="a-price-whole")

    return {
        "title": title.text.strip() if title else None,
        "price": price.text.strip() if price else None
    }

product = scrape_amazon_product("https://www.amazon.com/dp/B0EXAMPLE")
print(product)

Erfasste Preisdaten fürs Monitoring weiterverarbeiten

Ein einzelner Abruf liefert nur eine Momentaufnahme. Für echtes Wettbewerbspreis-Monitoring speichern Sie Titel, Preis und einen Zeitstempel pro Produkt und lassen den Scraper in festen Intervallen laufen – je nach Sortiment stündlich bis täglich. So erkennen DACH-Händler Preisänderungen der Konkurrenz früh und können ihre eigenen Preise in Shopware, JTL oder Shopify zeitnah nachziehen.

Drei Dinge halten den Betrieb dabei stabil und schlank:

• Änderungen statt Rohdaten protokollieren – speichern Sie nur Abweichungen gegenüber dem letzten Lauf, das hält die Datenmenge klein und macht Preissprünge sofort sichtbar.
• Fehlende Werte tolerieren – ein leeres Preisfeld bedeutet meist ein geändertes Layout, nicht das Produktende; markieren Sie solche Datensätze zur manuellen Prüfung, statt den Lauf abzubrechen.
• Lastspitzen vermeiden – verteilen Sie große Produktlisten über den Tag, statt Tausende Seiten in wenigen Minuten abzurufen; das senkt die CAPTCHA-Rate und schont Ihr Proxy-Budget.

Best Practices für stabiles Scraping

1. Residential-Proxys verwenden – Rechenzentrums-IPs werden aggressiv blockiert
2. User-Agents rotieren – einen Pool realistischer Browser-Strings nutzen
3. Sitzungen beibehalten – Cookies über alle Anfragen hinweg speichern
4. Verzögerungen einbauen – 3–10 Sekunden zwischen den Anfragen
5. Accept-Language setzen – immer Locale-Header mitsenden
6. Keine eingeloggten Seiten scrapen – Produktseiten sind ohne Anmeldung erreichbar

Fehlerbehebung

Rechtliche Einordnung und DSGVO

Öffentlich zugängliche Produktdaten – Preise, Titel, Bewertungen – zu erfassen ist in der Regel zulässig. DACH-Teams sollten dennoch die Nutzungsbedingungen der Shop-Seite prüfen und den Datenschutz beachten: Sobald personenbezogene Daten verarbeitet werden – etwa Klarnamen aus Bewertungen oder IP-Adressen aus Proxy-Ketten –, greift die DSGVO. Beschränken Sie die Erfassung auf das Nötige und dokumentieren Sie Ihre Rechtsgrundlage. Das ist Ihre Sorgfaltspflicht, keine Aussage über die Compliance von CaptchaAI.

Konkret bedeutet das für DACH-Teams:

• Erfassen Sie nur öffentlich sichtbare Produktdaten, keine personenbezogenen Inhalte aus Bewertungen.
• Prüfen Sie Nutzungsbedingungen und Impressum der Shop-Seite vor dem ersten Lauf.
• Dokumentieren Sie Zweck und Rechtsgrundlage Ihrer Datenerfassung nachvollziehbar.

Hinweis: Dies ist eine allgemeine Einordnung und keine Rechtsberatung. Klären Sie den konkreten Einzelfall mit Ihrer Rechtsabteilung oder einer Fachanwältin.

FAQ

Welchen CAPTCHA-Typ setzen große Einzelhandelsseiten ein?

Meist ein eigenes Bild-CAPTCHA mit verzerrtem Text, kein reCAPTCHA. CaptchaAI verarbeitet diese über den method=base64-Endpunkt.

Wie viele Threads brauche ich für kontinuierliches Preis-Monitoring?

Das hängt von der parallelen Last ab. CaptchaAI rechnet pro Thread ab – also pro gleichzeitiger Lösung, nicht pro CAPTCHA –, jeder Thread löst monatlich unbegrenzt viele CAPTCHAs. Für Tests genügt BASIC (15 $/Monat, 5 Threads); für mehrere parallele Crawler skalieren Sie über ADVANCE (90 $/Monat, 50 Threads) aufwärts.

Löst CaptchaAI auch reCAPTCHA oder Cloudflare Turnstile auf Shop-Seiten?

Ja. Neben Bild-CAPTCHAs unterstützt CaptchaAI reCAPTCHA v2/v3, Cloudflare Turnstile und Challenge sowie GeeTest v3. Für JavaScript-Abfragen nutzen Sie den passenden Endpunkt statt der OCR-Route.

Reicht ein Rechenzentrums-Proxy oder brauche ich Residential-Proxys?

Für gelegentliche Abrufe genügt oft ein Rechenzentrums-Proxy. Bei dauerhaftem Scraping großer Shops sind Residential-Proxys stabiler, weil ihre IP-Reputation seltener ein CAPTCHA auslöst.

Wie oft sollte ich die Preise abrufen?

Das richtet sich nach der Preisdynamik Ihres Marktes. Für die meisten Sortimente reicht ein täglicher Lauf; bei stark schwankenden Kategorien wie Elektronik sind stündliche Abrufe sinnvoll. Je häufiger Sie abrufen, desto wichtiger werden saubere Residential-Proxys und eine gedrosselte Anfragerate, damit nicht bei jedem Lauf ein Bild-CAPTCHA erscheint.

Verwandte Leitfäden

• Suchergebnisse trotz CAPTCHA erfassen
• Proxy-Rotation für CAPTCHA-Scraping
• Bild-CAPTCHA per API lösen