Lösen von CAPTCHAs auf japanischen und koreanischen Websites

Wer japanische und koreanische Websites automatisiert erfasst, scheitert selten an der Ablauflogik – sondern an der Zeichenerkennung. Bild-CAPTCHAs mit Hiragana, Katakana, Kanji oder Hangul bringen jede auf Latein trainierte OCR an ihre Grenzen. Die kurze Antwort: Mit dem API-Parameter language=2 verarbeitet CaptchaAI genau diese CJK-Zeichensätze und liefert den erkannten Text als Token zurück – ganz ohne eigenes Modell.

Welche CAPTCHAs japanische und koreanische Websites einsetzen

Bild-CAPTCHAs mit landessprachlichen Zeichen dominieren die Login- und Suchformulare; tokenbasierte Verfahren laufen parallel dazu.

Hinweis: hCaptcha und FunCaptcha (Arkose Labs) kommen auf einigen dieser Seiten vor, werden von CaptchaAI aber nicht unterstützt. Bei den tokenbasierten reCAPTCHA-Varianten spielt die lokalisierte Oberfläche keine Rolle – Sie übergeben Sitekey und Page-URL, den Rest übernimmt der reCAPTCHA-Löser.

Zeichensätze verstehen: Hiragana, Katakana, Kanji, Hangul

Die Erkennungsstrategie ergibt sich aus den Schriftsystemen selbst. Japanisch kombiniert bis zu drei davon in einem einzigen Bild – der anspruchsvollste Fall überhaupt.

Python: Bild-CAPTCHA mit japanischen und koreanischen Zeichen lösen

Der Ablauf übermittelt das Bild Base64-kodiert mit language=2 an in.php und fragt res.php im Polling ab, bis der erkannte Text vorliegt. Das Polling läuft in bis zu 24 Durchgängen mit 5 Sekunden Abstand, bevor es in ein Timeout fällt. Dieselbe Logik deckt Japanisch und Koreanisch ab – CaptchaAI erkennt den CJK-Zeichensatz automatisch, sodass Sie keine getrennten Codepfade pflegen müssen.

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_japanese_captcha(image_path: str) -> str:
    """Solve a Japanese character 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,          # CJK 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_korean_captcha(image_path: str) -> str:
    """Solve a Korean hangul 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,
        "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_captcha_from_session(session: requests.Session,
                                captcha_url: str,
                                language: int = 2) -> str:
    """Download and solve a 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": str(language),
        "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")


# --- Usage ---

# Japanese CAPTCHA
jp_text = solve_japanese_captcha("japanese_captcha.png")
print(f"Japanese CAPTCHA: {jp_text}")

# Korean CAPTCHA from a live session
session = requests.Session()
session.headers["Accept-Language"] = "ko-KR,ko;q=0.9"
session.get("https://example.kr/login")  # establish session
kr_text = solve_captcha_from_session(session, "https://example.kr/captcha/image")
print(f"Korean CAPTCHA: {kr_text}")

JavaScript: CJK-CAPTCHAs in Node.js lösen

In Node.js ist der Ablauf identisch. solveFromUrl lädt das CAPTCHA innerhalb einer bestehenden Session inklusive Accept-Language-Header – wichtig, damit die Zielseite die passende, lokalisierte Variante ausliefert.

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 solveAsianCaptcha(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");
}

async function solveFromUrl(captchaUrl, cookies = "") {
  const resp = await fetch(captchaUrl, {
    headers: { Cookie: cookies, "Accept-Language": "ja-JP,ja;q=0.9" },
  });
  const buffer = await resp.arrayBuffer();
  const imageB64 = Buffer.from(buffer).toString("base64");

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

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

  const taskId = submitResp.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");
}

// Usage
const jpText = await solveAsianCaptcha("japanese_captcha.png");
console.log(`Japanese: ${jpText}`);

Praxisszenario und Kostenrahmen

Ein typischer DACH-Fall: Ein Preismonitoring-Team aus dem E-Commerce gleicht täglich Produktpreise auf japanischen und koreanischen Marktplätzen ab. An den Suchformularen stehen Bild-CAPTCHAs mit Hangul oder gemischten Schriften; über die OCR-Engine laufen sie automatisch durch, während die Automatisierung Formulare ausfüllt und absendet.

Weil CaptchaAI pro Thread abrechnet und nicht pro Lösung, bleibt der Rahmen planbar: BASIC (15 $/Monat, 5 Threads) deckt fünf parallele Lösungen ab, jeder Thread mit unbegrenzten Lösungen im Abrechnungsmonat. Sie skalieren über die Thread-Anzahl, nicht über ein Volumenlimit. Die Preise verstehen sich in US-Dollar. Sobald dabei personenbezogene Daten – etwa IP-Adressen – verarbeitet werden, greift die DSGVO: Klären Sie Rechtsgrundlage und Datenflüsse vorab.

Typische Fehler und ihre Lösung

Häufige Fragen

Was kostet das Lösen vieler japanischer und koreanischer CAPTCHAs?

CaptchaAI rechnet pro Thread ab, nicht pro Lösung. Jeder Thread enthält unbegrenzte Lösungen im Abrechnungsmonat – schon BASIC (15 $/Monat, 5 Threads) erlaubt fünf parallele Lösungen. Die Kosten skalieren über die Parallelität, nicht über das Volumen.

Löst CaptchaAI hCaptcha auf japanischen oder koreanischen Seiten?

Nein. hCaptcha und FunCaptcha (Arkose Labs) werden nicht unterstützt und dürfen in keiner Kalkulation als lösbar eingeplant werden. Für Bild-CAPTCHAs nutzen Sie die OCR-Engine, für die verbreiteten reCAPTCHA-Varianten den reCAPTCHA-Löser mit Sitekey und Page-URL.

Wie gehe ich mit mehreren Schriftsystemen in einem einzigen Bild um?

Der Fall aus Hiragana, Katakana und Kanji zusammen ist der anspruchsvollste. Mit language=2 verarbeitet CaptchaAI mehrere Schriften in einem Bild; für stabile Ergebnisse hilft eine möglichst hohe Bildauflösung.

Wozu dient der Accept-Language-Header beim Abruf?

Er signalisiert der Zielseite die gewünschte Sprache, sodass sie die japanische oder koreanische Variante ausliefert. Am Erkennungsergebnis selbst ändert er nichts – dafür ist allein language=2 maßgeblich. Setzen Sie ihn passend zur Region (ja-JP bzw. ko-KR), damit Sie das erwartete CAPTCHA erhalten.

Verwandte Leitfäden

• CAPTCHAs auf chinesischen Websites lösen
• GeeTest v3 per API lösen
• Raster-Bild-CAPTCHA in Node.js lösen