Kyrillischer Text CAPTCHA-Lösung mit CaptchaAI

Kyrillische Text-CAPTCHAs lösen Sie mit CaptchaAI, indem Sie das Bild an den OCR-Endpunkt senden und den Parameter language=2 setzen. Damit gibt der Solver die Zeichen als korrekte kyrillische Unicode-Codepunkte zurück – nicht als optisch ähnliche lateinische Ersatzzeichen. Genau daran scheitern Standard-OCR-Pipelines auf russischen, ukrainischen, bulgarischen und serbischen Seiten: Ein „А“ sieht aus wie ein lateinisches „A“, ist aber U+0410 statt U+0041. Wer den falschen Codepunkt übermittelt, kassiert vom Formular eine Ablehnung – obwohl der Text auf dem Bildschirm völlig richtig aussieht.

Warum kyrillische CAPTCHAs eine Sonderbehandlung brauchen

Das Kernproblem sind Homoglyphen: Zeichen, die in Latein und Kyrillisch nahezu identisch aussehen, aber unterschiedliche Codepunkte belegen. Rund ein Dutzend Großbuchstaben überlappen sich optisch fast perfekt. Die folgende Tabelle zeigt die häufigsten Verwechslungspaare:

Solange Ihre Extraktion nur auf das Aussehen achtet, fällt der Unterschied nicht auf. Die Validierung auf der Zielseite prüft jedoch den tatsächlichen Codepunkt – und lehnt ein lateinisches „B“ dort ab, wo ein kyrillisches „В“ (U+0412) erwartet wird.

Kyrillische CAPTCHAs erkennen: typische Varianten

Kyrillische Bild-CAPTCHAs tauchen in mehreren wiederkehrenden Varianten auf. Wer sie kennt, wundert sich nicht über gemischte Skripte oder ausgeschriebene Zahlwörter im Ergebnis:

Kyrillisches Bild-CAPTCHA in Python lösen

Der folgende Ablauf liest das Bild ein, übermittelt es Base64-kodiert an in.php und fragt das Ergebnis an res.php ab. Entscheidend ist language=2: Damit aktivieren Sie die Modelle für nicht-lateinische Schrift. Die Hilfsfunktion verify_cyrillic() bestätigt anschließend, dass die Antwort tatsächlich Zeichen aus dem kyrillischen Unicode-Block (U+0400–U+04FF) enthält.

import requests
import base64
import time

API_KEY = "YOUR_API_KEY"
SUBMIT_URL = "https://ocr.captchaai.com/in.php"
RESULT_URL = "https://ocr.captchaai.com/res.php"


def solve_cyrillic_captcha(image_path: str) -> str:
    """Solve a Cyrillic text image CAPTCHA."""
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    resp = requests.post(SUBMIT_URL, data={
        "key": API_KEY,
        "method": "base64",
        "body": image_b64,
        "language": 2,          # Non-Latin character support
        "json": 1,
    }, timeout=30).json()

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

    task_id = resp["request"]
    for _ in range(24):
        time.sleep(5)
        poll = requests.get(RESULT_URL, params={
            "key": API_KEY, "action": "get", "id": task_id, "json": 1,
        }, timeout=15).json()

        if poll.get("request") == "CAPCHA_NOT_READY":
            continue
        if poll.get("status") == 1:
            return poll["request"]
        raise RuntimeError(f"Solve: {poll.get('request')}")

    raise RuntimeError("Timeout")


def solve_cyrillic_from_session(session: requests.Session,
                                 captcha_url: str) -> str:
    """Solve a Cyrillic CAPTCHA within a session context."""
    resp = session.get(captcha_url, timeout=15)
    image_b64 = base64.b64encode(resp.content).decode()

    submit = requests.post(SUBMIT_URL, data={
        "key": API_KEY,
        "method": "base64",
        "body": image_b64,
        "language": 2,
        "json": 1,
    }, timeout=30).json()

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

    task_id = submit["request"]
    for _ in range(24):
        time.sleep(5)
        poll = requests.get(RESULT_URL, params={
            "key": API_KEY, "action": "get", "id": task_id, "json": 1,
        }, timeout=15).json()

        if poll.get("request") == "CAPCHA_NOT_READY":
            continue
        if poll.get("status") == 1:
            return poll["request"]
        raise RuntimeError(f"Solve: {poll.get('request')}")

    raise RuntimeError("Timeout")


def verify_cyrillic(text: str) -> bool:
    """Verify that solved text contains Cyrillic characters."""
    return any('\u0400' <= ch <= '\u04FF' for ch in text)


# --- Russian website form flow ---

def solve_russian_form(form_url: str, captcha_url: str,
                       form_data: dict) -> requests.Response:
    """Complete a Russian website form with CAPTCHA."""
    session = requests.Session()
    session.headers.update({
        "Accept-Language": "ru-RU,ru;q=0.9",
    })

    # Establish session
    session.get(form_url, timeout=15)

    # Solve CAPTCHA
    captcha_text = solve_cyrillic_from_session(session, captcha_url)
    print(f"Cyrillic CAPTCHA: {captcha_text}")

    if verify_cyrillic(captcha_text):
        print("Confirmed: contains Cyrillic characters")

    form_data["captcha"] = captcha_text
    return session.post(form_url, data=form_data, timeout=30)


# --- Usage ---

text = solve_cyrillic_captcha("russian_captcha.png")
print(f"Solved: {text}")
print(f"Is Cyrillic: {verify_cyrillic(text)}")
print(f"Unicode codepoints: {[hex(ord(c)) for c in text]}")

Kyrillische CAPTCHAs mit Node.js verarbeiten

