Bild-CAPTCHA gibt falsche Antwort zurück: Qualitätsoptimierung

Wenn die zurückgegebene Antwort bei einem Bild-CAPTCHA nicht stimmt, liegt das selten am OCR und fast immer am Bild selbst. Drei Ursachen erklären den Großteil der Fälle: ein falsch zugeschnittenes Element, eine kaputte Base64-Kodierung und eine zu niedrige Auflösung. Prüfen Sie diese drei zuerst – oft ist das Problem damit erledigt, bevor Sie an Vorverarbeitung oder zusätzliche Parameter denken.

Zuerst prüfen: liegt es am Bild oder am Dienst?

Bevor Sie an Parametern schrauben, klären Sie die Schuldfrage in einem einzigen Schritt: Speichern Sie genau das Byte-Array, das Ihre Pipeline übermittelt, als Datei ab und öffnen Sie es im Bildbetrachter. Was Sie dort sehen, sieht auch das OCR – nicht mehr und nicht weniger.

Ist das Bild leer, halb abgeschnitten, verwaschen oder erkennbar das falsche Element, haben Sie die Ursache bereits gefunden, und die folgenden Fixes greifen. Zeigt der Bildbetrachter dagegen ein sauberes, gut lesbares CAPTCHA und die Antwort ist trotzdem Unsinn, ist die Kodierung der wahrscheinlichste Übeltäter (Fix 2). Diese Zwei-Minuten-Diagnose erspart Ihnen langes Raten und richtet den Blick sofort auf die richtige Stelle in der Pipeline.

Die häufigsten Ursachen im Überblick

Nach Häufigkeit geordnet – die obersten drei Zeilen decken den Großteil aller Support-Fälle ab:

Ein Szenario aus dem DACH-Alltag

Ein wiederkehrendes Muster: Ein Team automatisiert die Terminbuchung auf einem BLS-Visa-Portal mit klassischem Text-Bild-CAPTCHA. Die Antworten kommen fast richtig zurück, aber ein Zeichen ist regelmäßig falsch. Ursache war nicht der Dienst, sondern ein Seiten-Screenshot, der das CAPTCHA mit einem Pixel Rand abschnitt und zusätzlich skalierte. Nach dem Wechsel auf einen Element-Screenshot (Fix 5) und einen min_len/max_len-Hinweis stimmte die Antwort zuverlässig. Die Lehre: Nicht der Lösungsdienst, sondern die Aufnahme ist die häufigste Fehlerquelle.

Format, Auflösung und Dateigröße richtig wählen

Bevor wir zu Code kommen, die Ausgangswerte, an denen sich alles Weitere orientiert. Übermitteln Sie CAPTCHA-Bilder als PNG, nicht als stark komprimiertes JPEG – verlustbehaftete Komprimierung erzeugt Artefakte an genau den Kanten, die das OCR zum Lesen braucht. Die Auflösung sollte mindestens 50×20 Pixel betragen; alles darunter ist für eine verlässliche Erkennung zu grob. Nach oben halten Sie die Dateigröße unter 600 KB, damit die Übertragung nicht unnötig träge wird.

Ein häufiger, schwer zu findender Fehler ist die doppelte Komprimierung: Ein Screenshot wird als JPEG gespeichert, später als PNG neu kodiert und dabei hochskaliert. Das Ergebnis sieht auf dem Bildschirm passabel aus, enthält aber Kompressionsrauschen, das die Trefferquote drückt. Arbeiten Sie deshalb möglichst mit dem verlustfreien Rohmaterial des Element-Screenshots.

Fix 1: Bildqualität vor dem Übermitteln prüfen

Ein kurzer Vorab-Check fängt leere, winzige oder überkomprimierte Bilder ab, bevor sie an CaptchaAI gehen – so verbrauchen Sie keine Threads für aussichtslose Übermittlungen.

import base64
from io import BytesIO
from PIL import Image


def validate_captcha_image(image_path):
    """Check image quality before submitting to CaptchaAI."""
    img = Image.open(image_path)
    width, height = img.size
    issues = []

    # Minimum resolution
    if width < 50 or height < 20:
        issues.append(f"Too small: {width}x{height}px (min 50x20)")

    # Check if mostly blank
    pixels = list(img.getdata())
    if img.mode == "RGB":
        white_count = sum(1 for p in pixels if p[0] > 250 and p[1] > 250 and p[2] > 250)
    else:
        white_count = sum(1 for p in pixels if p > 250)

    blank_ratio = white_count / len(pixels)
    if blank_ratio > 0.95:
        issues.append(f"Image appears blank ({blank_ratio:.0%} white)")

    # File size check
    img_bytes = BytesIO()
    img.save(img_bytes, format="PNG")
    size_kb = img_bytes.tell() / 1024
    if size_kb < 1:
        issues.append(f"File too small ({size_kb:.1f} KB) — may be empty")
    if size_kb > 600:
        issues.append(f"File too large ({size_kb:.0f} KB) — submit under 600 KB")

    return issues


