Résolution mathématique de CAPTCHA avec le paramètre de calcul CaptchaAI

Pour résoudre un CAPTCHA mathématique, un seul paramètre compte : calc. Réglé sur 1, il demande à CaptchaAI de calculer l'équation affichée et de renvoyer le résultat (10) plutôt que son texte (3+7). Vous récupérez une réponse prête à insérer, sans la parser côté client.

Où vous rencontrez ces CAPTCHA

Les CAPTCHA mathématiques restent courants sur les formulaires à faible enjeu, là où un défi léger suffit à filtrer le trafic automatisé basique. Vous les croisez surtout sur :

• les formulaires d'inscription et de création de compte ;
• les pages de contact et les formulaires de support ;
• les portails de prise de rendez-vous et les espaces adhérents ;
• d'anciens forums et CMS qui embarquent encore un widget arithmétique maison.

Dans tous ces cas, le champ attend un entier — c'est exactement ce que calc=1 vous renvoie.

Ce que fait le paramètre calc

Tout dépend d'une seule valeur envoyée avec la requête :

L'appel de base pour résoudre l'équation

La mécanique est celle d'une résolution OCR classique : l'image base64 part vers in.php, puis vous interrogez res.php jusqu'au résultat. Seuls calc=1 et numeric=1 changent — calcul de l'équation, résultat numérique.

Le cycle tient en trois temps :

• vous envoyez l'image encodée en base64 à in.php avec calc=1 et numeric=1 ;
• vous récupérez un identifiant de tâche, puis vous interrogez res.php toutes les cinq secondes ;
• dès que le statut passe à 1, le champ request contient le résultat calculé, prêt à insérer.

import requests
import base64
import time
import os

API_KEY = os.environ["CAPTCHAAI_API_KEY"]


