Résolution de CAPTCHA de texte cyrillique avec CaptchaAI

Les sites Web russes, ukrainiens, bulgares et serbes utilisent des CAPTCHA en cyrillique qui ressemblent trompeusement au latin : des caractères comme А, В, С, Е, Н, О semblent identiques à leurs homologues latins mais sont des points de code Unicode complètement différents. Cela crée des défis de reconnaissance et de soumission uniques que l'OCR latin standard manque.

Caractères cyrilliques ou latins pouvant être confondus

La soumission d’un mauvais point de code entraîne le rejet du texte d’apparence correcte lors de la validation du formulaire.

Python : CAPTCHA d'image cyrillique

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]}")

JavaScript : gestion des CAPTCHA cyrilliques

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

Modèles CAPTCHA cyrilliques courants

Dépannage

FAQ

Comment CaptchaAI distingue-t-il le cyrillique В du latin B ?

Les modèles OCR de CaptchaAI sont formés sur les fonctionnalités de contexte et de glyphe. Lorsque language=2 est défini, le solveur utilise des modèles prenant en charge le cyrillique qui renvoient les points de code Unicode appropriés. Le texte renvoyé utilisera des caractères cyrilliques (U+0400 – U+04FF) pour le texte russe.

Gère-t-il les caractères spécifiques à l'ukrainien ?

Oui. L'ukrainien utilise des caractères non présents en russe : Ò (U+0491), Ñ » (U+0454), і (U+0456), ї (U+0457). CaptchaAI les reconnaît avec language=2. Le solveur gère tous les scripts cyrilliques, notamment le russe, l'ukrainien, le bulgare et le serbe.

Et si le CAPTCHA mélangeait le cyrillique et le latin ?

Certains CAPTCHA mélangent intentionnellement des scripts pour créer une ambiguïté. CaptchaAI renvoie le texte avec les points de code Unicode corrects pour chaque caractère. Vérifiez à l'aide de la fonction verify_cyrillic() ou en inspectant les points de code.

Prochaines étapes

Résolvez les CAPTCHA cyrilliques sur les sites Web russes et slaves –récupérez votre clé API CaptchaAI.

Guides associés :

• Résoudre les CAPTCHA sur les sites Web chinois
• Jeu de caractères CAPTCHA pour images multilingues
• Localisation CAPTCHA et paramètres de langue