issues = validate_captcha_image("captcha.png")
if issues:
    for issue in issues:
        print(f"WARNING: {issue}")
else:
    print("Image quality OK")

Fix 2: Base64-Kodierung korrekt umsetzen

Die häufigste Kauderwelsch-Antwort entsteht, wenn versehentlich der Dateiname statt des Dateiinhalts kodiert wird. Ein Roundtrip-Check – kodieren, dekodieren, mit dem Original vergleichen – schließt das zuverlässig aus.

import base64


def encode_captcha(image_path):
    """Properly encode a CAPTCHA image to base64."""
    with open(image_path, "rb") as f:
        raw = f.read()

    encoded = base64.b64encode(raw).decode("ascii")

    # Verify round-trip
    decoded = base64.b64decode(encoded)
    assert decoded == raw, "Base64 encoding corrupted the image"

    return encoded


# WRONG — encoding a file path string
bad = base64.b64encode(b"captcha.png").decode()  # Encodes filename, not image!

# CORRECT — encoding file contents
with open("captcha.png", "rb") as f:
    good = base64.b64encode(f.read()).decode()

Fix 3: Bildvorverarbeitung für schwierige Fälle

Nur nötig, wenn das Original wirklich grenzwertig ist: sehr kleine Bilder hochskalieren, Kontrast anheben, schärfen. Standard-CAPTCHAs brauchen das in der Regel nicht.

from PIL import Image, ImageFilter, ImageEnhance
from io import BytesIO
import base64


def preprocess_captcha(image_path):
    """Improve image quality for better OCR accuracy."""
    img = Image.open(image_path)

    # Convert to RGB if needed
    if img.mode != "RGB":
        img = img.convert("RGB")

    # Upscale small images
    width, height = img.size
    if width < 200:
        scale = 200 / width
        img = img.resize(
            (int(width * scale), int(height * scale)),
            Image.LANCZOS,
        )

    # Increase contrast
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(1.5)

    # Sharpen
    img = img.filter(ImageFilter.SHARPEN)

    # Convert to PNG bytes
    buffer = BytesIO()
    img.save(buffer, format="PNG")
    return base64.b64encode(buffer.getvalue()).decode()

Wann sich Vorverarbeitung lohnt – und wann sie schadet

Vorverarbeitung ist kein Allheilmittel. Bei sauberen Standardbildern kann zu aggressives Schärfen oder ein zu hoher Kontrast Kanten überzeichnen und die Erkennung sogar verschlechtern. Setzen Sie sie deshalb gezielt ein: bei sehr kleinen Bildern das Hochskalieren, bei blassen oder rauschigen Vorlagen eine moderate Kontrastanhebung.

Ein praktischer Ansatz ist A/B-Testen über ein paar Dutzend Beispiele: Übermitteln Sie dieselben CAPTCHAs einmal roh und einmal vorverarbeitet und vergleichen Sie die Trefferquote. Behalten Sie nur die Schritte, die messbar helfen – und lassen Sie den Rest weg, statt jede Pipeline pauschal mit Filtern zu überfrachten.

Fix 4: Typ- und Sprach-Hinweise mitgeben

Sagen Sie dem Dienst, was er sieht: nur Ziffern, feste Länge, Groß-/Kleinschreibung relevant. Diese Hinweise engen den Lösungsraum ein und erhöhen die Trefferquote spürbar.

import requests


def solve_image(api_key, image_base64, **hints):
    """Submit image CAPTCHA with quality hints."""
    data = {
        "key": api_key,
        "method": "base64",
        "body": image_base64,
        "json": 1,
    }

    # Add optional hints for better accuracy
    if "language" in hints:
        data["language"] = hints["language"]  # 0=default, 1=Cyrillic, 2=Latin
    if "textinstructions" in hints:
        data["textinstructions"] = hints["textinstructions"]
    if "numeric" in hints:
        data["numeric"] = hints["numeric"]  # 1=digits only, 2=letters only
    if "min_len" in hints:
        data["min_len"] = hints["min_len"]
    if "max_len" in hints:
        data["max_len"] = hints["max_len"]

    resp = requests.post("https://ocr.captchaai.com/in.php", data=data, timeout=30)
    return resp.json()


# Example: Digits-only CAPTCHA, 4-6 characters
result = solve_image(
    "YOUR_API_KEY",
    encoded_image,
    numeric=1,
    min_len=4,
    max_len=6,
)

# Example: Case-sensitive text
result = solve_image(
    "YOUR_API_KEY",
    encoded_image,
    textinstructions="Case-sensitive, enter exactly as shown",
)

Fix 5: Nur das CAPTCHA-Element erfassen

Ein Screenshot der ganzen Seite bringt Ränder und Nachbar-Elemente ins Bild und verwässert das OCR. Fotografieren Sie gezielt das Element – das behebt in der Praxis die meisten „fast richtig"-Fälle.

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


