Un CAPTCHA mathématique vous demande de résoudre une opération simple — « Combien font 7 + 3 ? » — avant de valider un formulaire. Sa variante logique pose une question de bon sens (« De quelle couleur est le ciel ? ») ou fait compléter une suite de nombres. Ce sont les plus anciens et les plus faibles des CAPTCHA : une équation en texte HTML se lit en une ligne de code, et une équation en image se règle avec un OCR. Pourtant, vous les croiserez encore partout : formulaires de contact WordPress, espaces membres, applications internes jamais modernisées. Voici comment les reconnaître et les traiter proprement en automatisation.
Les cinq familles de CAPTCHA mathématiques et logiques
CAPTCHA arithmétiques simples
La forme la plus répandue : une addition, une soustraction ou une multiplication portant sur un ou deux chiffres. Vous en avez sûrement déjà croisé :
- « Combien font 3 + 5 ? »
- « 12 – 4 = ? »
- « 6 × 7 = ? »
La question est soit écrite en clair dans le HTML — donc immédiatement lisible par un script —, soit intégrée à une image, ce qui impose un passage par l'OCR.
Équations rendues en image
Ici, l'opération est dessinée dans une image pour empêcher toute lecture directe du texte : police déformée, chiffres colorés, fond bruité — par exemple « 14 + 23 = ? » en caractères tordus. Il faut alors un OCR pour extraire l'équation, puis un calcul pour la résoudre.
Nombres écrits en toutes lettres
Variante destinée à casser les expressions régulières : les nombres sont écrits en mots plutôt qu'en chiffres.
- « Combien font sept plus trois ? »
- « Tapez le résultat de douze moins cinq »
La détection réclame une petite couche d'analyse (NLP) pour reconvertir les mots en chiffres avant de calculer.
Questions de logique et de bon sens
Non arithmétiques, ces défis s'appuient sur des connaissances triviales :
- « De quelle couleur est l'herbe ? »
- « Combien de pattes a un chien ? »
- « Le feu est-il chaud ou froid ? »
Les réponses sortent presque toujours d'une banque de questions figée, ce qui les rend rejouables dès qu'on l'a cartographiée.
Suites et motifs à compléter
Le formulaire affiche une séquence et demande la valeur suivante :
- « Qu'est-ce qui vient ensuite : 2, 4, 6, 8 ? »
- « Complétez la suite : 1, 1, 2, 3, 5, ? »
Il faut ici une logique de reconnaissance de motifs (progression arithmétique, suite de Fibonacci, etc.).
Pourquoi ces CAPTCHA n'ont pas disparu
Malgré leur faiblesse, les CAPTCHA mathématiques restent très présents, pour des raisons pratiques :
- Simplicité — aucune dépendance à une API externe, aucun SDK JavaScript à charger.
- Écosystème WordPress — des extensions comme « Math CAPTCHA » ou « Really Simple CAPTCHA » sont installées sur des millions de sites.
- Faible friction — un petit calcul se résout plus vite qu'une grille d'images à cliquer.
- Accessibilité — en texte HTML, ils restent lisibles par les lecteurs d'écran, là où les CAPTCHA en image échouent.
- Systèmes hérités — beaucoup d'applications antérieures aux services CAPTCHA modernes n'ont jamais été migrées.
Prenons un cas concret : le formulaire de contact WordPress d'une PME hébergée chez OVHcloud, protégé par Really Simple CAPTCHA. Le plugin ajoute un « 4 + 1 = ? » en texte, suffisant pour filtrer les robots de spam les plus grossiers, mais inutile face à un script qui lit le DOM.
Ce qui se passe côté serveur
Le mécanisme est identique quelle que soit la présentation : le serveur génère une équation, conserve la réponse de son côté, puis compare ce que vous soumettez.
Le cas d'une équation en texte
Server generates random equation (e.g., "7 + 3")
↓
Stores answer (10) in server-side session
↓
Renders equation as HTML text or image
↓
User submits answer via form field
↓
Server compares submitted answer to stored answer
↓
Match → Form submitted Mismatch → Error shown
Le cas d'une équation en image
Server generates random equation
↓
Renders equation into a distorted image (noise, lines, color shifts)
↓
Image served to client via <img> tag
↓
User reads image, computes answer, types in form field
↓
Server validates submitted answer
Repérer un CAPTCHA mathématique dans vos scripts
Avant de résoudre, il faut détecter. Les deux scripts ci-dessous inspectent une page et signalent la présence de motifs arithmétiques, d'images de CAPTCHA ou de questions logiques.
En Python avec BeautifulSoup
import requests
from bs4 import BeautifulSoup
import re
def detect_math_captcha(url):
"""Detect common math CAPTCHA patterns on a page."""
response = requests.get(url, timeout=10)
soup = BeautifulSoup(response.text, "html.parser")
html = response.text.lower()
indicators = {
"text_math": False,
"image_math": False,
"logic_question": False,
}
# Check for text-based math questions
math_patterns = [
r"what is \d+\s*[\+\-\×\*]\s*\d+",
r"\d+\s*[\+\-\×\*]\s*\d+\s*=\s*\?",
r"solve:\s*\d+",
r"type the (result|answer|sum)",
]
for pattern in math_patterns:
if re.search(pattern, html):
indicators["text_math"] = True
break
# Check for CAPTCHA images near math-related labels
captcha_images = soup.find_all("img", attrs={
"alt": re.compile(r"captcha|math|verify", re.I)
})
if captcha_images:
indicators["image_math"] = True
# Check for logic questions
logic_patterns = [
r"what color is",
r"how many legs",
r"what comes next",
r"is .+ hot or cold",
]
for pattern in logic_patterns:
if re.search(pattern, html):
indicators["logic_question"] = True
break
return indicators
result = detect_math_captcha("https://example.com/contact")
print(result)
En Node.js avec Cheerio
const axios = require("axios");
const cheerio = require("cheerio");
async function detectMathCaptcha(url) {
const { data: html } = await axios.get(url, { timeout: 10000 });
const $ = cheerio.load(html);
const lower = html.toLowerCase();
const indicators = {
textMath: false,
imageMath: false,
logicQuestion: false,
};
// Text-based math patterns
const mathPatterns = [
/what is \d+\s*[+\-×*]\s*\d+/,
/\d+\s*[+\-×*]\s*\d+\s*=\s*\?/,
/solve:\s*\d+/,
/type the (result|answer|sum)/,
];
for (const pattern of mathPatterns) {
if (pattern.test(lower)) {
indicators.textMath = true;
break;
}
}
// Check for CAPTCHA images
$("img").each((_, el) => {
const alt = ($(el).attr("alt") || "").toLowerCase();
if (/captcha|math|verify/.test(alt)) {
indicators.imageMath = true;
}
});
return indicators;
}
detectMathCaptcha("https://example.com/contact").then(console.log);
Résoudre une équation en image avec l'OCR
Quand l'équation est une image, la marche à suivre tient en deux temps : l'OCR extrait le texte, puis un analyseur minimal calcule le résultat. Une équation en image relève du CAPTCHA image/OCR, un type pris en charge par CaptchaAI.
Exemple : l'API OCR de CaptchaAI
import requests
import time
import re
API_KEY = "YOUR_API_KEY"
CAPTCHA_IMAGE_URL = "https://example.com/captcha.png"
# Download the CAPTCHA image
image_data = requests.get(CAPTCHA_IMAGE_URL).content
# Submit to CaptchaAI OCR
import base64
b64_image = base64.b64encode(image_data).decode()
submit = requests.post("https://ocr.captchaai.com/in.php", data={
"key": API_KEY,
"method": "base64",
"body": b64_image,
"json": 1,
})
task_id = submit.json().get("request")
# Poll for result
for _ in range(30):
time.sleep(3)
result = requests.get("https://ocr.captchaai.com/res.php", params={
"key": API_KEY,
"action": "get",
"id": task_id,
"json": 1,
})
data = result.json()
if data.get("status") == 1:
ocr_text = data["request"] # e.g., "7 + 3"
print(f"OCR result: {ocr_text}")
# Parse and compute the answer
match = re.match(r"(\d+)\s*([+\-*/×])\s*(\d+)", ocr_text)
if match:
a, op, b = int(match.group(1)), match.group(2), int(match.group(3))
ops = {"+": a + b, "-": a - b, "*": a * b, "×": a * b, "/": a // b}
answer = ops.get(op)
print(f"Answer: {answer}")
break
elif "CAPCHA_NOT_READY" in str(data):
continue
Le script envoie l'image encodée en base64, interroge le résultat toutes les trois secondes, puis parse l'équation renvoyée pour la calculer.
Comparaison avec les autres familles de CAPTCHA
Situer les CAPTCHA mathématiques face aux mécanismes comportementaux aide à décider s'il faut les remplacer.
| Critère | CAPTCHA mathématiques | reCAPTCHA v2 | hCaptcha | CAPTCHA à curseur |
|---|---|---|---|---|
| Friction utilisateur | Faible (calcul mental rapide) | Moyenne (sélection d'images) | Moyenne (sélection d'images) | Faible (un seul glissement) |
| Résistance aux robots | Très faible | Élevée | Élevée | Moyenne |
| Accessibilité | Bonne (versions en texte) | Faible (dépend de la vue) | Faible (dépend de la vue) | Faible (dépend de la motricité) |
| Coût | Gratuit (auto-hébergé) | Palier gratuit disponible | Palier gratuit disponible | Variable |
| Usage typique | WordPress, formulaires de contact | Connexion, inscription | Connexion, inscription | E-commerce, marchés asiatiques |
Le constat est net : leur résistance aux robots reste très faible. Dès que le spam devient un vrai problème, un mécanisme comportemental comme reCAPTCHA v2/v3 ou Cloudflare Turnstile est bien plus adapté.
Questions fréquentes
CaptchaAI prend-il en charge les CAPTCHA mathématiques en image ?
Oui. Une équation rendue en image relève du type CAPTCHA image/OCR, pris en charge par CaptchaAI. Vous envoyez l'image à l'API OCR, vous récupérez le texte de l'équation (« 7 + 3 »), puis votre code calcule le résultat. Aucun sitekey n'est à configurer, contrairement à reCAPTCHA ou Turnstile.
Un CAPTCHA mathématique gêne-t-il les utilisateurs légitimes ?
Peu, tant que l'opération reste triviale. Un « 3 + 5 » se résout plus vite qu'une grille d'images, et les versions en texte HTML restent lisibles par les lecteurs d'écran — un point d'accessibilité que les CAPTCHA en image respectent mal. Le compromis : cette simplicité côté utilisateur est aussi ce qui les rend faciles à automatiser.
Les questions logiques sont-elles plus difficiles à automatiser que l'arithmétique ?
Un peu, mais pas beaucoup. Les questions de bon sens (« De quelle couleur est l'herbe ? ») proviennent presque toujours d'une banque figée ; une fois cartographiée, les réponses se rejouent. L'arithmétique, elle, se calcule directement. Aucune des deux familles n'offre de protection sérieuse face à un script déterminé.
Combien coûte la résolution de CAPTCHA en image chez CaptchaAI ?
La facturation repose sur des threads simultanés, pas sur le nombre de résolutions. Le plan BASIC ($15/mois, 5 threads) autorise un nombre illimité de résolutions par thread, et les paliers montent jusqu'à VIP-3 ($7,500/mois, 5 000 threads). Un formulaire WordPress à faible trafic tient largement dans le plus petit palier.
En résumé
Les CAPTCHA mathématiques et logiques forment la catégorie la plus simple, surtout présente sur les formulaires de contact WordPress et les systèmes hérités. Les versions en texte se lisent directement dans le HTML ; les versions en image demandent un OCR pour extraire l'équation, puis une arithmétique triviale. Pour ces dernières, appuyez-vous sur l'API OCR d'images de CaptchaAI. Faciles à automatiser, ces CAPTCHA doivent aujourd'hui leur survie à leur simplicité et à leur accessibilité, bien plus qu'à leur efficacité.