In Node.js ist der Ablauf identisch: Bild einlesen, mit language: "2" übermitteln, den Status im Intervall abfragen und den zurückgegebenen Text prüfen. showCodepoints() macht sichtbar, welche Unicode-Werte der Solver geliefert hat – praktisch beim Debuggen gemischter Skripte.

const API_KEY = "YOUR_API_KEY";
const SUBMIT_URL = "https://ocr.captchaai.com/in.php";
const RESULT_URL = "https://ocr.captchaai.com/res.php";
const fs = require("fs");

async function solveCyrillicCaptcha(imagePath) {
  const imageB64 = fs.readFileSync(imagePath, "base64");

  const body = new URLSearchParams({
    key: API_KEY,
    method: "base64",
    body: imageB64,
    language: "2",
    json: "1",
  });

  const resp = await (await fetch(SUBMIT_URL, { method: "POST", body })).json();
  if (resp.status !== 1) throw new Error(`Submit: ${resp.request}`);

  const taskId = resp.request;
  for (let i = 0; i < 24; i++) {
    await new Promise((r) => setTimeout(r, 5000));
    const url = `${RESULT_URL}?key=${API_KEY}&action=get&id=${taskId}&json=1`;
    const poll = await (await fetch(url)).json();
    if (poll.request === "CAPCHA_NOT_READY") continue;
    if (poll.status === 1) return poll.request;
    throw new Error(`Solve: ${poll.request}`);
  }
  throw new Error("Timeout");
}

function isCyrillic(text) {
  return /[\u0400-\u04FF]/.test(text);
}

function showCodepoints(text) {
  return [...text].map((ch) => `${ch}=U+${ch.codePointAt(0).toString(16).padStart(4, "0")}`);
}

// Usage
const text = await solveCyrillicCaptcha("russian_captcha.png");
console.log(`Solved: ${text}`);
console.log(`Is Cyrillic: ${isCyrillic(text)}`);
console.log(`Codepoints: ${showCodepoints(text).join(", ")}`);

Kyrillische CAPTCHAs im Datenerfassungs-Workflow

Für Teams im DACH-Raum, die Daten von russisch- oder osteuropäischsprachigen Quellen erfassen, ist der Zeichensatz nur ein Teil der Aufgabe. Setzen Sie realistische Accept-Language-Header (ru-RU), halten Sie die Session über den kompletten Formularablauf stabil und extrahieren Sie Daten erst, nachdem das gelöste Token in derselben Sitzung akzeptiert wurde – genau das zeigt die Funktion solve_russian_form() oben.

CaptchaAI rechnet dabei nicht pro Lösung ab, sondern pro gleichzeitigem Thread. Bild- und OCR-CAPTCHAs teilen sich dieselben Threads wie alle anderen Typen; einen Aufpreis für kyrillische Inhalte gibt es nicht. Für einen einzelnen Scraper reicht meist der Tarif BASIC (15 $/Monat, 5 Threads); wer mehrere Quellen parallel abarbeitet, skaliert über STANDARD (30 $/Monat, 15 Threads) oder ADVANCE (90 $/Monat, 50 Threads) nach oben. Die Preise sind in US-Dollar angegeben.

Beachten Sie außerdem die rechtliche Seite: Sobald Sie personenbezogene Daten – dazu zählen nach DSGVO bereits IP-Adressen – von osteuropäischen Portalen erfassen, sollten Sie Zweck und Rechtsgrundlage der Verarbeitung dokumentieren. Das gehört zu Ihrer eigenen Sorgfaltspflicht, unabhängig vom eingesetzten CAPTCHA-Dienst.

Fehlerbehebung bei kyrillischen CAPTCHAs

Die meisten Probleme bei kyrillischen CAPTCHAs sind keine OCR-Fehler, sondern Kodierungs- oder Homoglyph-Fallen weiter unten im Ablauf. Diese Übersicht deckt die häufigsten Fälle ab:

Häufige Fragen

Welchen language-Wert muss ich für kyrillischen Text setzen?

language=2. Dieser Wert aktiviert die Modelle für nicht-lateinische Schrift und deckt Russisch, Ukrainisch, Bulgarisch und Serbisch gemeinsam ab. Ohne ihn interpretiert der Standard-OCR-Pfad kyrillische Zeichen häufig als lateinische Homoglyphen.

Was kostet das Lösen kyrillischer CAPTCHAs?

Nicht mehr als jeder andere Bildtyp. CaptchaAI berechnet Threads, keine einzelnen Lösungen – innerhalb eines Tarifs lösen Sie unbegrenzt viele CAPTCHAs pro Thread, ohne Aufschlag für den Zeichensatz. Der Einstieg liegt bei BASIC mit 15 $/Monat und 5 Threads.

Kann ich kyrillische CAPTCHAs parallel in großem Umfang lösen?

Ja. Der gleichzeitige Durchsatz hängt an Ihrer Thread-Zahl: Jeder Thread verarbeitet ein CAPTCHA zur Zeit und nimmt danach sofort das nächste. Mehr Threads bedeuten mehr parallele Lösungen – an der Code-Logik ändert sich nichts, Sie starten die Aufrufe lediglich nebenläufig.

Warum lehnt das Formular meinen scheinbar richtigen Text ab?

Fast immer wegen eines Homoglyphs: Ihr Text enthält ein lateinisches Zeichen, wo die Seite ein kyrillisches erwartet (oder umgekehrt). Übernehmen Sie den Rückgabewert von CaptchaAI unverändert und prüfen Sie im Zweifel die Unicode-Codepunkte, bevor Sie absenden.

Verwandte Leitfäden

• CAPTCHAs auf japanischen und koreanischen Websites lösen
• CAPTCHAs auf chinesischen Websites lösen
• Bild-CAPTCHAs mit Node.js lösen