def capture_captcha_element(driver, selector):
    """Screenshot only the CAPTCHA element, not the full page."""
    element = driver.find_element(By.CSS_SELECTOR, selector)

    # Element screenshot (better than page crop)
    png_bytes = element.screenshot_as_png

    # Verify it's not empty
    if len(png_bytes) < 500:
        raise ValueError("Screenshot too small — element may not be visible")

    return base64.b64encode(png_bytes).decode()


# Usage
driver = webdriver.Chrome()
driver.get("https://example.com")
image_b64 = capture_captcha_element(driver, "img#captchaImage")

Fix 6: Dynamische und rotierende CAPTCHAs abfangen

Manche Bilder wechseln im Sekundentakt oder laufen schnell ab. Erfassen und übermitteln Sie in einem Zug, ohne Zwischenschritte, und fragen Sie das Ergebnis danach ab.

import time


def solve_with_fresh_image(driver, api_key, captcha_selector):
    """Capture and solve CAPTCHA immediately to avoid expiry."""
    # Wait for CAPTCHA to load fully
    time.sleep(2)

    # Capture fresh
    element = driver.find_element(By.CSS_SELECTOR, captcha_selector)
    png_bytes = element.screenshot_as_png
    body = base64.b64encode(png_bytes).decode()

    # Submit immediately
    resp = requests.post("https://ocr.captchaai.com/in.php", data={
        "key": api_key,
        "method": "base64",
        "body": body,
        "json": 1,
    }, timeout=30)
    result = resp.json()

    if result.get("status") != 1:
        raise RuntimeError(result.get("request"))

    task_id = result["request"]

    # Poll — image CAPTCHAs solve fast
    time.sleep(5)
    for _ in range(12):
        resp = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": api_key, "action": "get",
            "id": task_id, "json": 1,
        }, timeout=15)
        data = resp.json()

        if data.get("status") == 1:
            return data["request"]
        if data["request"] != "CAPCHA_NOT_READY":
            raise RuntimeError(data["request"])
        time.sleep(3)

    raise TimeoutError("Image solve timeout")

Checkliste zur schnellen Fehlerbehebung

Vom Symptom zur Ursache – arbeiten Sie die Zeile ab, die auf Ihren Fall passt:

Falsche Antworten korrekt zurückmelden

Bleibt eine Antwort trotz sauberem Bild falsch, melden Sie sie über den Endpunkt reportbad mit der zugehörigen Aufgaben-ID zurück. Das fließt in die Qualitätsauswertung ein und kann zu einer Gutschrift auf Ihrem Guthaben führen. Wichtig: Melden Sie nur nachweislich falsch gelöste CAPTCHAs. Antworten, die die Zielseite aus anderen Gründen ablehnt – etwa wegen eines abgelaufenen Formular-Tokens oder eines Rate-Limits –, gehören nicht in diese Rückmeldung, weil sie das Signal verfälschen.

Häufige Fragen

Woran erkenne ich, ob das Bild oder der Dienst schuld ist?

Am Bild – in nahezu allen Fällen. Speichern Sie das exakte Bild, das Sie übermitteln, lokal ab und öffnen Sie es. Ist es leer, verpixelt oder abgeschnitten, haben Sie die Ursache. Kommt bei sauberem Bild trotzdem Unsinn zurück, prüfen Sie die Base64-Kodierung (Fix 2).

Welche Parameter verbessern die Trefferquote bei Text-Bild-CAPTCHAs?

Vor allem numeric (nur Ziffern oder nur Buchstaben), min_len/max_len für eine feste Zeichenlänge und textinstructions für Sonderfälle wie Groß-/Kleinschreibung. Jeder Hinweis engt den Lösungsraum ein und reduziert Fehlinterpretationen.

Muss ich Bilder grundsätzlich vorverarbeiten?

Nein. Standard-CAPTCHA-Bilder verarbeitet CaptchaAI ohne Vorverarbeitung zuverlässig. Sinnvoll ist sie nur bei Grenzfällen – sehr kleine, kontrastarme oder stark komprimierte Bilder profitieren vom Hochskalieren und einer Kontrastanhebung (Fix 3).

Welche Bildgröße und welches Format sollte ich übermitteln?

PNG mit mindestens 50×20 Pixel und unter 600 KB. Verzichten Sie auf verlustbehaftete JPEG-Komprimierung und auf mehrfaches Neu-Kodieren, da beides Artefakte an den Zeichenkanten erzeugt und die Erkennung erschwert.

Wie melde ich eine falsche Antwort?

Über den Endpunkt reportbad mit der zugehörigen Aufgaben-ID. Das meldet die Fehllösung zurück und kann zu einer Gutschrift führen. Melden Sie nur nachweislich falsche Antworten, nicht solche, die die Website aus anderen Gründen ablehnt.

Verwandte Leitfäden

• Sinkende Erfolgsquote diagnostizieren
• API-Antworten validieren und Fehler deuten

Bild-CAPTCHAs zuverlässig lösen – jetzt CaptchaAI testen.