Lösungsstrategien für Bild-CAPTCHA mit mehreren Zeichen

Komplexe Bild-CAPTCHAs verwenden verbundene Buchstaben, überlappende Zeichen, unterschiedliche Schriftarten und Rauschen, um OCR zu verhindern. Hier erfahren Sie, wie Sie mit CaptchaAI an sie herantreten.

Häufige Komplexitätstypen

Senden komplexer CAPTCHAs

Senden Sie Standard-CAPTCHAs mit mehreren Zeichen über base64 mit den entsprechenden Hinweisen:

import requests
import base64
import time
import os

API_KEY = os.environ["CAPTCHAAI_API_KEY"]


def solve_complex_image(image_b64, hints=None):
    """Solve a complex multi-character image CAPTCHA."""
    payload = {
        "key": API_KEY,
        "method": "base64",
        "body": image_b64,
        "json": 1,
    }

    if hints:
        payload.update(hints)

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

    if result.get("status") != 1:
        raise RuntimeError(f"Submit failed: {result.get('request')}")

    task_id = result["request"]

    time.sleep(8)
    for _ in range(24):
        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(5)

    raise TimeoutError("Solve timeout")

Strategie: Verbundene Buchstaben

Verbundene Buchstaben sind für die einfache OCR am schwierigsten, nicht jedoch für CaptchaAI:

def solve_connected_letters(image_path):
    """Solve CAPTCHA with connected/overlapping characters."""
    with open(image_path, "rb") as f:
        b64 = base64.b64encode(f.read()).decode("ascii")

    return solve_complex_image(b64, hints={
        "textinstructions": "Characters may be connected or overlapping",
        "minLen": 4,
        "maxLen": 8,
    })

Strategie: Gemischter Fall mit Rauschen

def solve_noisy_mixed(image_path):
    """Solve CAPTCHA with background noise and mixed case."""
    with open(image_path, "rb") as f:
        b64 = base64.b64encode(f.read()).decode("ascii")

    return solve_complex_image(b64, hints={
        "regsense": 1,         # Case-sensitive
        "language": 2,         # Latin characters
        "textinstructions": "Ignore background lines and noise",
    })

Strategie: Text mit mehreren Schriftarten

def solve_multi_font(image_path):
    """Solve CAPTCHA using multiple fonts per character."""
    with open(image_path, "rb") as f:
        b64 = base64.b64encode(f.read()).decode("ascii")

    return solve_complex_image(b64, hints={
        "textinstructions": "Each character may use a different font or style",
        "minLen": 5,
        "maxLen": 7,
    })

Bildvorverarbeitung für bessere Ergebnisse

Eine Vorverarbeitung vor der Übermittlung kann die Genauigkeit verbessern:

# preprocess.py
from PIL import Image, ImageFilter, ImageEnhance
import io
import base64


def preprocess_for_ocr(image_path):
    """Preprocess image to improve OCR accuracy."""
    img = Image.open(image_path)

    # Convert to grayscale
    img = img.convert("L")

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

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

    # Binarize (threshold)
    threshold = 128
    img = img.point(lambda p: 255 if p > threshold else 0)

    # Encode back to base64
    buffer = io.BytesIO()
    img.save(buffer, format="PNG")
    return base64.b64encode(buffer.getvalue()).decode("ascii")

Wiederholungsstrategie mit Berichterstellung

# retry_strategy.py


def solve_with_retry(image_b64, hints, max_retries=3):
    """Retry solving with fallback strategies."""
    strategies = [
        hints,                                          # Original hints
        {**hints, "textinstructions": ""},              # Without instructions
        {**hints, "numeric": 0, "regsense": 0},        # Relaxed constraints
    ]

    for i, strategy in enumerate(strategies[:max_retries]):
        try:
            result = solve_complex_image(image_b64, strategy)
            return {"text": result, "strategy": i, "success": True}
        except RuntimeError:
            continue

    return {"text": None, "strategy": -1, "success": False}


def report_bad_answer(task_id):
    """Report incorrect answer for quality feedback."""
    requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY,
        "action": "reportbad",
        "id": task_id,
    }, timeout=10)

Fehlerbehebung

FAQ

Sollte ich Bilder vor dem Absenden vorverarbeiten?

Nur wenn Sie schlechte Ergebnisse erzielen. CaptchaAI verarbeitet die meisten Verzerrungen nativ. Die Vorverarbeitung hilft bei sehr verrauschten oder kontrastarmen Bildern.

Was passiert, wenn derselbe Bildtyp immer wieder fehlschlägt?

Melden Sie schlechte Antworten mit reportbad, um die Genauigkeit zu verbessern. Versuchen Sie auch, spezifische textinstructions hinzuzufügen, die die CAPTCHA-Eigenschaften beschreiben.

Gibt es eine Zeichenbeschränkung für Bild-CAPTCHAs?

CaptchaAI kann CAPTCHAs mit bis zu etwa 20 Zeichen verarbeiten. Die meisten sind 4-8 Zeichen lang.

Verwandte Leitfäden

• Bild-CAPTCHA falsche Antwort Qualitätsoptimierung
• Bild-CAPTCHA Base64-Kodierung Best Practices

Komplexe Bild-CAPTCHAs lösen – Beginnen Sie mit CaptchaAI.