Automatiser des connexions protégées par CAPTCHA avec CaptchaAI

Les pages de connexion sont l'endroit où les CAPTCHA apparaissent le plus souvent. C'est logique : elles protègent un point d'entrée sensible, souvent exposé aux bots, aux tests agressifs et aux tentatives en masse. Pour automatiser un login, il ne suffit donc pas de remplir un formulaire. Il faut aussi gérer le challenge au bon moment, conserver la session et ne pas perdre les cookies ou les jetons CSRF pendant le processus.

CaptchaAI prend en charge la résolution du challenge pendant que votre script pilote le reste : chargement de page, remplissage des champs, soumission et maintien de la session authentifiée.

Types de CAPTCHA les plus courants sur les pages de connexion

Méthode 1 : requêtes HTTP sans navigateur

Cette approche convient aux formulaires qui acceptent encore une soumission POST classique sans logique JavaScript trop lourde.

import requests
import time

API_KEY = "YOUR_API_KEY"

def solve_recaptcha(site_key, page_url):
    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY, "method": "userrecaptcha",
        "googlekey": site_key, "pageurl": page_url
    })
    task_id = resp.text.split("|")[1]
    for _ in range(60):
        time.sleep(5)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY, "action": "get", "id": task_id
        })
        if result.text == "CAPCHA_NOT_READY": continue
        if result.text.startswith("OK|"): return result.text.split("|")[1]
        raise Exception(result.text)
    raise TimeoutError()

# Login flow
session = requests.Session()
login_url = "https://example.com/login"

# Load login page to get cookies and site key
page = session.get(login_url)
# Extract site_key from the page HTML...
site_key = "6Le-wvkS..."

# Solve CAPTCHA
token = solve_recaptcha(site_key, login_url)

# Submit login form
resp = session.post(login_url, data={
    "username": "user@example.com",
    "password": "your_password",
    "g-recaptcha-response": token
})

if resp.url != login_url:
    print("Login successful!")
    # session now has auth cookies for subsequent requests

Méthode 2 : Selenium en Python

Quand la page dépend fortement de JavaScript, le navigateur automatisé devient souvent plus fiable qu'un simple requests.Session().

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import requests
import time

API_KEY = "YOUR_API_KEY"

options = webdriver.ChromeOptions()
options.add_argument("--disable-blink-features=AutomationControlled")
driver = webdriver.Chrome(options=options)

# Navigate to login page
driver.get("https://example.com/login")
wait = WebDriverWait(driver, 10)

# Fill in credentials
username_field = wait.until(EC.presence_of_element_located((By.NAME, "username")))
username_field.send_keys("user@example.com")
driver.find_element(By.NAME, "password").send_keys("your_password")

# Extract site key and solve
recaptcha = driver.find_element(By.CLASS_NAME, "g-recaptcha")
site_key = recaptcha.get_attribute("data-sitekey")

token = solve_recaptcha(site_key, driver.current_url)

# Inject token
driver.execute_script(
    f"document.getElementById('g-recaptcha-response').innerHTML = '{token}';"
)

# Submit
driver.find_element(By.CSS_SELECTOR, 'button[type="submit"]').click()
wait.until(EC.url_changes(driver.current_url))
print(f"Logged in! Now at: {driver.current_url}")

Méthode 3 : Puppeteer en Node.js

const puppeteer = require("puppeteer");
const axios = require("axios");

const API_KEY = "YOUR_API_KEY";

async function solveRecaptcha(siteKey, pageUrl) {
  const submit = await axios.get("https://ocr.captchaai.com/in.php", {
    params: {
      key: API_KEY,
      method: "userrecaptcha",
      googlekey: siteKey,
      pageurl: pageUrl,
    },
  });
  const taskId = submit.data.split("|")[1];

  while (true) {
    await new Promise((r) => setTimeout(r, 5000));
    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: API_KEY, action: "get", id: taskId },
    });
    if (result.data === "CAPCHA_NOT_READY") continue;
    if (result.data.startsWith("OK|")) return result.data.split("|")[1];
    throw new Error(result.data);
  }
}

(async () => {
  const browser = await puppeteer.launch({ headless: "new" });
  const page = await browser.newPage();
  await page.goto("https://example.com/login");

  // Fill credentials
  await page.type("#username", "user@example.com");
  await page.type("#password", "your_password");

  // Get site key and solve
  const siteKey = await page.$eval(".g-recaptcha", (el) =>
    el.getAttribute("data-sitekey")
  );
  const token = await solveRecaptcha(siteKey, page.url());

  // Inject and submit
  await page.evaluate(
    (t) => (document.getElementById("g-recaptcha-response").innerHTML = t),
    token
  );
  await page.click('button[type="submit"]');
  await page.waitForNavigation();

  console.log("Logged in:", page.url());
  await browser.close();
})();

Gérer CAPTCHA et MFA dans le même flux

Certaines pages de connexion affichent d'abord un CAPTCHA, puis redirigent vers une étape MFA. Il faut alors considérer la résolution comme une étape du flux global, pas comme une opération isolée.

# Step 1: Solve CAPTCHA and submit login
token = solve_recaptcha(site_key, login_url)
resp = session.post(login_url, data={
    "username": "user@example.com",
    "password": "your_password",
    "g-recaptcha-response": token
})

# Step 2: Handle MFA page (if redirected)
if "verify" in resp.url or "mfa" in resp.url:
    # Your MFA code logic here
    mfa_code = get_mfa_code()
    resp = session.post(resp.url, data={"code": mfa_code})

# Step 3: Verify logged in
assert "dashboard" in resp.url

Depannage

FAQ

Peut-on automatiser n'importe quelle page de connexion ?

CaptchaAI couvre la partie CAPTCHA, mais votre script doit toujours gérer le formulaire, la session et les étapes d'authentification associées. Le cadre légal dépend évidemment de votre autorisation à accéder au compte et au service.

Faut-il toujours passer par un navigateur ?

Non. Beaucoup de formulaires de connexion acceptent encore un POST classique. Le navigateur est surtout nécessaire quand la page dépend d'exécution JavaScript, de rendu dynamique ou de callbacks front-end.

Comment garder la session après la connexion ?

Conservez les cookies et réutilisez la même session HTTP ou le même navigateur. Sans cela, toute la résolution CAPTCHA ne sert à rien puisque la session authentifiée est perdue juste après le login.

Guides connexes

• Gestion du CAPTCHA Selenium avec Python
• Résolution CAPTCHA avec Puppeteer en Node.js
• Gestion des CAPTCHA avec Playwright