def solve_math_captcha(image_b64):
    """Solve a math CAPTCHA — returns the computed result."""
    resp = requests.post("https://ocr.captchaai.com/in.php", data={
        "key": API_KEY,
        "method": "base64",
        "body": image_b64,
        "calc": 1,          # Compute the math
        "numeric": 1,       # Result will be a number
        "json": 1,
    }, timeout=30)

    result = resp.json()
    if result.get("status") != 1:
        raise RuntimeError(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")


# Example: Image shows "3 + 7 = ?"
# With calc=0: Returns "3+7"
# With calc=1: Returns "10"

Reconnaître les formats courants

CaptchaAI gère l'arithmétique de base et certaines formulations en toutes lettres :

Format              Example        Result
─────────────────────────────────────────
Addition            3 + 7 = ?      10
Subtraction         15 - 8 = ?     7
Multiplication      4 × 6 = ?      24
Division            20 ÷ 5 = ?     4
Mixed               3 + 4 × 2 = ?  11
Text-based          "three plus five"  8

Pourquoi ajouter numeric

calc=1 déclenche le calcul ; numeric=1 signale en plus que la réponse attendue est un nombre. Combinés, ils réduisent les lectures ambiguës — un 0 pris pour la lettre « O », par exemple — et vous évitent une étape de nettoyage côté client. Sur des équations purement arithmétiques, gardez toujours les deux ensemble.

Guider la lecture avec des instructions textuelles

Quand l'équation est ambiguë ou en langage naturel, textinstructions précise le résultat attendu — par exemple pour une consigne « additionnez les deux nombres ».

def solve_text_math_captcha(image_b64, instructions):
    """Solve a math CAPTCHA with custom instructions."""
    resp = requests.post("https://ocr.captchaai.com/in.php", data={
        "key": API_KEY,
        "method": "base64",
        "body": image_b64,
        "calc": 1,
        "textinstructions": instructions,
        "json": 1,
    }, timeout=30)
    return resp.json()


# Example instructions:
# "Solve the math expression and enter the number"
# "What is the result of the equation shown?"
# "Enter the sum of the two numbers"

Fiabiliser la sortie

En production, la réponse n'est pas toujours propre : espaces, résultat négatif, décimale pour une équation entière. La fonction suivante nettoie la sortie (les négatifs comme "-3" sont conservés) puis bascule en repli — calc=0 plus calcul local — si la réponse n'est pas un nombre.

# edge_cases.py


def validate_math_result(answer):
    """Validate and clean math CAPTCHA result."""
    if not answer:
        return None

    # Remove spaces
    answer = answer.strip()

    # Handle negative results
    if answer.startswith("-"):
        try:
            return str(int(answer))
        except ValueError:
            return answer

    # Handle decimal results
    try:
        num = float(answer)
        if num == int(num):
            return str(int(num))
        return str(num)
    except ValueError:
        return answer


def solve_math_with_fallback(image_b64):
    """Try calc=1, fall back to manual parsing if needed."""
    # Try with calc
    result = solve_math_captcha(image_b64)

    # Validate result is actually a number
    try:
        float(result)
        return result
    except (ValueError, TypeError):
        pass

    # Fallback: solve without calc and compute locally
    resp = requests.post("https://ocr.captchaai.com/in.php", data={
        "key": API_KEY,
        "method": "base64",
        "body": image_b64,
        "calc": 0,      # Get the expression text
        "json": 1,
    }, timeout=30)

    # ... poll for result ...
    expression = "3+7"  # Example OCR result

    # Safely evaluate
    return str(safe_eval(expression))


def safe_eval(expression):
    """Safely evaluate a simple math expression."""
    # Only allow digits and basic operators
    import re
    cleaned = expression.replace("×", "*").replace("÷", "/").replace("=", "").replace("?", "")
    cleaned = cleaned.strip()

    if not re.match(r'^[\d\s+\-*/().]+$', cleaned):
        raise ValueError(f"Unsafe expression: {expression}")

    return eval(cleaned)  # Safe because we validated the pattern

Intégrer dans un flux Selenium

Sur une vraie page, la résolution s'insère entre la capture de l'image et l'envoi du formulaire. Si vous automatisez vos propres formulaires (tests QA en staging, démarche autorisée), minimisez les données personnelles et vérifiez vos obligations RGPD avant journalisation.

# full_flow.py
from selenium import webdriver
from selenium.webdriver.common.by import By
import base64
import os


def solve_math_captcha_on_page(driver, captcha_selector, input_selector, submit_selector):
    """Complete flow: capture math CAPTCHA, solve, enter answer."""

    # Capture CAPTCHA image
    captcha_el = driver.find_element(By.CSS_SELECTOR, captcha_selector)
    image_b64 = captcha_el.screenshot_as_base64

    # Solve with calc=1
    answer = solve_math_captcha(image_b64)
    print(f"Math answer: {answer}")

    # Enter the computed result
    input_el = driver.find_element(By.CSS_SELECTOR, input_selector)
    input_el.clear()
    input_el.send_keys(answer)

    # Submit
    driver.find_element(By.CSS_SELECTOR, submit_selector).click()


# Usage
driver = webdriver.Chrome()
driver.get("https://example.com/form")

solve_math_captcha_on_page(
    driver,
    captcha_selector="#captcha-image",
    input_selector="#captcha-answer",
    submit_selector="#submit-btn",
)

En production : quelques réflexes

• validez toujours la réponse avant de la soumettre : un résultat vide ou non numérique doit déclencher un repli ;
• journalisez le taux d'échec par format d'équation pour repérer un opérateur systématiquement mal lu ;
• gardez calc=1 et numeric=1 par défaut, et ne revenez à calc=0 que pour les expressions que l'API ne calcule pas ;
• prévoyez un timeout et une nouvelle tentative : une équation très déformée peut renvoyer ERROR_CAPTCHA_UNSOLVABLE.

Dépannage

FAQ

Quelle valeur de calc faut-il envoyer ?

Envoyez calc=1 pour le résultat calculé, plus numeric=1 si la réponse est un nombre. Par défaut, calc=0 renvoie seulement le texte.

Le paramètre calc entraîne-t-il un surcoût ?

Non. La facturation se fait par thread simultané (à partir de BASIC, $15/mois, 5 threads), résolutions illimitées par thread. Résoudre avec calc=1 occupe un thread le temps du calcul, comme toute autre image.

calc fonctionne-t-il avec les équations écrites en toutes lettres ?

Partiellement. Pour un défi « trois plus cinq », ajoutez textinstructions pour signaler un calcul en texte ; les résultats varient selon la formulation.

Faut-il prétraiter l'image avant l'envoi ?

En général non : envoyez la capture telle quelle. Si le résultat revient faux de façon répétée, un recadrage serré sur l'équation et une mise en niveaux de gris améliorent la lecture OCR avant de renvoyer l'image.

calc s'utilise-t-il depuis n'importe quel langage ?

Oui. C'est un simple paramètre de formulaire dans une requête POST vers in.php ; Python, Node.js, PHP, Go ou cURL l'envoient de la même façon. Le pack d'exemples couvre les principaux langages clients.

Guides connexes

• Réglages de précision de l'OCR
• Paramètres de longueur MinLen et MaxLen

Résolvez vos CAPTCHA mathématiques en un appel — ouvrez un compte CaptchaAI.